diff --git a/src/stream.c b/src/stream.c
index fe48be4..a98ecb0 100644
--- a/src/stream.c
+++ b/src/stream.c
@@ -22,6 +22,7 @@
 
 #include <types/applet.h>
 #include <types/capture.h>
+#include <types/filters.h>
 #include <types/global.h>
 
 #include <proto/acl.h>
@@ -33,6 +34,7 @@
 #include <proto/connection.h>
 #include <proto/dumpstats.h>
 #include <proto/fd.h>
+#include <proto/filters.h>
 #include <proto/freq_ctr.h>
 #include <proto/frontend.h>
 #include <proto/hdr_idx.h>
@@ -74,6 +76,7 @@
 struct stream *stream_new(struct session *sess, struct task *t, enum obj_type *origin)
 {
 	struct stream *s;
+	struct filter *filter, *back;
 	struct connection *conn = objt_conn(origin);
 	struct appctx *appctx   = objt_appctx(origin);
 
@@ -214,6 +217,21 @@
 
 	HLUA_INIT(&s->hlua);
 
+	LIST_INIT(&s->strm_flt.filters);
+	memset(s->strm_flt.current, 0, sizeof(s->strm_flt.current));
+	list_for_each_entry(filter, &sess->fe->filters, list) {
+		struct filter *f = pool_alloc2(pool2_filter);
+		if (!f)
+			goto out_fail_accept;
+		memset(f, 0, sizeof(*f));
+		f->id    = filter->id;
+		f->ops   = filter->ops;
+		f->conf  = filter->conf;
+		LIST_ADDQ(&s->strm_flt.filters, &f->list);
+	}
+	if (flt_stream_start(s) < 0)
+		goto out_fail_accept;
+
 	/* finish initialization of the accepted file descriptor */
 	if (conn)
 		conn_data_want_recv(conn);
@@ -232,6 +250,10 @@
 
 	/* Error unrolling */
  out_fail_accept:
+	list_for_each_entry_safe(filter, back, &s->strm_flt.filters, list) {
+		LIST_DEL(&filter->list);
+		pool_free2(pool2_filter, filter);
+	}
 	LIST_DEL(&s->list);
 	pool_free2(pool2_stream, s);
 	return NULL;
@@ -246,6 +268,7 @@
 	struct proxy *fe = sess->fe;
 	struct bref *bref, *back;
 	struct connection *cli_conn = objt_conn(sess->origin);
+	struct filter *filter, *fback;
 	int i;
 
 	if (s->pend_pos)
@@ -306,6 +329,12 @@
 		s->txn = NULL;
 	}
 
+	flt_stream_stop(s);
+	list_for_each_entry_safe(filter, fback, &s->strm_flt.filters, list) {
+		LIST_DEL(&filter->list);
+		pool_free2(pool2_filter, filter);
+	}
+
 	if (fe) {
 		pool_free2(fe->rsp_cap_pool, s->res_cap);
 		pool_free2(fe->req_cap_pool, s->req_cap);
@@ -1166,6 +1195,7 @@
 	if (fe == s->be) {
 		s->req.analysers &= ~AN_REQ_INSPECT_BE;
 		s->req.analysers &= ~AN_REQ_HTTP_PROCESS_BE;
+		s->req.analysers &= ~AN_FLT_START_BE;
 	}
 
 	/* as soon as we know the backend, we must check if we have a matching forced or ignored
@@ -1206,7 +1236,7 @@
 
 	if (s->txn)
 		s->txn->status = 500;
-	s->req.analysers = 0;
+	s->req.analysers &= AN_FLT_END;
 	s->req.analyse_exp = TICK_ETERNITY;
 	return 0;
 }
@@ -1749,84 +1779,131 @@
 			ana_list = ana_back = req->analysers;
 			while (ana_list && max_loops--) {
 				/* Warning! ensure that analysers are always placed in ascending order! */
+				if (ana_list & AN_FLT_START_FE) {
+					if (!flt_start_analyze(s, req, AN_FLT_START_FE))
+						break;
+					UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_FLT_START_FE);
+				}
 
 				if (ana_list & AN_REQ_INSPECT_FE) {
+					if (!flt_analyze(s, req, AN_REQ_INSPECT_FE))
+						break;
 					if (!tcp_inspect_request(s, req, AN_REQ_INSPECT_FE))
 						break;
 					UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_INSPECT_FE);
 				}
 
 				if (ana_list & AN_REQ_WAIT_HTTP) {
+					if (!flt_analyze(s, req, AN_REQ_WAIT_HTTP))
+						break;
 					if (!http_wait_for_request(s, req, AN_REQ_WAIT_HTTP))
 						break;
 					UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_WAIT_HTTP);
 				}
 
 				if (ana_list & AN_REQ_HTTP_BODY) {
+					if (!flt_analyze(s, req, AN_REQ_HTTP_BODY))
+						break;
 					if (!http_wait_for_request_body(s, req, AN_REQ_HTTP_BODY))
 						break;
 					UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_HTTP_BODY);
 				}
 
 				if (ana_list & AN_REQ_HTTP_PROCESS_FE) {
+					if (!flt_analyze(s, req, AN_REQ_HTTP_PROCESS_FE))
+						break;
 					if (!http_process_req_common(s, req, AN_REQ_HTTP_PROCESS_FE, sess->fe))
 						break;
 					UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_HTTP_PROCESS_FE);
 				}
 
 				if (ana_list & AN_REQ_SWITCHING_RULES) {
+					if (!flt_analyze(s, req, AN_REQ_SWITCHING_RULES))
+						break;
 					if (!process_switching_rules(s, req, AN_REQ_SWITCHING_RULES))
 						break;
 					UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_SWITCHING_RULES);
 				}
 
 				if (ana_list & AN_REQ_INSPECT_BE) {
+					if (!flt_analyze(s, req, AN_REQ_INSPECT_BE))
+						break;
 					if (!tcp_inspect_request(s, req, AN_REQ_INSPECT_BE))
 						break;
 					UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_INSPECT_BE);
 				}
 
 				if (ana_list & AN_REQ_HTTP_PROCESS_BE) {
+					if (!flt_analyze(s, req, AN_REQ_HTTP_PROCESS_BE))
+						break;
 					if (!http_process_req_common(s, req, AN_REQ_HTTP_PROCESS_BE, s->be))
 						break;
 					UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_HTTP_PROCESS_BE);
 				}
 
 				if (ana_list & AN_REQ_HTTP_TARPIT) {
+					if (!flt_analyze(s, req, AN_REQ_HTTP_TARPIT))
+						break;
 					if (!http_process_tarpit(s, req, AN_REQ_HTTP_TARPIT))
 						break;
 					UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_HTTP_TARPIT);
 				}
 
 				if (ana_list & AN_REQ_SRV_RULES) {
+					if (!flt_analyze(s, req, AN_REQ_SRV_RULES))
+						break;
 					if (!process_server_rules(s, req, AN_REQ_SRV_RULES))
 						break;
 					UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_SRV_RULES);
 				}
 
 				if (ana_list & AN_REQ_HTTP_INNER) {
+					if (!flt_analyze(s, req, AN_REQ_HTTP_INNER))
+						break;
 					if (!http_process_request(s, req, AN_REQ_HTTP_INNER))
 						break;
 					UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_HTTP_INNER);
 				}
 
 				if (ana_list & AN_REQ_PRST_RDP_COOKIE) {
+					if (!flt_analyze(s, req, AN_REQ_PRST_RDP_COOKIE))
+						break;
 					if (!tcp_persist_rdp_cookie(s, req, AN_REQ_PRST_RDP_COOKIE))
 						break;
 					UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_PRST_RDP_COOKIE);
 				}
 
 				if (ana_list & AN_REQ_STICKING_RULES) {
+					if (!flt_analyze(s, req, AN_REQ_STICKING_RULES))
+						break;
 					if (!process_sticking_rules(s, req, AN_REQ_STICKING_RULES))
 						break;
 					UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_STICKING_RULES);
 				}
 
+				if (ana_list & AN_FLT_START_BE) {
+					if (!flt_start_analyze(s, req, AN_FLT_START_BE))
+						break;
+					UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_FLT_START_BE);
+				}
+
+				if (ana_list & AN_FLT_XFER_DATA) {
+					if (!flt_xfer_data(s, req, AN_FLT_XFER_DATA))
+						break;
+					UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_FLT_XFER_DATA);
+				}
+
 				if (ana_list & AN_REQ_HTTP_XFER_BODY) {
 					if (!http_request_forward_body(s, req, AN_REQ_HTTP_XFER_BODY))
 						break;
 					UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_REQ_HTTP_XFER_BODY);
 				}
+
+				if (ana_list & AN_FLT_END) {
+					if (!flt_end_analyze(s, req, AN_FLT_END))
+						break;
+					UPDATE_ANALYSERS(req->analysers, ana_list, ana_back, AN_FLT_END);
+				}
 				break;
 			}
 		}
@@ -1896,36 +1973,67 @@
 			ana_list = ana_back = res->analysers;
 			while (ana_list && max_loops--) {
 				/* Warning! ensure that analysers are always placed in ascending order! */
+				if (ana_list & AN_FLT_START_FE) {
+					if (!flt_start_analyze(s, res, AN_FLT_START_FE))
+						break;
+					UPDATE_ANALYSERS(res->analysers, ana_list, ana_back, AN_FLT_START_FE);
+				}
 
 				if (ana_list & AN_RES_INSPECT) {
+					if (!flt_analyze(s, res, AN_RES_INSPECT))
+						break;
 					if (!tcp_inspect_response(s, res, AN_RES_INSPECT))
 						break;
 					UPDATE_ANALYSERS(res->analysers, ana_list, ana_back, AN_RES_INSPECT);
 				}
 
 				if (ana_list & AN_RES_WAIT_HTTP) {
+					if (!flt_analyze(s, res, AN_RES_WAIT_HTTP))
+						break;
 					if (!http_wait_for_response(s, res, AN_RES_WAIT_HTTP))
 						break;
 					UPDATE_ANALYSERS(res->analysers, ana_list, ana_back, AN_RES_WAIT_HTTP);
 				}
 
 				if (ana_list & AN_RES_STORE_RULES) {
+					if (!flt_analyze(s, res, AN_RES_STORE_RULES))
+						break;
 					if (!process_store_rules(s, res, AN_RES_STORE_RULES))
 						break;
 					UPDATE_ANALYSERS(res->analysers, ana_list, ana_back, AN_RES_STORE_RULES);
 				}
 
 				if (ana_list & AN_RES_HTTP_PROCESS_BE) {
+					if (!flt_analyze(s, res, AN_RES_HTTP_PROCESS_BE))
+						break;
 					if (!http_process_res_common(s, res, AN_RES_HTTP_PROCESS_BE, s->be))
 						break;
 					UPDATE_ANALYSERS(res->analysers, ana_list, ana_back, AN_RES_HTTP_PROCESS_BE);
 				}
 
+				if (ana_list & AN_FLT_START_BE) {
+					if (!flt_start_analyze(s, res, AN_FLT_START_BE))
+						break;
+					UPDATE_ANALYSERS(res->analysers, ana_list, ana_back, AN_FLT_START_BE);
+				}
+
+				if (ana_list & AN_FLT_XFER_DATA) {
+					if (!flt_xfer_data(s, res, AN_FLT_XFER_DATA))
+						break;
+					UPDATE_ANALYSERS(res->analysers, ana_list, ana_back, AN_FLT_XFER_DATA);
+				}
+
 				if (ana_list & AN_RES_HTTP_XFER_BODY) {
 					if (!http_response_forward_body(s, res, AN_RES_HTTP_XFER_BODY))
 						break;
 					UPDATE_ANALYSERS(res->analysers, ana_list, ana_back, AN_RES_HTTP_XFER_BODY);
 				}
+
+				if (ana_list & AN_FLT_END) {
+					if (!flt_end_analyze(s, res, AN_FLT_END))
+						break;
+					UPDATE_ANALYSERS(res->analysers, ana_list, ana_back, AN_FLT_END);
+				}
 				break;
 			}
 		}