diff --git a/src/handler/future.rs b/src/handler/future.rs
index 68f139c8..999b96a9 100644
--- a/src/handler/future.rs
+++ b/src/handler/future.rs
@@ -2,7 +2,10 @@
 
 use crate::body::{box_body, BoxBody};
 use crate::util::{Either, EitherProj};
-use futures_util::{future::BoxFuture, ready};
+use futures_util::{
+    future::{BoxFuture, Map},
+    ready,
+};
 use http::{Method, Request, Response};
 use http_body::Empty;
 use pin_project_lite::pin_project;
@@ -64,5 +67,8 @@ where
 opaque_future! {
     /// The response future for [`IntoService`](super::IntoService).
     pub type IntoServiceFuture =
-        BoxFuture<'static, Result<Response<BoxBody>, Infallible>>;
+        Map<
+            BoxFuture<'static, Response<BoxBody>>,
+            fn(Response<BoxBody>) -> Result<Response<BoxBody>, Infallible>,
+        >;
 }
diff --git a/src/handler/into_service.rs b/src/handler/into_service.rs
index c5f6bcfc..ffc0fde0 100644
--- a/src/handler/into_service.rs
+++ b/src/handler/into_service.rs
@@ -1,9 +1,5 @@
 use super::Handler;
-use crate::{
-    body::{box_body, BoxBody},
-    extract::{FromRequest, RequestParts},
-    response::IntoResponse,
-};
+use crate::body::BoxBody;
 use http::{Request, Response};
 use std::{
     convert::Infallible,
@@ -16,12 +12,12 @@ use tower::Service;
 /// An adapter that makes a [`Handler`] into a [`Service`].
 ///
 /// Created with [`Handler::into_service`].
-pub struct IntoService<H, T> {
+pub struct IntoService<H, B, T> {
     handler: H,
-    _marker: PhantomData<fn() -> T>,
+    _marker: PhantomData<fn() -> (B, T)>,
 }
 
-impl<H, T> IntoService<H, T> {
+impl<H, B, T> IntoService<H, B, T> {
     pub(super) fn new(handler: H) -> Self {
         Self {
             handler,
@@ -30,7 +26,7 @@ impl<H, T> IntoService<H, T> {
     }
 }
 
-impl<H, T> fmt::Debug for IntoService<H, T> {
+impl<H, B, T> fmt::Debug for IntoService<H, B, T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_tuple("IntoService")
             .field(&format_args!("..."))
@@ -38,7 +34,7 @@ impl<H, T> fmt::Debug for IntoService<H, T> {
     }
 }
 
-impl<H, T> Clone for IntoService<H, T>
+impl<H, B, T> Clone for IntoService<H, B, T>
 where
     H: Clone,
 {
@@ -50,11 +46,9 @@ where
     }
 }
 
-impl<H, T, B> Service<Request<B>> for IntoService<H, T>
+impl<H, T, B> Service<Request<B>> for IntoService<H, B, T>
 where
-    H: Handler<T>,
-    T: FromRequest<B> + Send,
-    T::Rejection: Send,
+    H: Handler<B, T> + Clone + Send + 'static,
     B: Send + 'static,
 {
     type Response = Response<BoxBody>;
@@ -69,16 +63,10 @@ where
     }
 
     fn call(&mut self, req: Request<B>) -> Self::Future {
+        use futures_util::future::FutureExt;
+
         let handler = self.handler.clone();
-        let future = Box::pin(async move {
-            let mut req = RequestParts::new(req);
-            let input = T::from_request(&mut req).await;
-            let res = match input {
-                Ok(input) => Handler::call(handler, input).await,
-                Err(rejection) => rejection.into_response().map(box_body),
-            };
-            Ok::<_, Infallible>(res)
-        });
+        let future = Handler::call(handler, req).map(Ok::<_, Infallible> as _);
 
         super::future::IntoServiceFuture { future }
     }
diff --git a/src/handler/mod.rs b/src/handler/mod.rs
index a64e7c29..8fb0630c 100644
--- a/src/handler/mod.rs
+++ b/src/handler/mod.rs
@@ -2,7 +2,7 @@
 
 use crate::{
     body::{box_body, BoxBody},
-    extract::{FromRequest, RequestParts},
+    extract::FromRequest,
     response::IntoResponse,
     routing::{EmptyRouter, MethodFilter},
     service::HandleError,
@@ -44,9 +44,9 @@ pub use self::into_service::IntoService;
 /// # axum::Server::bind(&"".parse().unwrap()).serve(app.into_make_service()).await.unwrap();
 /// # };
 /// ```
-pub fn any<H, T>(handler: H) -> OnMethod<H, T, EmptyRouter>
+pub fn any<H, B, T>(handler: H) -> OnMethod<H, B, T, EmptyRouter>
 where
-    H: Handler<T>,
+    H: Handler<B, T>,
 {
     on(MethodFilter::all(), handler)
 }
@@ -54,9 +54,9 @@ where
 /// Route `CONNECT` requests to the given handler.
 ///
 /// See [`get`] for an example.
-pub fn connect<H, T>(handler: H) -> OnMethod<H, T, EmptyRouter>
+pub fn connect<H, B, T>(handler: H) -> OnMethod<H, B, T, EmptyRouter>
 where
-    H: Handler<T>,
+    H: Handler<B, T>,
 {
     on(MethodFilter::CONNECT, handler)
 }
@@ -64,9 +64,9 @@ where
 /// Route `DELETE` requests to the given handler.
 ///
 /// See [`get`] for an example.
-pub fn delete<H, T>(handler: H) -> OnMethod<H, T, EmptyRouter>
+pub fn delete<H, B, T>(handler: H) -> OnMethod<H, B, T, EmptyRouter>
 where
-    H: Handler<T>,
+    H: Handler<B, T>,
 {
     on(MethodFilter::DELETE, handler)
 }
@@ -93,9 +93,9 @@ where
 /// Note that `get` routes will also be called for `HEAD` requests but will have
 /// the response body removed. Make sure to add explicit `HEAD` routes
 /// afterwards.
-pub fn get<H, T>(handler: H) -> OnMethod<H, T, EmptyRouter>
+pub fn get<H, B, T>(handler: H) -> OnMethod<H, B, T, EmptyRouter>
 where
-    H: Handler<T>,
+    H: Handler<B, T>,
 {
     on(MethodFilter::GET | MethodFilter::HEAD, handler)
 }
@@ -103,9 +103,9 @@ where
 /// Route `HEAD` requests to the given handler.
 ///
 /// See [`get`] for an example.
-pub fn head<H, T>(handler: H) -> OnMethod<H, T, EmptyRouter>
+pub fn head<H, B, T>(handler: H) -> OnMethod<H, B, T, EmptyRouter>
 where
-    H: Handler<T>,
+    H: Handler<B, T>,
 {
     on(MethodFilter::HEAD, handler)
 }
@@ -113,9 +113,9 @@ where
 /// Route `OPTIONS` requests to the given handler.
 ///
 /// See [`get`] for an example.
-pub fn options<H, T>(handler: H) -> OnMethod<H, T, EmptyRouter>
+pub fn options<H, B, T>(handler: H) -> OnMethod<H, B, T, EmptyRouter>
 where
-    H: Handler<T>,
+    H: Handler<B, T>,
 {
     on(MethodFilter::OPTIONS, handler)
 }
@@ -123,9 +123,9 @@ where
 /// Route `PATCH` requests to the given handler.
 ///
 /// See [`get`] for an example.
-pub fn patch<H, T>(handler: H) -> OnMethod<H, T, EmptyRouter>
+pub fn patch<H, B, T>(handler: H) -> OnMethod<H, B, T, EmptyRouter>
 where
-    H: Handler<T>,
+    H: Handler<B, T>,
 {
     on(MethodFilter::PATCH, handler)
 }
@@ -133,9 +133,9 @@ where
 /// Route `POST` requests to the given handler.
 ///
 /// See [`get`] for an example.
-pub fn post<H, T>(handler: H) -> OnMethod<H, T, EmptyRouter>
+pub fn post<H, B, T>(handler: H) -> OnMethod<H, B, T, EmptyRouter>
 where
-    H: Handler<T>,
+    H: Handler<B, T>,
 {
     on(MethodFilter::POST, handler)
 }
@@ -143,9 +143,9 @@ where
 /// Route `PUT` requests to the given handler.
 ///
 /// See [`get`] for an example.
-pub fn put<H, T>(handler: H) -> OnMethod<H, T, EmptyRouter>
+pub fn put<H, B, T>(handler: H) -> OnMethod<H, B, T, EmptyRouter>
 where
-    H: Handler<T>,
+    H: Handler<B, T>,
 {
     on(MethodFilter::PUT, handler)
 }
@@ -153,9 +153,9 @@ where
 /// Route `TRACE` requests to the given handler.
 ///
 /// See [`get`] for an example.
-pub fn trace<H, T>(handler: H) -> OnMethod<H, T, EmptyRouter>
+pub fn trace<H, B, T>(handler: H) -> OnMethod<H, B, T, EmptyRouter>
 where
-    H: Handler<T>,
+    H: Handler<B, T>,
 {
     on(MethodFilter::TRACE, handler)
 }
@@ -179,9 +179,9 @@ where
 /// # axum::Server::bind(&"".parse().unwrap()).serve(app.into_make_service()).await.unwrap();
 /// # };
 /// ```
-pub fn on<H, T>(method: MethodFilter, handler: H) -> OnMethod<H, T, EmptyRouter>
+pub fn on<H, B, T>(method: MethodFilter, handler: H) -> OnMethod<H, B, T, EmptyRouter>
 where
-    H: Handler<T>,
+    H: Handler<B, T>,
 {
     OnMethod {
         method,
@@ -206,14 +206,14 @@ pub(crate) mod sealed {
 ///
 /// See the [module docs](crate::handler) for more details.
 #[async_trait]
-pub trait Handler<T>: Clone + Send + Sync + Sized + 'static {
+pub trait Handler<B, T>: Clone + Send + Sized + 'static {
     // This seals the trait. We cannot use the regular "sealed super trait"
     // approach due to coherence.
     #[doc(hidden)]
     type Sealed: sealed::HiddentTrait;
 
-    /// Call the handler.
-    async fn call(self, input: T) -> Response<BoxBody>;
+    /// Call the handler with the given request.
+    async fn call(self, req: Request<B>) -> Response<BoxBody>;
 
     /// Apply a [`tower::Layer`] to the handler.
     ///
@@ -251,7 +251,7 @@ pub trait Handler<T>: Clone + Send + Sync + Sized + 'static {
     /// errors. See [`Layered::handle_error`] for more details.
     fn layer<L>(self, layer: L) -> Layered<L::Service, T>
     where
-        L: Layer<OnMethod<Self, T, EmptyRouter>>,
+        L: Layer<OnMethod<Self, B, T, EmptyRouter>>,
     {
         Layered::new(layer.layer(any(self)))
     }
@@ -280,21 +280,22 @@ pub trait Handler<T>: Clone + Send + Sync + Sized + 'static {
     /// # Ok::<_, hyper::Error>(())
     /// # };
     /// ```
-    fn into_service(self) -> IntoService<Self, T> {
+    fn into_service(self) -> IntoService<Self, B, T> {
         IntoService::new(self)
     }
 }
 
 #[async_trait]
-impl<F, Fut, Res> Handler<()> for F
+impl<F, Fut, Res, B> Handler<B, ()> for F
 where
     F: FnOnce() -> Fut + Clone + Send + Sync + 'static,
     Fut: Future<Output = Res> + Send,
     Res: IntoResponse,
+    B: Send + 'static,
 {
     type Sealed = sealed::Hidden;
 
-    async fn call(self, _: ()) -> Response<BoxBody> {
+    async fn call(self, _req: Request<B>) -> Response<BoxBody> {
         self().await.into_response().map(box_body)
     }
 }
@@ -306,18 +307,35 @@ macro_rules! impl_handler {
     ( $head:ident, $($tail:ident),* $(,)? ) => {
         #[async_trait]
         #[allow(non_snake_case)]
-        impl<F, Fut, Res, $head, $($tail,)*> Handler<($head, $($tail,)*)> for F
+        impl<F, Fut, B, Res, $head, $($tail,)*> Handler<B, ($head, $($tail,)*)> for F
         where
             F: FnOnce($head, $($tail,)*) -> Fut + Clone + Send + Sync + 'static,
             Fut: Future<Output = Res> + Send,
+            B: Send + 'static,
             Res: IntoResponse,
-            $head: Send + 'static,
-            $( $tail: Send + 'static ),*
+            B: Send + 'static,
+            $head: FromRequest<B> + Send,
+            $( $tail: FromRequest<B> + Send,)*
         {
             type Sealed = sealed::Hidden;
 
-            async fn call(self, ($head, $($tail,)*): ($head, $($tail,)*)) -> Response<BoxBody> {
+            async fn call(self, req: Request<B>) -> Response<BoxBody> {
+                let mut req = crate::extract::RequestParts::new(req);
+
+                let $head = match $head::from_request(&mut req).await {
+                    Ok(value) => value,
+                    Err(rejection) => return rejection.into_response().map(box_body),
+                };
+
+                $(
+                    let $tail = match $tail::from_request(&mut req).await {
+                        Ok(value) => value,
+                        Err(rejection) => return rejection.into_response().map(box_body),
+                    };
+                )*
+
                 let res = self($head, $($tail,)*).await;
+
                 res.into_response().map(crate::body::box_body)
             }
         }
@@ -355,9 +373,9 @@ where
 }
 
 #[async_trait]
-impl<S, T, ReqBody, ResBody> Handler<(Request<ReqBody>,)> for Layered<S, T>
+impl<S, T, ReqBody, ResBody> Handler<ReqBody, T> for Layered<S, T>
 where
-    S: Service<Request<ReqBody>, Response = Response<ResBody>> + Clone + Send + Sync + 'static,
+    S: Service<Request<ReqBody>, Response = Response<ResBody>> + Clone + Send + 'static,
     S::Error: IntoResponse,
     S::Future: Send,
     T: 'static,
@@ -367,7 +385,7 @@ where
 {
     type Sealed = sealed::Hidden;
 
-    async fn call(self, (req,): (Request<ReqBody>,)) -> Response<BoxBody> {
+    async fn call(self, req: Request<ReqBody>) -> Response<BoxBody> {
         match self
             .svc
             .oneshot(req)
@@ -413,14 +431,14 @@ impl<S, T> Layered<S, T> {
 
 /// A handler [`Service`] that accepts requests based on a [`MethodFilter`] and
 /// allows chaining additional handlers.
-pub struct OnMethod<H, T, F> {
+pub struct OnMethod<H, B, T, F> {
     pub(crate) method: MethodFilter,
     pub(crate) handler: H,
     pub(crate) fallback: F,
-    pub(crate) _marker: PhantomData<fn() -> T>,
+    pub(crate) _marker: PhantomData<fn() -> (B, T)>,
 }
 
-impl<H, T, F> fmt::Debug for OnMethod<H, T, F>
+impl<H, B, T, F> fmt::Debug for OnMethod<H, B, T, F>
 where
     T: fmt::Debug,
     F: fmt::Debug,
@@ -434,7 +452,7 @@ where
     }
 }
 
-impl<H, T, F> Clone for OnMethod<H, T, F>
+impl<H, B, T, F> Clone for OnMethod<H, B, T, F>
 where
     H: Clone,
     F: Clone,
@@ -449,21 +467,21 @@ where
     }
 }
 
-impl<H, T, F> Copy for OnMethod<H, T, F>
+impl<H, B, T, F> Copy for OnMethod<H, B, T, F>
 where
     H: Copy,
     F: Copy,
 {
 }
 
-impl<H, T, F> OnMethod<H, T, F> {
+impl<H, B, T, F> OnMethod<H, B, T, F> {
     /// Chain an additional handler that will accept all requests regardless of
     /// its HTTP method.
     ///
     /// See [`OnMethod::get`] for an example.
-    pub fn any<H2, T2>(self, handler: H2) -> OnMethod<H2, T2, Self>
+    pub fn any<H2, T2>(self, handler: H2) -> OnMethod<H2, B, T2, Self>
     where
-        H2: Handler<T2>,
+        H2: Handler<B, T2>,
     {
         self.on(MethodFilter::all(), handler)
     }
@@ -471,9 +489,9 @@ impl<H, T, F> OnMethod<H, T, F> {
     /// Chain an additional handler that will only accept `CONNECT` requests.
     ///
     /// See [`OnMethod::get`] for an example.
-    pub fn connect<H2, T2>(self, handler: H2) -> OnMethod<H2, T2, Self>
+    pub fn connect<H2, T2>(self, handler: H2) -> OnMethod<H2, B, T2, Self>
     where
-        H2: Handler<T2>,
+        H2: Handler<B, T2>,
     {
         self.on(MethodFilter::CONNECT, handler)
     }
@@ -481,9 +499,9 @@ impl<H, T, F> OnMethod<H, T, F> {
     /// Chain an additional handler that will only accept `DELETE` requests.
     ///
     /// See [`OnMethod::get`] for an example.
-    pub fn delete<H2, T2>(self, handler: H2) -> OnMethod<H2, T2, Self>
+    pub fn delete<H2, T2>(self, handler: H2) -> OnMethod<H2, B, T2, Self>
     where
-        H2: Handler<T2>,
+        H2: Handler<B, T2>,
     {
         self.on(MethodFilter::DELETE, handler)
     }
@@ -510,9 +528,9 @@ impl<H, T, F> OnMethod<H, T, F> {
     /// Note that `get` routes will also be called for `HEAD` requests but will have
     /// the response body removed. Make sure to add explicit `HEAD` routes
     /// afterwards.
-    pub fn get<H2, T2>(self, handler: H2) -> OnMethod<H2, T2, Self>
+    pub fn get<H2, T2>(self, handler: H2) -> OnMethod<H2, B, T2, Self>
     where
-        H2: Handler<T2>,
+        H2: Handler<B, T2>,
     {
         self.on(MethodFilter::GET | MethodFilter::HEAD, handler)
     }
@@ -520,9 +538,9 @@ impl<H, T, F> OnMethod<H, T, F> {
     /// Chain an additional handler that will only accept `HEAD` requests.
     ///
     /// See [`OnMethod::get`] for an example.
-    pub fn head<H2, T2>(self, handler: H2) -> OnMethod<H2, T2, Self>
+    pub fn head<H2, T2>(self, handler: H2) -> OnMethod<H2, B, T2, Self>
     where
-        H2: Handler<T2>,
+        H2: Handler<B, T2>,
     {
         self.on(MethodFilter::HEAD, handler)
     }
@@ -530,9 +548,9 @@ impl<H, T, F> OnMethod<H, T, F> {
     /// Chain an additional handler that will only accept `OPTIONS` requests.
     ///
     /// See [`OnMethod::get`] for an example.
-    pub fn options<H2, T2>(self, handler: H2) -> OnMethod<H2, T2, Self>
+    pub fn options<H2, T2>(self, handler: H2) -> OnMethod<H2, B, T2, Self>
     where
-        H2: Handler<T2>,
+        H2: Handler<B, T2>,
     {
         self.on(MethodFilter::OPTIONS, handler)
     }
@@ -540,9 +558,9 @@ impl<H, T, F> OnMethod<H, T, F> {
     /// Chain an additional handler that will only accept `PATCH` requests.
     ///
     /// See [`OnMethod::get`] for an example.
-    pub fn patch<H2, T2>(self, handler: H2) -> OnMethod<H2, T2, Self>
+    pub fn patch<H2, T2>(self, handler: H2) -> OnMethod<H2, B, T2, Self>
     where
-        H2: Handler<T2>,
+        H2: Handler<B, T2>,
     {
         self.on(MethodFilter::PATCH, handler)
     }
@@ -550,9 +568,9 @@ impl<H, T, F> OnMethod<H, T, F> {
     /// Chain an additional handler that will only accept `POST` requests.
     ///
     /// See [`OnMethod::get`] for an example.
-    pub fn post<H2, T2>(self, handler: H2) -> OnMethod<H2, T2, Self>
+    pub fn post<H2, T2>(self, handler: H2) -> OnMethod<H2, B, T2, Self>
     where
-        H2: Handler<T2>,
+        H2: Handler<B, T2>,
     {
         self.on(MethodFilter::POST, handler)
     }
@@ -560,9 +578,9 @@ impl<H, T, F> OnMethod<H, T, F> {
     /// Chain an additional handler that will only accept `PUT` requests.
     ///
     /// See [`OnMethod::get`] for an example.
-    pub fn put<H2, T2>(self, handler: H2) -> OnMethod<H2, T2, Self>
+    pub fn put<H2, T2>(self, handler: H2) -> OnMethod<H2, B, T2, Self>
     where
-        H2: Handler<T2>,
+        H2: Handler<B, T2>,
     {
         self.on(MethodFilter::PUT, handler)
     }
@@ -570,9 +588,9 @@ impl<H, T, F> OnMethod<H, T, F> {
     /// Chain an additional handler that will only accept `TRACE` requests.
     ///
     /// See [`OnMethod::get`] for an example.
-    pub fn trace<H2, T2>(self, handler: H2) -> OnMethod<H2, T2, Self>
+    pub fn trace<H2, T2>(self, handler: H2) -> OnMethod<H2, B, T2, Self>
     where
-        H2: Handler<T2>,
+        H2: Handler<B, T2>,
     {
         self.on(MethodFilter::TRACE, handler)
     }
@@ -600,9 +618,9 @@ impl<H, T, F> OnMethod<H, T, F> {
     /// # axum::Server::bind(&"".parse().unwrap()).serve(app.into_make_service()).await.unwrap();
     /// # };
     /// ```
-    pub fn on<H2, T2>(self, method: MethodFilter, handler: H2) -> OnMethod<H2, T2, Self>
+    pub fn on<H2, T2>(self, method: MethodFilter, handler: H2) -> OnMethod<H2, B, T2, Self>
     where
-        H2: Handler<T2>,
+        H2: Handler<B, T2>,
     {
         OnMethod {
             method,
@@ -613,12 +631,10 @@ impl<H, T, F> OnMethod<H, T, F> {
     }
 }
 
-impl<H, T, B, F> Service<Request<B>> for OnMethod<H, T, F>
+impl<H, B, T, F> Service<Request<B>> for OnMethod<H, B, T, F>
 where
-    H: Handler<T>,
-    T: FromRequest<B> + Send,
-    T::Rejection: Send,
-    F: Service<Request<B>, Response = Response<BoxBody>, Error = Infallible> + Clone + Send,
+    H: Handler<B, T>,
+    F: Service<Request<B>, Response = Response<BoxBody>, Error = Infallible> + Clone,
     B: Send + 'static,
 {
     type Response = Response<BoxBody>;
@@ -633,15 +649,7 @@ where
         let req_method = req.method().clone();
 
         let fut = if self.method.matches(req.method()) {
-            let handler = self.handler.clone();
-            let fut = Box::pin(async move {
-                let mut req = RequestParts::new(req);
-                let input = T::from_request(&mut req).await;
-                match input {
-                    Ok(input) => Handler::call(handler, input).await,
-                    Err(rejection) => rejection.into_response().map(box_body),
-                }
-            }) as _;
+            let fut = Handler::call(self.handler.clone(), req);
             Either::A { inner: fut }
         } else {
             let fut = self.fallback.clone().oneshot(req);
diff --git a/src/tests/handle_error.rs b/src/tests/handle_error.rs
index 92a1bdb6..cc93fe25 100644
--- a/src/tests/handle_error.rs
+++ b/src/tests/handle_error.rs
@@ -191,9 +191,9 @@ fn service_handle_on_router_still_impls_routing_dsl() {
 #[test]
 fn layered() {
     let app = Router::new()
-        .route("/echo", get(unit))
+        .route("/echo", get::<_, Body, _>(unit))
         .layer(timeout())
-        .handle_error::<Body, _>(handle_error::<BoxError>);
+        .handle_error(handle_error::<BoxError>);
 
     check_make_svc::<_, _, _, Infallible>(app.into_make_service());
 }
@@ -201,9 +201,9 @@ fn layered() {
 #[tokio::test] // async because of `.boxed()`
 async fn layered_boxed() {
     let app = Router::new()
-        .route("/echo", get(unit))
+        .route("/echo", get::<_, Body, _>(unit))
         .layer(timeout())
-        .boxed::<Body, _>()
+        .boxed()
         .handle_error(handle_error::<BoxError>);
 
     check_make_svc::<_, _, _, Infallible>(app.into_make_service());