diff --git a/ntex/src/web/app.rs b/ntex/src/web/app.rs
index 767b3306..0809c000 100644
--- a/ntex/src/web/app.rs
+++ b/ntex/src/web/app.rs
@@ -20,11 +20,11 @@ use super::dev::ResourceDef;
 use super::resource::Resource;
 use super::route::Route;
 use super::service::{
-    AppServiceFactory, HttpServiceFactory, ServiceFactoryWrapper, ServiceRequest,
-    ServiceResponse,
+    AppServiceFactory, HttpServiceFactory, ServiceFactoryWrapper, WebRequest,
+    WebResponse,
 };
 
-type HttpNewService = BoxServiceFactory<(), ServiceRequest, ServiceResponse, Error, ()>;
+type HttpNewService = BoxServiceFactory<(), WebRequest, WebResponse, Error, ()>;
 type FnDataFactory =
     Box<dyn Fn() -> LocalBoxFuture<'static, Result<Box<dyn DataFactory>, ()>>>;
 
@@ -65,8 +65,8 @@ where
     B: MessageBody,
     T: ServiceFactory<
         Config = (),
-        Request = ServiceRequest,
-        Response = ServiceResponse<B>,
+        Request = WebRequest,
+        Response = WebResponse<B>,
         Error = Error,
         InitError = (),
     >,
@@ -270,8 +270,8 @@ where
         F: IntoServiceFactory<U>,
         U: ServiceFactory<
                 Config = (),
-                Request = ServiceRequest,
-                Response = ServiceResponse,
+                Request = WebRequest,
+                Response = WebResponse,
                 Error = Error,
             > + 'static,
         U::InitError: fmt::Debug,
@@ -353,8 +353,8 @@ where
     ) -> App<
         impl ServiceFactory<
             Config = (),
-            Request = ServiceRequest,
-            Response = ServiceResponse<B1>,
+            Request = WebRequest,
+            Response = WebResponse<B1>,
             Error = Error,
             InitError = (),
         >,
@@ -363,8 +363,8 @@ where
     where
         M: Transform<
             T::Service,
-            Request = ServiceRequest,
-            Response = ServiceResponse<B1>,
+            Request = WebRequest,
+            Response = WebResponse<B1>,
             Error = Error,
             InitError = (),
         >,
@@ -420,8 +420,8 @@ where
     ) -> App<
         impl ServiceFactory<
             Config = (),
-            Request = ServiceRequest,
-            Response = ServiceResponse<B1>,
+            Request = WebRequest,
+            Response = WebResponse<B1>,
             Error = Error,
             InitError = (),
         >,
@@ -429,8 +429,8 @@ where
     >
     where
         B1: MessageBody,
-        F: FnMut(ServiceRequest, &mut T::Service) -> R + Clone,
-        R: Future<Output = Result<ServiceResponse<B1>, Error>>,
+        F: FnMut(WebRequest, &mut T::Service) -> R + Clone,
+        R: Future<Output = Result<WebResponse<B1>, Error>>,
     {
         App {
             endpoint: apply_fn_factory(self.endpoint, mw),
@@ -451,8 +451,8 @@ where
     B: MessageBody,
     T: ServiceFactory<
         Config = (),
-        Request = ServiceRequest,
-        Response = ServiceResponse<B>,
+        Request = WebRequest,
+        Response = WebResponse<B>,
         Error = Error,
         InitError = (),
     >,
@@ -480,7 +480,7 @@ mod tests {
     use crate::http::header::{self, HeaderValue};
     use crate::http::{Method, StatusCode};
     use crate::web::middleware::DefaultHeaders;
-    use crate::web::service::ServiceRequest;
+    use crate::web::service::WebRequest;
     use crate::web::test::{call_service, init_service, read_body, TestRequest};
     use crate::web::{self, HttpRequest, HttpResponse};
     use crate::Service;
@@ -504,12 +504,12 @@ mod tests {
                 .service(web::resource("/test").to(|| HttpResponse::Ok()))
                 .service(
                     web::resource("/test2")
-                        .default_service(|r: ServiceRequest| {
+                        .default_service(|r: WebRequest| {
                             ok(r.into_response(HttpResponse::Created()))
                         })
                         .route(web::get().to(|| HttpResponse::Ok())),
                 )
-                .default_service(|r: ServiceRequest| {
+                .default_service(|r: WebRequest| {
                     ok(r.into_response(HttpResponse::MethodNotAllowed()))
                 }),
         )
diff --git a/ntex/src/web/app_service.rs b/ntex/src/web/app_service.rs
index f73dddfb..fb9abf2b 100644
--- a/ntex/src/web/app_service.rs
+++ b/ntex/src/web/app_service.rs
@@ -17,50 +17,50 @@ use super::data::DataFactory;
 use super::guard::Guard;
 use super::request::{HttpRequest, HttpRequestPool};
 use super::rmap::ResourceMap;
-use super::service::{AppServiceFactory, ServiceRequest, ServiceResponse};
+use super::service::{AppServiceFactory, WebRequest, WebResponse};
 
 type Guards = Vec<Box<dyn Guard>>;
-type HttpService = BoxService<ServiceRequest, ServiceResponse, Error>;
-type HttpNewService = BoxServiceFactory<(), ServiceRequest, ServiceResponse, Error, ()>;
-type BoxResponse = LocalBoxFuture<'static, Result<ServiceResponse, Error>>;
+type HttpService = BoxService<WebRequest, WebResponse, Error>;
+type HttpNewService = BoxServiceFactory<(), WebRequest, WebResponse, Error, ()>;
+type BoxResponse = LocalBoxFuture<'static, Result<WebResponse, Error>>;
 type FnDataFactory =
     Box<dyn Fn() -> LocalBoxFuture<'static, Result<Box<dyn DataFactory>, ()>>>;
 
-/// Service factory to convert `Request` to a `ServiceRequest<S>`.
+/// Service factory to convert `Request` to a `WebRequest<S>`.
 /// It also executes data factories.
 pub struct AppInit<T, B>
 where
     T: ServiceFactory<
         Config = (),
-        Request = ServiceRequest,
-        Response = ServiceResponse<B>,
+        Request = WebRequest,
+        Response = WebResponse<B>,
         Error = Error,
         InitError = (),
     >,
 {
-    pub(crate) endpoint: T,
-    pub(crate) extensions: RefCell<Option<Extensions>>,
-    pub(crate) data: Rc<Vec<Box<dyn DataFactory>>>,
-    pub(crate) data_factories: Rc<Vec<FnDataFactory>>,
-    pub(crate) services: Rc<RefCell<Vec<Box<dyn AppServiceFactory>>>>,
-    pub(crate) default: Option<Rc<HttpNewService>>,
-    pub(crate) factory_ref: Rc<RefCell<Option<AppRoutingFactory>>>,
-    pub(crate) external: RefCell<Vec<ResourceDef>>,
+    pub(super) endpoint: T,
+    pub(super) extensions: RefCell<Option<Extensions>>,
+    pub(super) data: Rc<Vec<Box<dyn DataFactory>>>,
+    pub(super) data_factories: Rc<Vec<FnDataFactory>>,
+    pub(super) services: Rc<RefCell<Vec<Box<dyn AppServiceFactory>>>>,
+    pub(super) default: Option<Rc<HttpNewService>>,
+    pub(super) factory_ref: Rc<RefCell<Option<AppRoutingFactory>>>,
+    pub(super) external: RefCell<Vec<ResourceDef>>,
 }
 
 impl<T, B> ServiceFactory for AppInit<T, B>
 where
     T: ServiceFactory<
         Config = (),
-        Request = ServiceRequest,
-        Response = ServiceResponse<B>,
+        Request = WebRequest,
+        Response = WebResponse<B>,
         Error = Error,
         InitError = (),
     >,
 {
     type Config = AppConfig;
     type Request = Request;
-    type Response = ServiceResponse<B>;
+    type Response = WebResponse<B>;
     type Error = T::Error;
     type InitError = T::InitError;
     type Service = AppInitService<T::Service, B>;
@@ -69,7 +69,7 @@ where
     fn new_service(&self, config: AppConfig) -> Self::Future {
         // update resource default service
         let default = self.default.clone().unwrap_or_else(|| {
-            Rc::new(boxed::factory(fn_service(|req: ServiceRequest| {
+            Rc::new(boxed::factory(fn_service(|req: WebRequest| {
                 ok(req.into_response(Response::NotFound().finish()))
             })))
         });
@@ -149,8 +149,8 @@ impl<T, B> Future for AppInitResult<T, B>
 where
     T: ServiceFactory<
         Config = (),
-        Request = ServiceRequest,
-        Response = ServiceResponse<B>,
+        Request = WebRequest,
+        Response = WebResponse<B>,
         Error = Error,
         InitError = (),
     >,
@@ -202,10 +202,10 @@ where
     }
 }
 
-/// Service to convert `Request` to a `ServiceRequest<S>`
+/// Service to convert `Request` to a `WebRequest<S>`
 pub struct AppInitService<T, B>
 where
-    T: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    T: Service<Request = WebRequest, Response = WebResponse<B>, Error = Error>,
 {
     service: T,
     rmap: Rc<ResourceMap>,
@@ -216,10 +216,10 @@ where
 
 impl<T, B> Service for AppInitService<T, B>
 where
-    T: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    T: Service<Request = WebRequest, Response = WebResponse<B>, Error = Error>,
 {
     type Request = Request;
-    type Response = ServiceResponse<B>;
+    type Response = WebResponse<B>;
     type Error = T::Error;
     type Future = T::Future;
 
@@ -249,13 +249,13 @@ where
                 self.pool,
             )
         };
-        self.service.call(ServiceRequest::new(req))
+        self.service.call(WebRequest::new(req))
     }
 }
 
 impl<T, B> Drop for AppInitService<T, B>
 where
-    T: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    T: Service<Request = WebRequest, Response = WebResponse<B>, Error = Error>,
 {
     fn drop(&mut self) {
         self.pool.clear();
@@ -269,8 +269,8 @@ pub struct AppRoutingFactory {
 
 impl ServiceFactory for AppRoutingFactory {
     type Config = ();
-    type Request = ServiceRequest;
-    type Response = ServiceResponse;
+    type Request = WebRequest;
+    type Response = WebResponse;
     type Error = Error;
     type InitError = ();
     type Service = AppRouting;
@@ -374,13 +374,13 @@ impl Future for AppRoutingFactoryResponse {
 
 pub struct AppRouting {
     router: Router<HttpService, Guards>,
-    ready: Option<(ServiceRequest, ResourceInfo)>,
+    ready: Option<(WebRequest, ResourceInfo)>,
     default: Option<HttpService>,
 }
 
 impl Service for AppRouting {
-    type Request = ServiceRequest;
-    type Response = ServiceResponse;
+    type Request = WebRequest;
+    type Response = WebResponse;
     type Error = Error;
     type Future = BoxResponse;
 
@@ -392,7 +392,7 @@ impl Service for AppRouting {
         }
     }
 
-    fn call(&mut self, mut req: ServiceRequest) -> Self::Future {
+    fn call(&mut self, mut req: WebRequest) -> Self::Future {
         let res = self.router.recognize_mut_checked(&mut req, |req, guards| {
             if let Some(ref guards) = guards {
                 for f in guards {
@@ -410,7 +410,7 @@ impl Service for AppRouting {
             default.call(req)
         } else {
             let req = req.into_parts().0;
-            ok(ServiceResponse::new(req, Response::NotFound().finish())).boxed_local()
+            ok(WebResponse::new(req, Response::NotFound().finish())).boxed_local()
         }
     }
 }
@@ -428,8 +428,8 @@ impl AppEntry {
 
 impl ServiceFactory for AppEntry {
     type Config = ();
-    type Request = ServiceRequest;
-    type Response = ServiceResponse;
+    type Request = WebRequest;
+    type Response = WebResponse;
     type Error = Error;
     type InitError = ();
     type Service = AppRouting;
diff --git a/ntex/src/web/config.rs b/ntex/src/web/config.rs
index d94232f3..3a254076 100644
--- a/ntex/src/web/config.rs
+++ b/ntex/src/web/config.rs
@@ -12,13 +12,12 @@ use super::resource::Resource;
 use super::rmap::ResourceMap;
 use super::route::Route;
 use super::service::{
-    AppServiceFactory, HttpServiceFactory, ServiceFactoryWrapper, ServiceRequest,
-    ServiceResponse,
+    AppServiceFactory, HttpServiceFactory, ServiceFactoryWrapper, WebRequest,
+    WebResponse,
 };
 
 type Guards = Vec<Box<dyn Guard>>;
-type HttpNewService =
-    boxed::BoxServiceFactory<(), ServiceRequest, ServiceResponse, Error, ()>;
+type HttpNewService = boxed::BoxServiceFactory<(), WebRequest, WebResponse, Error, ()>;
 
 /// Application configuration
 pub struct AppService {
@@ -108,8 +107,8 @@ impl AppService {
         F: IntoServiceFactory<S>,
         S: ServiceFactory<
                 Config = (),
-                Request = ServiceRequest,
-                Response = ServiceResponse,
+                Request = WebRequest,
+                Response = WebResponse,
                 Error = Error,
                 InitError = (),
             > + 'static,
@@ -174,9 +173,9 @@ impl Default for AppConfig {
 /// to set of external methods. This could help with
 /// modularization of big application configuration.
 pub struct ServiceConfig {
-    pub(crate) services: Vec<Box<dyn AppServiceFactory>>,
-    pub(crate) data: Vec<Box<dyn DataFactory>>,
-    pub(crate) external: Vec<ResourceDef>,
+    pub(super) services: Vec<Box<dyn AppServiceFactory>>,
+    pub(super) data: Vec<Box<dyn DataFactory>>,
+    pub(super) external: Vec<ResourceDef>,
 }
 
 impl ServiceConfig {
diff --git a/ntex/src/web/handler.rs b/ntex/src/web/handler.rs
index 13419e6c..0d904702 100644
--- a/ntex/src/web/handler.rs
+++ b/ntex/src/web/handler.rs
@@ -14,7 +14,7 @@ use crate::{Service, ServiceFactory};
 use super::extract::FromRequest;
 use super::request::HttpRequest;
 use super::responder::Responder;
-use super::service::{ServiceRequest, ServiceResponse};
+use super::service::{WebRequest, WebResponse};
 
 /// Async handler converter factory
 pub trait Factory<T, R, O>: Clone + 'static
@@ -82,16 +82,16 @@ where
     O: Responder,
 {
     type Request = (T, HttpRequest);
-    type Response = ServiceResponse;
+    type Response = WebResponse;
     type Error = Infallible;
-    type Future = HandlerServiceResponse<R, O>;
+    type Future = HandlerWebResponse<R, O>;
 
     fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         Poll::Ready(Ok(()))
     }
 
     fn call(&mut self, (param, req): (T, HttpRequest)) -> Self::Future {
-        HandlerServiceResponse {
+        HandlerWebResponse {
             fut: self.hnd.call(param),
             fut2: None,
             req: Some(req),
@@ -101,7 +101,7 @@ where
 
 #[doc(hidden)]
 #[pin_project]
-pub struct HandlerServiceResponse<T, R>
+pub struct HandlerWebResponse<T, R>
 where
     T: Future<Output = R>,
     R: Responder,
@@ -113,12 +113,12 @@ where
     req: Option<HttpRequest>,
 }
 
-impl<T, R> Future for HandlerServiceResponse<T, R>
+impl<T, R> Future for HandlerWebResponse<T, R>
 where
     T: Future<Output = R>,
     R: Responder,
 {
-    type Output = Result<ServiceResponse, Infallible>;
+    type Output = Result<WebResponse, Infallible>;
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.as_mut().project();
@@ -126,12 +126,12 @@ where
         if let Some(fut) = this.fut2.as_pin_mut() {
             return match fut.poll(cx) {
                 Poll::Ready(Ok(res)) => {
-                    Poll::Ready(Ok(ServiceResponse::new(this.req.take().unwrap(), res)))
+                    Poll::Ready(Ok(WebResponse::new(this.req.take().unwrap(), res)))
                 }
                 Poll::Pending => Poll::Pending,
                 Poll::Ready(Err(e)) => {
                     let res: Response = e.into().into();
-                    Poll::Ready(Ok(ServiceResponse::new(this.req.take().unwrap(), res)))
+                    Poll::Ready(Ok(WebResponse::new(this.req.take().unwrap(), res)))
                 }
             };
         }
@@ -164,16 +164,13 @@ impl<T: FromRequest, S> Extract<T, S> {
 
 impl<T: FromRequest, S> ServiceFactory for Extract<T, S>
 where
-    S: Service<
-            Request = (T, HttpRequest),
-            Response = ServiceResponse,
-            Error = Infallible,
-        > + Clone,
+    S: Service<Request = (T, HttpRequest), Response = WebResponse, Error = Infallible>
+        + Clone,
 {
     type Config = ();
-    type Request = ServiceRequest;
-    type Response = ServiceResponse;
-    type Error = (Error, ServiceRequest);
+    type Request = WebRequest;
+    type Response = WebResponse;
+    type Error = (Error, WebRequest);
     type InitError = ();
     type Service = ExtractService<T, S>;
     type Future = Ready<Result<Self::Service, ()>>;
@@ -193,22 +190,19 @@ pub struct ExtractService<T: FromRequest, S> {
 
 impl<T: FromRequest, S> Service for ExtractService<T, S>
 where
-    S: Service<
-            Request = (T, HttpRequest),
-            Response = ServiceResponse,
-            Error = Infallible,
-        > + Clone,
+    S: Service<Request = (T, HttpRequest), Response = WebResponse, Error = Infallible>
+        + Clone,
 {
-    type Request = ServiceRequest;
-    type Response = ServiceResponse;
-    type Error = (Error, ServiceRequest);
+    type Request = WebRequest;
+    type Response = WebResponse;
+    type Error = (Error, WebRequest);
     type Future = ExtractResponse<T, S>;
 
     fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         Poll::Ready(Ok(()))
     }
 
-    fn call(&mut self, req: ServiceRequest) -> Self::Future {
+    fn call(&mut self, req: WebRequest) -> Self::Future {
         let (req, mut payload) = req.into_parts();
         let fut = T::from_request(&req, &mut payload);
 
@@ -233,13 +227,9 @@ pub struct ExtractResponse<T: FromRequest, S: Service> {
 
 impl<T: FromRequest, S> Future for ExtractResponse<T, S>
 where
-    S: Service<
-        Request = (T, HttpRequest),
-        Response = ServiceResponse,
-        Error = Infallible,
-    >,
+    S: Service<Request = (T, HttpRequest), Response = WebResponse, Error = Infallible>,
 {
-    type Output = Result<ServiceResponse, (Error, ServiceRequest)>;
+    type Output = Result<WebResponse, (Error, WebRequest)>;
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.as_mut().project();
@@ -250,7 +240,7 @@ where
 
         match ready!(this.fut.poll(cx)) {
             Err(e) => {
-                let req = ServiceRequest::new(this.req.clone());
+                let req = WebRequest::new(this.req.clone());
                 Poll::Ready(Err((e.into(), req)))
             }
             Ok(item) => {
diff --git a/ntex/src/web/middleware/compress.rs b/ntex/src/web/middleware/compress.rs
index 96ac7531..ccff05bd 100644
--- a/ntex/src/web/middleware/compress.rs
+++ b/ntex/src/web/middleware/compress.rs
@@ -16,7 +16,7 @@ use crate::http::Error;
 use crate::service::{Service, Transform};
 
 use crate::web::dev::BodyEncoding;
-use crate::web::service::{ServiceRequest, ServiceResponse};
+use crate::web::service::{WebRequest, WebResponse};
 
 #[derive(Debug, Clone)]
 /// `Middleware` for compressing response body.
@@ -55,10 +55,10 @@ impl Default for Compress {
 impl<S, B> Transform<S> for Compress
 where
     B: MessageBody,
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    S: Service<Request = WebRequest, Response = WebResponse<B>, Error = Error>,
 {
-    type Request = ServiceRequest;
-    type Response = ServiceResponse<Encoder<B>>;
+    type Request = WebRequest;
+    type Response = WebResponse<Encoder<B>>;
     type Error = Error;
     type InitError = ();
     type Transform = CompressMiddleware<S>;
@@ -80,10 +80,10 @@ pub struct CompressMiddleware<S> {
 impl<S, B> Service for CompressMiddleware<S>
 where
     B: MessageBody,
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    S: Service<Request = WebRequest, Response = WebResponse<B>, Error = Error>,
 {
-    type Request = ServiceRequest;
-    type Response = ServiceResponse<Encoder<B>>;
+    type Request = WebRequest;
+    type Response = WebResponse<Encoder<B>>;
     type Error = Error;
     type Future = CompressResponse<S, B>;
 
@@ -91,7 +91,7 @@ where
         self.service.poll_ready(cx)
     }
 
-    fn call(&mut self, req: ServiceRequest) -> Self::Future {
+    fn call(&mut self, req: WebRequest) -> Self::Future {
         // negotiate content-encoding
         let encoding = if let Some(val) = req.headers().get(&ACCEPT_ENCODING) {
             if let Ok(enc) = val.to_str() {
@@ -127,9 +127,9 @@ where
 impl<S, B> Future for CompressResponse<S, B>
 where
     B: MessageBody,
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    S: Service<Request = WebRequest, Response = WebResponse<B>, Error = Error>,
 {
-    type Output = Result<ServiceResponse<Encoder<B>>, Error>;
+    type Output = Result<WebResponse<Encoder<B>>, Error>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.project();
diff --git a/ntex/src/web/middleware/cors.rs b/ntex/src/web/middleware/cors.rs
index 429fe9ea..6ff62d99 100644
--- a/ntex/src/web/middleware/cors.rs
+++ b/ntex/src/web/middleware/cors.rs
@@ -46,7 +46,7 @@ use std::rc::Rc;
 use std::task::{Context, Poll};
 
 use actix_service::{Service, Transform};
-use actix_web::dev::{RequestHead, ServiceRequest, ServiceResponse};
+use actix_web::dev::{RequestHead, WebRequest, WebResponse};
 use actix_web::error::{Error, ResponseError, Result};
 use actix_web::http::header::{self, HeaderName, HeaderValue};
 use actix_web::http::{self, Error as HttpError, Method, StatusCode, Uri};
@@ -535,12 +535,12 @@ pub struct CorsFactory {
 
 impl<S, B> Transform<S> for CorsFactory
 where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    S: Service<Request = WebRequest, Response = WebResponse<B>, Error = Error>,
     S::Future: 'static,
     B: 'static,
 {
-    type Request = ServiceRequest;
-    type Response = ServiceResponse<B>;
+    type Request = WebRequest;
+    type Response = WebResponse<B>;
     type Error = Error;
     type InitError = ();
     type Transform = CorsMiddleware<S>;
@@ -678,12 +678,12 @@ impl Inner {
 
 impl<S, B> Service for CorsMiddleware<S>
 where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    S: Service<Request = WebRequest, Response = WebResponse<B>, Error = Error>,
     S::Future: 'static,
     B: 'static,
 {
-    type Request = ServiceRequest;
-    type Response = ServiceResponse<B>;
+    type Request = WebRequest;
+    type Response = WebResponse<B>;
     type Error = Error;
     type Future = Either<
         Ready<Result<Self::Response, Error>>,
@@ -694,7 +694,7 @@ where
         self.service.poll_ready(cx)
     }
 
-    fn call(&mut self, req: ServiceRequest) -> Self::Future {
+    fn call(&mut self, req: WebRequest) -> Self::Future {
         if self.inner.preflight && Method::OPTIONS == *req.method() {
             if let Err(e) = self
                 .inner
@@ -1083,7 +1083,7 @@ mod tests {
             .expose_headers(exposed_headers.clone())
             .allowed_header(header::CONTENT_TYPE)
             .finish()
-            .new_transform(fn_service(|req: ServiceRequest| {
+            .new_transform(fn_service(|req: WebRequest| {
                 ok(req.into_response(
                     HttpResponse::Ok().header(header::VARY, "Accept").finish(),
                 ))
diff --git a/ntex/src/web/middleware/defaultheaders.rs b/ntex/src/web/middleware/defaultheaders.rs
index 99783dee..0e7dc67b 100644
--- a/ntex/src/web/middleware/defaultheaders.rs
+++ b/ntex/src/web/middleware/defaultheaders.rs
@@ -8,7 +8,7 @@ use futures::future::{ok, FutureExt, LocalBoxFuture, Ready};
 use crate::http::error::{Error, HttpError};
 use crate::http::header::{HeaderMap, HeaderName, HeaderValue, CONTENT_TYPE};
 use crate::service::{Service, Transform};
-use crate::web::service::{ServiceRequest, ServiceResponse};
+use crate::web::service::{WebRequest, WebResponse};
 
 /// `Middleware` for setting default response headers.
 ///
@@ -91,11 +91,11 @@ impl DefaultHeaders {
 
 impl<S, B> Transform<S> for DefaultHeaders
 where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    S: Service<Request = WebRequest, Response = WebResponse<B>, Error = Error>,
     S::Future: 'static,
 {
-    type Request = ServiceRequest;
-    type Response = ServiceResponse<B>;
+    type Request = WebRequest;
+    type Response = WebResponse<B>;
     type Error = Error;
     type InitError = ();
     type Transform = DefaultHeadersMiddleware<S>;
@@ -116,11 +116,11 @@ pub struct DefaultHeadersMiddleware<S> {
 
 impl<S, B> Service for DefaultHeadersMiddleware<S>
 where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    S: Service<Request = WebRequest, Response = WebResponse<B>, Error = Error>,
     S::Future: 'static,
 {
-    type Request = ServiceRequest;
-    type Response = ServiceResponse<B>;
+    type Request = WebRequest;
+    type Response = WebResponse<B>;
     type Error = Error;
     type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
 
@@ -128,7 +128,7 @@ where
         self.service.poll_ready(cx)
     }
 
-    fn call(&mut self, req: ServiceRequest) -> Self::Future {
+    fn call(&mut self, req: WebRequest) -> Self::Future {
         let inner = self.inner.clone();
         let fut = self.service.call(req);
 
@@ -161,7 +161,7 @@ mod tests {
     use super::*;
     use crate::http::header::CONTENT_TYPE;
     use crate::service::IntoService;
-    use crate::web::service::ServiceRequest;
+    use crate::web::service::WebRequest;
     use crate::web::test::{ok_service, TestRequest};
     use crate::web::HttpResponse;
 
@@ -178,7 +178,7 @@ mod tests {
         assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(), "0001");
 
         let req = TestRequest::default().to_srv_request();
-        let srv = |req: ServiceRequest| {
+        let srv = |req: WebRequest| {
             ok(req
                 .into_response(HttpResponse::Ok().header(CONTENT_TYPE, "0002").finish()))
         };
@@ -193,8 +193,7 @@ mod tests {
 
     #[actix_rt::test]
     async fn test_content_type() {
-        let srv =
-            |req: ServiceRequest| ok(req.into_response(HttpResponse::Ok().finish()));
+        let srv = |req: WebRequest| ok(req.into_response(HttpResponse::Ok().finish()));
         let mut mw = DefaultHeaders::new()
             .content_type()
             .new_transform(srv.into_service())
diff --git a/ntex/src/web/middleware/logger.rs b/ntex/src/web/middleware/logger.rs
index 0e39e1d6..026e7403 100644
--- a/ntex/src/web/middleware/logger.rs
+++ b/ntex/src/web/middleware/logger.rs
@@ -20,7 +20,7 @@ use crate::http::error::Error;
 use crate::http::header::HeaderName;
 use crate::http::StatusCode;
 use crate::service::{Service, Transform};
-use crate::web::service::{ServiceRequest, ServiceResponse};
+use crate::web::service::{WebRequest, WebResponse};
 use crate::web::HttpResponse;
 
 /// `Middleware` for logging request and response info to the terminal.
@@ -121,11 +121,11 @@ impl Default for Logger {
 
 impl<S, B> Transform<S> for Logger
 where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    S: Service<Request = WebRequest, Response = WebResponse<B>, Error = Error>,
     B: MessageBody,
 {
-    type Request = ServiceRequest;
-    type Response = ServiceResponse<StreamLog<B>>;
+    type Request = WebRequest;
+    type Response = WebResponse<StreamLog<B>>;
     type Error = Error;
     type InitError = ();
     type Transform = LoggerMiddleware<S>;
@@ -147,11 +147,11 @@ pub struct LoggerMiddleware<S> {
 
 impl<S, B> Service for LoggerMiddleware<S>
 where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    S: Service<Request = WebRequest, Response = WebResponse<B>, Error = Error>,
     B: MessageBody,
 {
-    type Request = ServiceRequest;
-    type Response = ServiceResponse<StreamLog<B>>;
+    type Request = WebRequest;
+    type Response = WebResponse<StreamLog<B>>;
     type Error = Error;
     type Future = LoggerResponse<S, B>;
 
@@ -159,7 +159,7 @@ where
         self.service.poll_ready(cx)
     }
 
-    fn call(&mut self, req: ServiceRequest) -> Self::Future {
+    fn call(&mut self, req: WebRequest) -> Self::Future {
         if self.inner.exclude.contains(req.path()) {
             LoggerResponse {
                 fut: self.service.call(req),
@@ -201,9 +201,9 @@ where
 impl<S, B> Future for LoggerResponse<S, B>
 where
     B: MessageBody,
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    S: Service<Request = WebRequest, Response = WebResponse<B>, Error = Error>,
 {
-    type Output = Result<ServiceResponse<StreamLog<B>>, Error>;
+    type Output = Result<WebResponse<StreamLog<B>>, Error>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.project();
@@ -418,7 +418,7 @@ impl FormatText {
         }
     }
 
-    fn render_request(&mut self, now: OffsetDateTime, req: &ServiceRequest) {
+    fn render_request(&mut self, now: OffsetDateTime, req: &WebRequest) {
         match *self {
             FormatText::RequestLine => {
                 *self = if req.query_string().is_empty() {
@@ -488,7 +488,7 @@ mod tests {
 
     #[actix_rt::test]
     async fn test_logger() {
-        let srv = |req: ServiceRequest| {
+        let srv = |req: WebRequest| {
             ok(req.into_response(
                 HttpResponse::build(StatusCode::OK)
                     .header("X-Test", "ttt")
diff --git a/ntex/src/web/mod.rs b/ntex/src/web/mod.rs
index c1930f9d..d0bd40f7 100644
--- a/ntex/src/web/mod.rs
+++ b/ntex/src/web/mod.rs
@@ -115,7 +115,7 @@ pub mod dev {
     pub use crate::web::info::ConnectionInfo;
     pub use crate::web::rmap::ResourceMap;
     pub use crate::web::service::{
-        HttpServiceFactory, ServiceRequest, ServiceResponse, WebService,
+        HttpServiceFactory, WebRequest, WebResponse, WebService,
     };
 
     pub use crate::web::types::form::UrlEncoded;
diff --git a/ntex/src/web/resource.rs b/ntex/src/web/resource.rs
index 89db6c3e..04e921e5 100644
--- a/ntex/src/web/resource.rs
+++ b/ntex/src/web/resource.rs
@@ -20,10 +20,10 @@ use crate::web::guard::Guard;
 use crate::web::handler::Factory;
 use crate::web::responder::Responder;
 use crate::web::route::{CreateRouteService, Route, RouteService};
-use crate::web::service::{ServiceRequest, ServiceResponse};
+use crate::web::service::{WebRequest, WebResponse};
 
-type HttpService = BoxService<ServiceRequest, ServiceResponse, Error>;
-type HttpNewService = BoxServiceFactory<(), ServiceRequest, ServiceResponse, Error, ()>;
+type HttpService = BoxService<WebRequest, WebResponse, Error>;
+type HttpNewService = BoxServiceFactory<(), WebRequest, WebResponse, Error, ()>;
 
 /// *Resource* is an entry in resources table which corresponds to requested URL.
 ///
@@ -79,8 +79,8 @@ impl<T> Resource<T>
 where
     T: ServiceFactory<
         Config = (),
-        Request = ServiceRequest,
-        Response = ServiceResponse,
+        Request = WebRequest,
+        Response = WebResponse,
         Error = Error,
         InitError = (),
     >,
@@ -250,8 +250,8 @@ where
     ) -> Resource<
         impl ServiceFactory<
             Config = (),
-            Request = ServiceRequest,
-            Response = ServiceResponse,
+            Request = WebRequest,
+            Response = WebResponse,
             Error = Error,
             InitError = (),
         >,
@@ -259,8 +259,8 @@ where
     where
         M: Transform<
             T::Service,
-            Request = ServiceRequest,
-            Response = ServiceResponse,
+            Request = WebRequest,
+            Response = WebResponse,
             Error = Error,
             InitError = (),
         >,
@@ -279,7 +279,7 @@ where
 
     /// Register a resource middleware function.
     ///
-    /// This function accepts instance of `ServiceRequest` type and
+    /// This function accepts instance of `WebRequest` type and
     /// mutable reference to the next middleware in chain.
     ///
     /// This is similar to `App's` middlewares, but middleware get invoked on resource level.
@@ -317,15 +317,15 @@ where
     ) -> Resource<
         impl ServiceFactory<
             Config = (),
-            Request = ServiceRequest,
-            Response = ServiceResponse,
+            Request = WebRequest,
+            Response = WebResponse,
             Error = Error,
             InitError = (),
         >,
     >
     where
-        F: FnMut(ServiceRequest, &mut T::Service) -> R + Clone,
-        R: Future<Output = Result<ServiceResponse, Error>>,
+        F: FnMut(WebRequest, &mut T::Service) -> R + Clone,
+        R: Future<Output = Result<WebResponse, Error>>,
     {
         Resource {
             endpoint: apply_fn_factory(self.endpoint, mw),
@@ -347,8 +347,8 @@ where
         F: IntoServiceFactory<U>,
         U: ServiceFactory<
                 Config = (),
-                Request = ServiceRequest,
-                Response = ServiceResponse,
+                Request = WebRequest,
+                Response = WebResponse,
                 Error = Error,
             > + 'static,
         U::InitError: fmt::Debug,
@@ -368,8 +368,8 @@ impl<T> HttpServiceFactory for Resource<T>
 where
     T: ServiceFactory<
             Config = (),
-            Request = ServiceRequest,
-            Response = ServiceResponse,
+            Request = WebRequest,
+            Response = WebResponse,
             Error = Error,
             InitError = (),
         > + 'static,
@@ -400,8 +400,8 @@ impl<T> IntoServiceFactory<T> for Resource<T>
 where
     T: ServiceFactory<
         Config = (),
-        Request = ServiceRequest,
-        Response = ServiceResponse,
+        Request = WebRequest,
+        Response = WebResponse,
         Error = Error,
         InitError = (),
     >,
@@ -425,8 +425,8 @@ pub struct ResourceFactory {
 
 impl ServiceFactory for ResourceFactory {
     type Config = ();
-    type Request = ServiceRequest;
-    type Response = ServiceResponse;
+    type Request = WebRequest;
+    type Response = WebResponse;
     type Error = Error;
     type InitError = ();
     type Service = ResourceService;
@@ -519,19 +519,19 @@ pub struct ResourceService {
 }
 
 impl Service for ResourceService {
-    type Request = ServiceRequest;
-    type Response = ServiceResponse;
+    type Request = WebRequest;
+    type Response = WebResponse;
     type Error = Error;
     type Future = Either<
-        Ready<Result<ServiceResponse, Error>>,
-        LocalBoxFuture<'static, Result<ServiceResponse, Error>>,
+        Ready<Result<WebResponse, Error>>,
+        LocalBoxFuture<'static, Result<WebResponse, Error>>,
     >;
 
     fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         Poll::Ready(Ok(()))
     }
 
-    fn call(&mut self, mut req: ServiceRequest) -> Self::Future {
+    fn call(&mut self, mut req: WebRequest) -> Self::Future {
         for route in self.routes.iter_mut() {
             if route.check(&mut req) {
                 if let Some(ref data) = self.data {
@@ -544,7 +544,7 @@ impl Service for ResourceService {
             Either::Right(default.call(req))
         } else {
             let req = req.into_parts().0;
-            Either::Left(ok(ServiceResponse::new(
+            Either::Left(ok(WebResponse::new(
                 req,
                 Response::MethodNotAllowed().finish(),
             )))
@@ -565,8 +565,8 @@ impl ResourceEndpoint {
 
 impl ServiceFactory for ResourceEndpoint {
     type Config = ();
-    type Request = ServiceRequest;
-    type Response = ServiceResponse;
+    type Request = WebRequest;
+    type Response = WebResponse;
     type Error = Error;
     type InitError = ();
     type Service = ResourceService;
@@ -587,7 +587,7 @@ mod tests {
     use crate::http::header::{self, HeaderValue};
     use crate::http::{Error, Method, StatusCode};
     use crate::web::middleware::DefaultHeaders;
-    use crate::web::service::ServiceRequest;
+    use crate::web::service::WebRequest;
     use crate::web::test::{call_service, init_service, TestRequest};
     use crate::web::{self, guard, App, HttpResponse};
     use crate::Service;
@@ -683,7 +683,7 @@ mod tests {
                 .service(
                     web::resource("/test").route(web::get().to(|| HttpResponse::Ok())),
                 )
-                .default_service(|r: ServiceRequest| {
+                .default_service(|r: WebRequest| {
                     ok(r.into_response(HttpResponse::BadRequest()))
                 }),
         )
@@ -702,7 +702,7 @@ mod tests {
             App::new().service(
                 web::resource("/test")
                     .route(web::get().to(|| HttpResponse::Ok()))
-                    .default_service(|r: ServiceRequest| {
+                    .default_service(|r: WebRequest| {
                         ok(r.into_response(HttpResponse::BadRequest()))
                     }),
             ),
diff --git a/ntex/src/web/route.rs b/ntex/src/web/route.rs
index 94ed94ff..7437d078 100644
--- a/ntex/src/web/route.rs
+++ b/ntex/src/web/route.rs
@@ -12,7 +12,7 @@ use crate::web::extract::FromRequest;
 use crate::web::guard::{self, Guard};
 use crate::web::handler::{Extract, Factory, Handler};
 use crate::web::responder::Responder;
-use crate::web::service::{ServiceRequest, ServiceResponse};
+use crate::web::service::{WebRequest, WebResponse};
 use crate::web::HttpResponse;
 
 type BoxedRouteService<Req, Res> = Box<
@@ -41,7 +41,7 @@ type BoxedRouteNewService<Req, Res> = Box<
 /// Route uses builder-like pattern for configuration.
 /// If handler is not explicitly set, default *404 Not Found* handler is used.
 pub struct Route {
-    service: BoxedRouteNewService<ServiceRequest, ServiceResponse>,
+    service: BoxedRouteNewService<WebRequest, WebResponse>,
     guards: Rc<Vec<Box<dyn Guard>>>,
 }
 
@@ -63,8 +63,8 @@ impl Route {
 
 impl ServiceFactory for Route {
     type Config = ();
-    type Request = ServiceRequest;
-    type Response = ServiceResponse;
+    type Request = WebRequest;
+    type Response = WebResponse;
     type Error = Error;
     type InitError = ();
     type Service = RouteService;
@@ -78,10 +78,8 @@ impl ServiceFactory for Route {
     }
 }
 
-type RouteFuture = LocalBoxFuture<
-    'static,
-    Result<BoxedRouteService<ServiceRequest, ServiceResponse>, ()>,
->;
+type RouteFuture =
+    LocalBoxFuture<'static, Result<BoxedRouteService<WebRequest, WebResponse>, ()>>;
 
 #[pin_project::pin_project]
 pub struct CreateRouteService {
@@ -107,12 +105,12 @@ impl Future for CreateRouteService {
 }
 
 pub struct RouteService {
-    service: BoxedRouteService<ServiceRequest, ServiceResponse>,
+    service: BoxedRouteService<WebRequest, WebResponse>,
     guards: Rc<Vec<Box<dyn Guard>>>,
 }
 
 impl RouteService {
-    pub fn check(&self, req: &mut ServiceRequest) -> bool {
+    pub fn check(&self, req: &mut WebRequest) -> bool {
         for f in self.guards.iter() {
             if !f.check(req.head()) {
                 return false;
@@ -123,8 +121,8 @@ impl RouteService {
 }
 
 impl Service for RouteService {
-    type Request = ServiceRequest;
-    type Response = ServiceResponse;
+    type Request = WebRequest;
+    type Response = WebResponse;
     type Error = Error;
     type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
 
@@ -132,7 +130,7 @@ impl Service for RouteService {
         self.service.poll_ready(cx)
     }
 
-    fn call(&mut self, req: ServiceRequest) -> Self::Future {
+    fn call(&mut self, req: WebRequest) -> Self::Future {
         self.service.call(req).boxed_local()
     }
 }
@@ -239,7 +237,7 @@ impl Route {
 
 struct RouteNewService<T>
 where
-    T: ServiceFactory<Request = ServiceRequest, Error = (Error, ServiceRequest)>,
+    T: ServiceFactory<Request = WebRequest, Error = (Error, WebRequest)>,
 {
     service: T,
 }
@@ -248,9 +246,9 @@ impl<T> RouteNewService<T>
 where
     T: ServiceFactory<
         Config = (),
-        Request = ServiceRequest,
-        Response = ServiceResponse,
-        Error = (Error, ServiceRequest),
+        Request = WebRequest,
+        Response = WebResponse,
+        Error = (Error, WebRequest),
     >,
     T::Future: 'static,
     T::Service: 'static,
@@ -265,20 +263,20 @@ impl<T> ServiceFactory for RouteNewService<T>
 where
     T: ServiceFactory<
         Config = (),
-        Request = ServiceRequest,
-        Response = ServiceResponse,
-        Error = (Error, ServiceRequest),
+        Request = WebRequest,
+        Response = WebResponse,
+        Error = (Error, WebRequest),
     >,
     T::Future: 'static,
     T::Service: 'static,
     <T::Service as Service>::Future: 'static,
 {
     type Config = ();
-    type Request = ServiceRequest;
-    type Response = ServiceResponse;
+    type Request = WebRequest;
+    type Response = WebResponse;
     type Error = Error;
     type InitError = ();
-    type Service = BoxedRouteService<ServiceRequest, Self::Response>;
+    type Service = BoxedRouteService<WebRequest, Self::Response>;
     type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
 
     fn new_service(&self, _: ()) -> Self::Future {
@@ -304,13 +302,13 @@ impl<T> Service for RouteServiceWrapper<T>
 where
     T::Future: 'static,
     T: Service<
-        Request = ServiceRequest,
-        Response = ServiceResponse,
-        Error = (Error, ServiceRequest),
+        Request = WebRequest,
+        Response = WebResponse,
+        Error = (Error, WebRequest),
     >,
 {
-    type Request = ServiceRequest;
-    type Response = ServiceResponse;
+    type Request = WebRequest;
+    type Response = WebResponse;
     type Error = Error;
     type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
 
@@ -318,7 +316,7 @@ where
         self.service.poll_ready(cx).map_err(|(e, _)| e)
     }
 
-    fn call(&mut self, req: ServiceRequest) -> Self::Future {
+    fn call(&mut self, req: WebRequest) -> Self::Future {
         self.service
             .call(req)
             .map(|res| match res {
diff --git a/ntex/src/web/scope.rs b/ntex/src/web/scope.rs
index 65f7200b..35523112 100644
--- a/ntex/src/web/scope.rs
+++ b/ntex/src/web/scope.rs
@@ -20,13 +20,13 @@ use crate::web::resource::Resource;
 use crate::web::rmap::ResourceMap;
 use crate::web::route::Route;
 use crate::web::service::{
-    AppServiceFactory, ServiceFactoryWrapper, ServiceRequest, ServiceResponse,
+    AppServiceFactory, ServiceFactoryWrapper, WebRequest, WebResponse,
 };
 
 type Guards = Vec<Box<dyn Guard>>;
-type HttpService = BoxService<ServiceRequest, ServiceResponse, Error>;
-type HttpNewService = BoxServiceFactory<(), ServiceRequest, ServiceResponse, Error, ()>;
-type BoxedResponse = LocalBoxFuture<'static, Result<ServiceResponse, Error>>;
+type HttpService = BoxService<WebRequest, WebResponse, Error>;
+type HttpNewService = BoxServiceFactory<(), WebRequest, WebResponse, Error, ()>;
+type BoxedResponse = LocalBoxFuture<'static, Result<WebResponse, Error>>;
 
 /// Resources scope.
 ///
@@ -89,8 +89,8 @@ impl<T> Scope<T>
 where
     T: ServiceFactory<
         Config = (),
-        Request = ServiceRequest,
-        Response = ServiceResponse,
+        Request = WebRequest,
+        Response = WebResponse,
         Error = Error,
         InitError = (),
     >,
@@ -283,8 +283,8 @@ where
         F: IntoServiceFactory<U>,
         U: ServiceFactory<
                 Config = (),
-                Request = ServiceRequest,
-                Response = ServiceResponse,
+                Request = WebRequest,
+                Response = WebResponse,
                 Error = Error,
             > + 'static,
         U::InitError: fmt::Debug,
@@ -305,7 +305,7 @@ where
     /// necessary, across all requests managed by the *Scope*.  Scope-level
     /// middleware is more limited in what it can modify, relative to Route or
     /// Application level middleware, in that Scope-level middleware can not modify
-    /// ServiceResponse.
+    /// WebResponse.
     ///
     /// Use middleware when you need to read or modify *every* request in some way.
     pub fn wrap<M>(
@@ -314,8 +314,8 @@ where
     ) -> Scope<
         impl ServiceFactory<
             Config = (),
-            Request = ServiceRequest,
-            Response = ServiceResponse,
+            Request = WebRequest,
+            Response = WebResponse,
             Error = Error,
             InitError = (),
         >,
@@ -323,8 +323,8 @@ where
     where
         M: Transform<
             T::Service,
-            Request = ServiceRequest,
-            Response = ServiceResponse,
+            Request = WebRequest,
+            Response = WebResponse,
             Error = Error,
             InitError = (),
         >,
@@ -346,7 +346,7 @@ where
     /// request as necessary, across all requests managed by the *Scope*.
     /// Scope-level middleware is more limited in what it can modify, relative
     /// to Route or Application level middleware, in that Scope-level middleware
-    /// can not modify ServiceResponse.
+    /// can not modify WebResponse.
     ///
     /// ```rust
     /// use ntex::service::Service;
@@ -379,15 +379,15 @@ where
     ) -> Scope<
         impl ServiceFactory<
             Config = (),
-            Request = ServiceRequest,
-            Response = ServiceResponse,
+            Request = WebRequest,
+            Response = WebResponse,
             Error = Error,
             InitError = (),
         >,
     >
     where
-        F: FnMut(ServiceRequest, &mut T::Service) -> R + Clone,
-        R: Future<Output = Result<ServiceResponse, Error>>,
+        F: FnMut(WebRequest, &mut T::Service) -> R + Clone,
+        R: Future<Output = Result<WebResponse, Error>>,
     {
         Scope {
             endpoint: apply_fn_factory(self.endpoint, mw),
@@ -406,8 +406,8 @@ impl<T> HttpServiceFactory for Scope<T>
 where
     T: ServiceFactory<
             Config = (),
-            Request = ServiceRequest,
-            Response = ServiceResponse,
+            Request = WebRequest,
+            Response = WebResponse,
             Error = Error,
             InitError = (),
         > + 'static,
@@ -477,8 +477,8 @@ pub struct ScopeFactory {
 
 impl ServiceFactory for ScopeFactory {
     type Config = ();
-    type Request = ServiceRequest;
-    type Response = ServiceResponse;
+    type Request = WebRequest;
+    type Response = WebResponse;
     type Error = Error;
     type InitError = ();
     type Service = ScopeService;
@@ -593,12 +593,12 @@ pub struct ScopeService {
     data: Option<Rc<Extensions>>,
     router: Router<HttpService, Vec<Box<dyn Guard>>>,
     default: Option<HttpService>,
-    _ready: Option<(ServiceRequest, ResourceInfo)>,
+    _ready: Option<(WebRequest, ResourceInfo)>,
 }
 
 impl Service for ScopeService {
-    type Request = ServiceRequest;
-    type Response = ServiceResponse;
+    type Request = WebRequest;
+    type Response = WebResponse;
     type Error = Error;
     type Future = Either<BoxedResponse, Ready<Result<Self::Response, Self::Error>>>;
 
@@ -606,7 +606,7 @@ impl Service for ScopeService {
         Poll::Ready(Ok(()))
     }
 
-    fn call(&mut self, mut req: ServiceRequest) -> Self::Future {
+    fn call(&mut self, mut req: WebRequest) -> Self::Future {
         let res = self.router.recognize_mut_checked(&mut req, |req, guards| {
             if let Some(ref guards) = guards {
                 for f in guards {
@@ -627,7 +627,7 @@ impl Service for ScopeService {
             Either::Left(default.call(req))
         } else {
             let req = req.into_parts().0;
-            Either::Right(ok(ServiceResponse::new(req, Response::NotFound().finish())))
+            Either::Right(ok(WebResponse::new(req, Response::NotFound().finish())))
         }
     }
 }
@@ -645,8 +645,8 @@ impl ScopeEndpoint {
 
 impl ServiceFactory for ScopeEndpoint {
     type Config = ();
-    type Request = ServiceRequest;
-    type Response = ServiceResponse;
+    type Request = WebRequest;
+    type Response = WebResponse;
     type Error = Error;
     type InitError = ();
     type Service = ScopeService;
@@ -667,7 +667,7 @@ mod tests {
     use crate::http::{Method, StatusCode};
     use crate::service::Service;
     use crate::web::middleware::DefaultHeaders;
-    use crate::web::service::ServiceRequest;
+    use crate::web::service::WebRequest;
     use crate::web::test::{call_service, init_service, read_body, TestRequest};
     use crate::web::{self, guard, App, HttpRequest, HttpResponse};
 
@@ -993,7 +993,7 @@ mod tests {
             App::new().service(
                 web::scope("/app")
                     .service(web::resource("/path1").to(|| HttpResponse::Ok()))
-                    .default_service(|r: ServiceRequest| {
+                    .default_service(|r: WebRequest| {
                         ok(r.into_response(HttpResponse::BadRequest()))
                     }),
             ),
@@ -1017,7 +1017,7 @@ mod tests {
                     web::resource("").to(|| HttpResponse::BadRequest()),
                 ))
                 .service(web::scope("/app2"))
-                .default_service(|r: ServiceRequest| {
+                .default_service(|r: WebRequest| {
                     ok(r.into_response(HttpResponse::MethodNotAllowed()))
                 }),
         )
diff --git a/ntex/src/web/service.rs b/ntex/src/web/service.rs
index b899dbd1..1bdb2a57 100644
--- a/ntex/src/web/service.rs
+++ b/ntex/src/web/service.rs
@@ -23,11 +23,11 @@ pub trait HttpServiceFactory {
     fn register(self, config: &mut AppService);
 }
 
-pub(crate) trait AppServiceFactory {
+pub(super) trait AppServiceFactory {
     fn register(&mut self, config: &mut AppService);
 }
 
-pub(crate) struct ServiceFactoryWrapper<T> {
+pub(super) struct ServiceFactoryWrapper<T> {
     factory: Option<T>,
 }
 
@@ -52,13 +52,13 @@ where
 
 /// An service http request
 ///
-/// ServiceRequest allows mutable access to request's internal structures
-pub struct ServiceRequest(HttpRequest);
+/// WebRequest allows mutable access to request's internal structures
+pub struct WebRequest(HttpRequest);
 
-impl ServiceRequest {
-    /// Construct service request
+impl WebRequest {
+    /// Construct web request
     pub(crate) fn new(req: HttpRequest) -> Self {
-        ServiceRequest(req)
+        WebRequest(req)
     }
 
     /// Deconstruct request into parts
@@ -69,14 +69,14 @@ impl ServiceRequest {
 
     /// Construct request from parts.
     ///
-    /// `ServiceRequest` can be re-constructed only if `req` hasnt been cloned.
+    /// `WebRequest` can be re-constructed only if `req` hasnt been cloned.
     pub fn from_parts(
         mut req: HttpRequest,
         pl: Payload,
     ) -> Result<Self, (HttpRequest, Payload)> {
         if Rc::strong_count(&req.0) == 1 && Rc::weak_count(&req.0) == 0 {
             Rc::get_mut(&mut req.0).unwrap().payload = pl;
-            Ok(ServiceRequest(req))
+            Ok(WebRequest(req))
         } else {
             Err((req, pl))
         }
@@ -84,28 +84,28 @@ impl ServiceRequest {
 
     /// Construct request from request.
     ///
-    /// `HttpRequest` implements `Clone` trait via `Rc` type. `ServiceRequest`
+    /// `HttpRequest` implements `Clone` trait via `Rc` type. `WebRequest`
     /// can be re-constructed only if rc's strong pointers count eq 1 and
     /// weak pointers count is 0.
     pub fn from_request(req: HttpRequest) -> Result<Self, HttpRequest> {
         if Rc::strong_count(&req.0) == 1 && Rc::weak_count(&req.0) == 0 {
-            Ok(ServiceRequest(req))
+            Ok(WebRequest(req))
         } else {
             Err(req)
         }
     }
 
-    /// Create service response
+    /// Create web response
     #[inline]
-    pub fn into_response<B, R: Into<Response<B>>>(self, res: R) -> ServiceResponse<B> {
-        ServiceResponse::new(self.0, res.into())
+    pub fn into_response<B, R: Into<Response<B>>>(self, res: R) -> WebResponse<B> {
+        WebResponse::new(self.0, res.into())
     }
 
-    /// Create service response for error
+    /// Create web response for error
     #[inline]
-    pub fn error_response<B, E: Into<Error>>(self, err: E) -> ServiceResponse<B> {
+    pub fn error_response<B, E: Into<Error>>(self, err: E) -> WebResponse<B> {
         let res: Response = err.into().into();
-        ServiceResponse::new(self.0, res.into_body())
+        WebResponse::new(self.0, res.into_body())
     }
 
     /// This method returns reference to the request head
@@ -236,13 +236,13 @@ impl ServiceRequest {
     }
 }
 
-impl Resource<Url> for ServiceRequest {
+impl Resource<Url> for WebRequest {
     fn resource_path(&mut self) -> &mut Path<Url> {
         self.match_info_mut()
     }
 }
 
-impl HttpMessage for ServiceRequest {
+impl HttpMessage for WebRequest {
     type Stream = PayloadStream;
 
     #[inline]
@@ -269,11 +269,11 @@ impl HttpMessage for ServiceRequest {
     }
 }
 
-impl fmt::Debug for ServiceRequest {
+impl fmt::Debug for WebRequest {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         writeln!(
             f,
-            "\nServiceRequest {:?} {}:{}",
+            "\nWebRequest {:?} {}:{}",
             self.head().version,
             self.head().method,
             self.path()
@@ -292,37 +292,37 @@ impl fmt::Debug for ServiceRequest {
     }
 }
 
-pub struct ServiceResponse<B = Body> {
+pub struct WebResponse<B = Body> {
     request: HttpRequest,
     response: Response<B>,
 }
 
-impl<B> ServiceResponse<B> {
-    /// Create service response instance
+impl<B> WebResponse<B> {
+    /// Create web response instance
     pub fn new(request: HttpRequest, response: Response<B>) -> Self {
-        ServiceResponse { request, response }
+        WebResponse { request, response }
     }
 
-    /// Create service response from the error
+    /// Create web response from the error
     pub fn from_err<E: Into<Error>>(err: E, request: HttpRequest) -> Self {
         let e: Error = err.into();
         let res: Response = e.into();
-        ServiceResponse {
+        WebResponse {
             request,
             response: res.into_body(),
         }
     }
 
-    /// Create service response for error
+    /// Create web response for error
     #[inline]
     pub fn error_response<E: Into<Error>>(self, err: E) -> Self {
         Self::from_err(err, self.request)
     }
 
-    /// Create service response
+    /// Create web response
     #[inline]
-    pub fn into_response<B1>(self, response: Response<B1>) -> ServiceResponse<B1> {
-        ServiceResponse::new(self.request, response)
+    pub fn into_response<B1>(self, response: Response<B1>) -> WebResponse<B1> {
+        WebResponse::new(self.request, response)
     }
 
     /// Get reference to original request
@@ -371,7 +371,7 @@ impl<B> ServiceResponse<B> {
             Ok(_) => self,
             Err(err) => {
                 let res: Response = err.into().into();
-                ServiceResponse::new(self.request, res.into_body())
+                WebResponse::new(self.request, res.into_body())
             }
         }
     }
@@ -382,32 +382,32 @@ impl<B> ServiceResponse<B> {
     }
 }
 
-impl<B> ServiceResponse<B> {
+impl<B> WebResponse<B> {
     /// Set a new body
-    pub fn map_body<F, B2>(self, f: F) -> ServiceResponse<B2>
+    pub fn map_body<F, B2>(self, f: F) -> WebResponse<B2>
     where
         F: FnOnce(&mut ResponseHead, ResponseBody<B>) -> ResponseBody<B2>,
     {
         let response = self.response.map_body(f);
 
-        ServiceResponse {
+        WebResponse {
             response,
             request: self.request,
         }
     }
 }
 
-impl<B> Into<Response<B>> for ServiceResponse<B> {
+impl<B> Into<Response<B>> for WebResponse<B> {
     fn into(self) -> Response<B> {
         self.response
     }
 }
 
-impl<B: MessageBody> fmt::Debug for ServiceResponse<B> {
+impl<B: MessageBody> fmt::Debug for WebResponse<B> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let res = writeln!(
             f,
-            "\nServiceResponse {:?} {}{}",
+            "\nWebResponse {:?} {}{}",
             self.response.head().version,
             self.response.head().status,
             self.response.head().reason.unwrap_or(""),
@@ -451,7 +451,7 @@ impl WebService {
     /// use ntex::http;
     /// use ntex::web::{self, guard, dev, App, HttpResponse};
     ///
-    /// async fn index(req: dev::ServiceRequest) -> Result<dev::ServiceResponse, http::Error> {
+    /// async fn index(req: dev::WebRequest) -> Result<dev::WebResponse, http::Error> {
     ///     Ok(req.into_response(HttpResponse::Ok().finish()))
     /// }
     ///
@@ -475,8 +475,8 @@ impl WebService {
         F: IntoServiceFactory<T>,
         T: ServiceFactory<
                 Config = (),
-                Request = ServiceRequest,
-                Response = ServiceResponse,
+                Request = WebRequest,
+                Response = WebResponse,
                 Error = Error,
                 InitError = (),
             > + 'static,
@@ -501,8 +501,8 @@ impl<T> HttpServiceFactory for WebServiceImpl<T>
 where
     T: ServiceFactory<
             Config = (),
-            Request = ServiceRequest,
-            Response = ServiceResponse,
+            Request = WebRequest,
+            Response = WebResponse,
             Error = Error,
             InitError = (),
         > + 'static,
@@ -540,28 +540,28 @@ mod tests {
     fn test_service_request() {
         let req = TestRequest::default().to_srv_request();
         let (r, pl) = req.into_parts();
-        assert!(ServiceRequest::from_parts(r, pl).is_ok());
+        assert!(WebRequest::from_parts(r, pl).is_ok());
 
         let req = TestRequest::default().to_srv_request();
         let (r, pl) = req.into_parts();
         let _r2 = r.clone();
-        assert!(ServiceRequest::from_parts(r, pl).is_err());
+        assert!(WebRequest::from_parts(r, pl).is_err());
 
         let req = TestRequest::default().to_srv_request();
         let (r, _pl) = req.into_parts();
-        assert!(ServiceRequest::from_request(r).is_ok());
+        assert!(WebRequest::from_request(r).is_ok());
 
         let req = TestRequest::default().to_srv_request();
         let (r, _pl) = req.into_parts();
         let _r2 = r.clone();
-        assert!(ServiceRequest::from_request(r).is_err());
+        assert!(WebRequest::from_request(r).is_err());
     }
 
     #[actix_rt::test]
     async fn test_service() {
         let mut srv = init_service(
             App::new().service(web::service("/test").name("test").finish(
-                |req: ServiceRequest| ok(req.into_response(HttpResponse::Ok().finish())),
+                |req: WebRequest| ok(req.into_response(HttpResponse::Ok().finish())),
             )),
         )
         .await;
@@ -571,7 +571,7 @@ mod tests {
 
         let mut srv = init_service(
             App::new().service(web::service("/test").guard(guard::Get()).finish(
-                |req: ServiceRequest| ok(req.into_response(HttpResponse::Ok().finish())),
+                |req: WebRequest| ok(req.into_response(HttpResponse::Ok().finish())),
             )),
         )
         .await;
@@ -589,7 +589,7 @@ mod tests {
             .header("x-test", "111")
             .to_srv_request();
         let s = format!("{:?}", req);
-        assert!(s.contains("ServiceRequest"));
+        assert!(s.contains("WebRequest"));
         assert!(s.contains("test=1"));
         assert!(s.contains("x-test"));
 
@@ -599,7 +599,7 @@ mod tests {
             .to_srv_response(res);
 
         let s = format!("{:?}", res);
-        assert!(s.contains("ServiceResponse"));
+        assert!(s.contains("WebResponse"));
         assert!(s.contains("x-test"));
     }
 }
diff --git a/ntex/src/web/test.rs b/ntex/src/web/test.rs
index 025240fd..220d6cd9 100644
--- a/ntex/src/web/test.rs
+++ b/ntex/src/web/test.rs
@@ -34,22 +34,20 @@ use crate::{map_config, IntoService, IntoServiceFactory, Service, ServiceFactory
 use crate::web::config::AppConfig;
 use crate::web::request::HttpRequestPool;
 use crate::web::rmap::ResourceMap;
-use crate::web::service::{ServiceRequest, ServiceResponse};
+use crate::web::service::{WebRequest, WebResponse};
 use crate::web::{HttpRequest, HttpResponse};
 
 /// Create service that always responds with `HttpResponse::Ok()`
 pub fn ok_service(
-) -> impl Service<Request = ServiceRequest, Response = ServiceResponse<Body>, Error = Error>
-{
+) -> impl Service<Request = WebRequest, Response = WebResponse<Body>, Error = Error> {
     default_service(StatusCode::OK)
 }
 
 /// Create service that responds with response with specified status code
 pub fn default_service(
     status_code: StatusCode,
-) -> impl Service<Request = ServiceRequest, Response = ServiceResponse<Body>, Error = Error>
-{
-    (move |req: ServiceRequest| {
+) -> impl Service<Request = WebRequest, Response = WebResponse<Body>, Error = Error> {
+    (move |req: WebRequest| {
         ok(req.into_response(HttpResponse::build(status_code).finish()))
     })
     .into_service()
@@ -80,13 +78,13 @@ pub fn default_service(
 /// ```
 pub async fn init_service<R, S, B, E>(
     app: R,
-) -> impl Service<Request = Request, Response = ServiceResponse<B>, Error = E>
+) -> impl Service<Request = Request, Response = WebResponse<B>, Error = E>
 where
     R: IntoServiceFactory<S>,
     S: ServiceFactory<
         Config = AppConfig,
         Request = Request,
-        Response = ServiceResponse<B>,
+        Response = WebResponse<B>,
         Error = E,
     >,
     S::InitError: std::fmt::Debug,
@@ -120,7 +118,7 @@ where
 /// ```
 pub async fn call_service<S, R, B, E>(app: &mut S, req: R) -> S::Response
 where
-    S: Service<Request = R, Response = ServiceResponse<B>, Error = E>,
+    S: Service<Request = R, Response = WebResponse<B>, Error = E>,
     E: std::fmt::Debug,
 {
     app.call(req).await.unwrap()
@@ -154,7 +152,7 @@ where
 /// ```
 pub async fn read_response<S, B>(app: &mut S, req: Request) -> Bytes
 where
-    S: Service<Request = Request, Response = ServiceResponse<B>, Error = Error>,
+    S: Service<Request = Request, Response = WebResponse<B>, Error = Error>,
     B: MessageBody,
 {
     let mut resp = app
@@ -170,7 +168,7 @@ where
     bytes.freeze()
 }
 
-/// Helper function that returns a response body of a ServiceResponse.
+/// Helper function that returns a response body of a WebResponse.
 ///
 /// ```rust
 /// use bytes::Bytes;
@@ -197,7 +195,7 @@ where
 ///     assert_eq!(result, Bytes::from_static(b"welcome!"));
 /// }
 /// ```
-pub async fn read_body<B>(mut res: ServiceResponse<B>) -> Bytes
+pub async fn read_body<B>(mut res: WebResponse<B>) -> Bytes
 where
     B: MessageBody,
 {
@@ -257,7 +255,7 @@ where
 /// ```
 pub async fn read_response_json<S, B, T>(app: &mut S, req: Request) -> T
 where
-    S: Service<Request = Request, Response = ServiceResponse<B>, Error = Error>,
+    S: Service<Request = Request, Response = WebResponse<B>, Error = Error>,
     B: MessageBody,
     T: DeserializeOwned,
 {
@@ -272,8 +270,8 @@ where
 /// For unit testing, actix provides a request builder type and a simple handler runner. TestRequest implements a builder-like pattern.
 /// You can generate various types of request via TestRequest's methods:
 ///  * `TestRequest::to_request` creates `actix_http::Request` instance.
-///  * `TestRequest::to_srv_request` creates `ServiceRequest` instance, which is used for testing middlewares and chain adapters.
-///  * `TestRequest::to_srv_response` creates `ServiceResponse` instance.
+///  * `TestRequest::to_srv_request` creates `WebRequest` instance, which is used for testing middlewares and chain adapters.
+///  * `TestRequest::to_srv_response` creates `WebResponse` instance.
 ///  * `TestRequest::to_http_request` creates `HttpRequest` instance, which is used for testing handlers.
 ///
 /// ```rust
@@ -461,13 +459,13 @@ impl TestRequest {
         req
     }
 
-    /// Complete request creation and generate `ServiceRequest` instance
-    pub fn to_srv_request(mut self) -> ServiceRequest {
+    /// Complete request creation and generate `WebRequest` instance
+    pub fn to_srv_request(mut self) -> WebRequest {
         let (mut head, payload) = self.req.finish().into_parts();
         head.peer_addr = self.peer_addr;
         self.path.get_mut().update(&head.uri);
 
-        ServiceRequest::new(HttpRequest::new(
+        WebRequest::new(HttpRequest::new(
             self.path,
             head,
             payload,
@@ -478,8 +476,8 @@ impl TestRequest {
         ))
     }
 
-    /// Complete request creation and generate `ServiceResponse` instance
-    pub fn to_srv_response<B>(self, res: HttpResponse<B>) -> ServiceResponse<B> {
+    /// Complete request creation and generate `WebResponse` instance
+    pub fn to_srv_response<B>(self, res: HttpResponse<B>) -> WebResponse<B> {
         self.to_srv_request().into_response(res)
     }
 
diff --git a/ntex/src/web/types/json.rs b/ntex/src/web/types/json.rs
index 180d96f0..90452603 100644
--- a/ntex/src/web/types/json.rs
+++ b/ntex/src/web/types/json.rs
@@ -288,7 +288,6 @@ impl Default for JsonConfig {
 }
 
 /// Request's payload json parser, it resolves to a deserialized `T` value.
-/// This future could be used with `ServiceRequest` and `ServiceFromRequest`.
 ///
 /// Returns error:
 ///
diff --git a/ntex/src/web/util.rs b/ntex/src/web/util.rs
index 78b1dca8..a76951c5 100644
--- a/ntex/src/web/util.rs
+++ b/ntex/src/web/util.rs
@@ -237,7 +237,7 @@ where
 /// use ntex::http::Error;
 /// use ntex::web::{self, dev, guard, App, HttpResponse};
 ///
-/// async fn my_service(req: dev::ServiceRequest) -> Result<dev::ServiceResponse, Error> {
+/// async fn my_service(req: dev::WebRequest) -> Result<dev::WebResponse, Error> {
 ///     Ok(req.into_response(HttpResponse::Ok().finish()))
 /// }
 ///