diff --git a/README.md b/README.md
index 7c54dd42..64b6e090 100644
--- a/README.md
+++ b/README.md
@@ -137,6 +137,69 @@ There are two types of callbacks:
 Callbacks must return 0 on success. Returning a non-zero value indicates
 error to the parser, making it exit immediately.
 
+For cases where it is necessary to pass local information to/from a callback,
+the `http_parser` object's `data` field can be used.
+An example of such a case is when using threads to handle a socket connection, 
+parse a request, and then give a response over that socket. By instantiation 
+of a thread-local struct containing relevant data (e.g. accepted socket, 
+allocated memory for callbacks to write into, etc), a parser's callbacks are 
+able to communicate data between the scope of the thread and the scope of the 
+callback in a threadsafe manner. This allows http-parser to be used in 
+multi-threaded contexts.
+
+Example:
+```
+ typedef struct {
+  socket_t sock;
+  void* buffer;
+  int buf_len;
+ } custom_data_t;
+ 
+ 
+int my_url_callback(http_parser* parser, const char *at, size_t length) {
+  /* access to thread local custom_data_t struct.
+  Use this access save parsed data for later use into thread local
+  buffer, or communicate over socket
+  */
+  parser->data;
+  ...
+  return 0;
+}
+
+...
+
+void http_parser_thread(socket_t sock) {
+ int nparsed = 0;
+ /* allocate memory for user data */
+ custom_data_t *my_data = malloc(sizeof(custom_data_t));
+ 
+ /* some information for use by callbacks.
+ * achieves thread -> callback information flow */
+ my_data->sock = sock;
+ 
+ /* instantiate a thread-local parser */
+ http_parser *parser = malloc(sizeof(http_parser)); 
+ http_parser_init(parser, HTTP_REQUEST); /* initialise parser */
+ /* this custom data reference is accessible through the reference to the
+ parser supplied to callback functions */
+ parser->data = my_data; 
+ 
+ http_parser_settings settings; / * set up callbacks */
+ settings.on_url = my_url_callback;
+ 
+ /* execute parser */
+ nparsed = http_parser_execute(parser, &settings, buf, recved);
+ 
+ ...
+ /* parsed information copied from callback.
+ can now perform action on data copied into thread-local memory from callbacks.
+ achieves callback -> thread information flow */
+ my_data->buffer; 
+ ...
+}
+
+```
+
 In case you parse HTTP message in chunks (i.e. `read()` request line
 from socket, parse, read half headers, parse, etc) your data callbacks
 may be called more than once. Http-parser guarantees that data pointer is only