diff --git a/Cargo.toml b/Cargo.toml
index 1d90703..1c0fcdf 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -23,6 +23,8 @@ hex = { package = "hex-conservative", version = "0.2" }
 log = "^0.4"
 minreq = { version = "2.11.0", features = ["json-using-serde"], optional = true }
 reqwest = { version = "0.11", optional = true, default-features = false, features = ["json"] }
+serde_json = { version = "1.0.127" }
+async-trait = { version = "0.1.82" }
 
 [dev-dependencies]
 serde_json = "1.0"
diff --git a/src/api.rs b/src/api.rs
index d4dfa1e..e481c2f 100644
--- a/src/api.rs
+++ b/src/api.rs
@@ -1,16 +1,419 @@
-//! structs from the esplora API
+//! Structures from the esplora API
 //!
-//! see: <https://github.com/Blockstream/esplora/blob/master/API.md>
+//! See: <https://github.com/Blockstream/esplora/blob/master/API.md>
 
+use core::str;
+use std::{future::Future, str::FromStr};
+
+use async_trait::async_trait;
+use bitcoin::consensus::Decodable;
 pub use bitcoin::consensus::{deserialize, serialize};
+use bitcoin::hashes::sha256::Hash;
 pub use bitcoin::hex::FromHex;
 use bitcoin::Weight;
 pub use bitcoin::{
     transaction, Amount, BlockHash, OutPoint, ScriptBuf, Transaction, TxIn, TxOut, Txid, Witness,
 };
 
+use hex::DisplayHex;
 use serde::Deserialize;
 
+/// An HTTP request method.
+pub enum Method {
+    /// The GET method
+    Get,
+    /// The POST method
+    Post,
+}
+
+/// A URL type for requests.
+type Url = String;
+
+/// A minimal HTTP request.
+pub struct Request {
+    pub method: Method,
+    pub url: Url,
+    pub body: Option<Vec<u8>>,
+}
+
+impl Request {
+    fn new(method: Method, url: Url, body: Option<Vec<u8>>) -> Self {
+        Self { method, url, body }
+    }
+}
+
+#[derive(Debug)]
+#[allow(unused)]
+pub struct Response {
+    pub status_code: i32,
+    pub body: Vec<u8>,
+    // pub reason: String,
+    // pub headers: HashMap<String, String>,
+    // pub url: Url,
+}
+
+impl Response {
+    pub fn new(
+        status_code: i32,
+        body: Vec<u8>,
+        // reason_phrase: String,
+        // headers: HashMap<String, String>,
+        // url: Url,
+    ) -> Self {
+        Self {
+            status_code,
+            body,
+            // reason: reason_phrase,
+            // headers,
+            // url,
+        }
+    }
+
+    pub fn is_status_ok(&self) -> bool {
+        self.status_code == 200
+    }
+
+    pub fn as_str(&self) -> Result<&str, crate::Error> {
+        match str::from_utf8(&self.body) {
+            Ok(s) => Ok(s),
+            Err(e) => Err(crate::Error::InvalidUtf8InBody(e)),
+        }
+    }
+}
+
+pub enum TransactionApi {
+    Tx(Txid),
+    TxInfo(Txid),
+    TxStatus(Txid),
+    TxMerkeBlockProof(Txid),
+    TxMerkleProof(Txid),
+    TxOutputStatus(Txid, u64),
+    Broadcast(Transaction),
+}
+
+impl Client for TransactionApi {
+    fn request(&self, base_url: &str) -> Request {
+        match self {
+            TransactionApi::Tx(txid) => {
+                Request::new(Method::Get, format!("{base_url}/tx/{txid}/raw"), None)
+            }
+            TransactionApi::TxStatus(txid) => {
+                Request::new(Method::Get, format!("{base_url}/tx/{txid}/status"), None)
+            }
+            TransactionApi::TxInfo(txid) => {
+                Request::new(Method::Get, format!("{base_url}/tx/{txid}"), None)
+            }
+            TransactionApi::TxMerkeBlockProof(txid) => Request::new(
+                Method::Get,
+                format!("{base_url}/tx/{txid}/merkleblock-proof"),
+                None,
+            ),
+            TransactionApi::TxMerkleProof(txid) => Request::new(
+                Method::Get,
+                format!("{base_url}/tx/{txid}/merkle-proof"),
+                None,
+            ),
+            TransactionApi::TxOutputStatus(txid, index) => Request::new(
+                Method::Get,
+                format!("{base_url}/tx/{txid}/outspend/{index}"),
+                None,
+            ),
+            TransactionApi::Broadcast(tx) => Request::new(
+                Method::Post,
+                format!("{base_url}/tx"),
+                Some(
+                    bitcoin::consensus::encode::serialize(tx)
+                        .to_lower_hex_string()
+                        .as_bytes()
+                        .to_vec(),
+                ),
+            ),
+        }
+    }
+
+    fn deserialize_decodable<T: Decodable>(&self, response: &Response) -> Result<T, crate::Error> {
+        if !response.is_status_ok() {
+            let status = u16::try_from(response.status_code).map_err(crate::Error::StatusCode)?;
+            let message = response.as_str()?.to_string();
+            return Err(crate::Error::HttpResponse { status, message });
+        }
+
+        match self {
+            TransactionApi::TxMerkeBlockProof(_) => {
+                let hex_str = response.as_str()?;
+                let hex_vec = Vec::from_hex(hex_str)?;
+                deserialize::<T>(&hex_vec).map_err(crate::Error::BitcoinEncoding)
+            }
+            _ => deserialize::<T>(&response.body).map_err(crate::Error::BitcoinEncoding),
+        }
+    }
+
+    fn deserialize_json<T: serde::de::DeserializeOwned>(
+        &self,
+        response: &Response,
+    ) -> Result<T, crate::Error> {
+        if !response.is_status_ok() {
+            let status = u16::try_from(response.status_code).map_err(crate::Error::StatusCode)?;
+            let message = response.as_str()?.to_string();
+            return Err(crate::Error::HttpResponse { status, message });
+        }
+
+        serde_json::from_slice(&response.body).map_err(crate::Error::SerdeJsonError)
+    }
+
+    fn deserialize_str<T: FromStr>(&self, _response: &Response) -> Result<T, crate::Error> {
+        unimplemented!("It's currently not required by `TransactionApi`")
+    }
+}
+
+pub enum AddressApi {
+    ScriptHashTxHistory(Hash),
+    ScriptHashConfirmedTxHistory(Hash, Txid),
+}
+
+impl Client for AddressApi {
+    fn request(&self, base_url: &str) -> Request {
+        match self {
+            AddressApi::ScriptHashTxHistory(script_hash) => Request::new(
+                Method::Get,
+                format!("{base_url}/scripthash/{:x}/txs", script_hash),
+                None,
+            ),
+            AddressApi::ScriptHashConfirmedTxHistory(script_hash, last_seen) => Request::new(
+                Method::Get,
+                format!(
+                    "{base_url}/scripthash/{:x}/txs/chain/{}",
+                    script_hash, last_seen
+                ),
+                None,
+            ),
+        }
+    }
+
+    fn deserialize_decodable<T: Decodable>(&self, _response: &Response) -> Result<T, crate::Error> {
+        unimplemented!("It's currently not required by `AddressApi`")
+    }
+
+    fn deserialize_json<T: serde::de::DeserializeOwned>(
+        &self,
+        response: &Response,
+    ) -> Result<T, crate::Error> {
+        if !response.is_status_ok() {
+            let status = u16::try_from(response.status_code).map_err(crate::Error::StatusCode)?;
+            let message = response.as_str()?.to_string();
+            return Err(crate::Error::HttpResponse { status, message });
+        }
+
+        serde_json::from_slice(&response.body).map_err(crate::Error::SerdeJsonError)
+    }
+
+    fn deserialize_str<T: FromStr>(&self, _response: &Response) -> Result<T, crate::Error> {
+        unimplemented!("It's currently not required by `AddressApi`")
+    }
+}
+
+pub enum BlocksApi {
+    BlockTxIdAtIndex(BlockHash, usize),
+    BlockHeader(BlockHash),
+    BlockStatus(BlockHash),
+    BlockRaw(BlockHash),
+    BlockTipHeight,
+    BlockTipHash,
+    BlockHash(u32),
+    BlockSummaries(Option<u32>),
+}
+
+impl Client for BlocksApi {
+    fn request(&self, base_url: &str) -> Request {
+        match self {
+            BlocksApi::BlockTxIdAtIndex(block_hash, index) => Request::new(
+                Method::Get,
+                format!("{base_url}/block/{block_hash}/txid/{index}"),
+                None,
+            ),
+            BlocksApi::BlockHeader(block_hash) => Request::new(
+                Method::Get,
+                format!("{base_url}/block/{block_hash}/header"),
+                None,
+            ),
+            BlocksApi::BlockStatus(block_hash) => Request::new(
+                Method::Get,
+                format!("{base_url}/block/{block_hash}/status"),
+                None,
+            ),
+            BlocksApi::BlockRaw(block_hash) => Request::new(
+                Method::Get,
+                format!("{base_url}/block/{block_hash}/raw"),
+                None,
+            ),
+            BlocksApi::BlockTipHeight => {
+                Request::new(Method::Get, format!("{base_url}/blocks/tip/height"), None)
+            }
+            BlocksApi::BlockTipHash => {
+                Request::new(Method::Get, format!("{base_url}/blocks/tip/hash"), None)
+            }
+            BlocksApi::BlockHash(block_height) => Request::new(
+                Method::Get,
+                format!("{base_url}/block-height/{block_height}"),
+                None,
+            ),
+            BlocksApi::BlockSummaries(block_height) => match block_height {
+                Some(height) => {
+                    Request::new(Method::Get, format!("{base_url}/blocks/{height}"), None)
+                }
+                None => Request::new(Method::Get, format!("{base_url}/blocks"), None),
+            },
+        }
+    }
+
+    fn deserialize_decodable<T: Decodable>(&self, response: &Response) -> Result<T, crate::Error> {
+        if !response.is_status_ok() {
+            let status = u16::try_from(response.status_code).map_err(crate::Error::StatusCode)?;
+            let message = response.as_str()?.to_string();
+            return Err(crate::Error::HttpResponse { status, message });
+        }
+
+        match self {
+            BlocksApi::BlockHeader(_) => {
+                let hex_str = response.as_str()?;
+                let hex_vec = Vec::from_hex(hex_str)?;
+                deserialize::<T>(&hex_vec).map_err(crate::Error::BitcoinEncoding)
+            },
+            BlocksApi::BlockRaw(_) => {
+                deserialize::<T>(&response.body).map_err(crate::Error::BitcoinEncoding)
+            },
+            _ => unimplemented!("It cannot be deserialized by `deserialize_decodable`, use either `deserialize_str` or `deserialize_json` instead.")
+        }
+    }
+
+    fn deserialize_json<T: serde::de::DeserializeOwned>(
+        &self,
+        response: &Response,
+    ) -> Result<T, crate::Error> {
+        if !response.is_status_ok() {
+            let status = u16::try_from(response.status_code).map_err(crate::Error::StatusCode)?;
+            let message = response.as_str()?.to_string();
+            return Err(crate::Error::HttpResponse { status, message });
+        }
+
+        match self {
+            BlocksApi::BlockStatus(_) | BlocksApi::BlockSummaries(_) => {
+                serde_json::from_slice(&response.body).map_err(crate::Error::SerdeJsonError)
+            }
+            BlocksApi::BlockHeader(_) | BlocksApi::BlockRaw(_) => {
+                unimplemented!("It cannot be deserialized by `deserialize_json`, use `deserialize_decodable` instead.")
+            }
+            BlocksApi::BlockTxIdAtIndex(_, _)
+            | BlocksApi::BlockTipHeight
+            | BlocksApi::BlockTipHash
+            | BlocksApi::BlockHash(_) => {
+                unimplemented!("It cannot be deserialized by `deserialize_json`, use `deserialize_str` instead.")
+            }
+        }
+    }
+
+    // TODO: (@leonardo) how can we return proper error here instead of unwrap ?
+    fn deserialize_str<T: FromStr>(&self, response: &Response) -> Result<T, crate::Error>
+    where
+        <T as FromStr>::Err: std::fmt::Debug,
+    {
+        if !response.is_status_ok() {
+            let status = u16::try_from(response.status_code).map_err(crate::Error::StatusCode)?;
+            let message = response.as_str()?.to_string();
+            return Err(crate::Error::HttpResponse { status, message });
+        }
+
+        match self {
+            BlocksApi::BlockTxIdAtIndex(_, _) | BlocksApi::BlockTipHash | BlocksApi::BlockHash(_) | BlocksApi::BlockTipHeight => {
+                Ok(T::from_str(response.as_str()?).unwrap()) // FIXME: (@leonardo) remove this unwrap
+            }
+            BlocksApi::BlockHeader(_) | BlocksApi::BlockRaw(_) => unimplemented!("It cannot be deserialized by `deserialize_str`, use `deserialize_decodable` instead."),
+            BlocksApi::BlockStatus(_) | BlocksApi::BlockSummaries(_) => unimplemented!("It cannot be deserialized by `deserialize_str`, use `deserialize_json` instead."),
+        }
+    }
+}
+
+pub enum FeeEstimatesApi {
+    FeeRate,
+}
+
+impl Client for FeeEstimatesApi {
+    fn request(&self, base_url: &str) -> Request {
+        match self {
+            FeeEstimatesApi::FeeRate => {
+                Request::new(Method::Get, format!("{base_url}/fee-estimates"), None)
+            }
+        }
+    }
+
+    fn deserialize_decodable<T: Decodable>(&self, _response: &Response) -> Result<T, crate::Error> {
+        unimplemented!("It's currently not required by `FeeEstimatesApi`")
+    }
+
+    fn deserialize_json<T: serde::de::DeserializeOwned>(
+        &self,
+        response: &Response,
+    ) -> Result<T, crate::Error> {
+        if !response.is_status_ok() {
+            let status = u16::try_from(response.status_code).map_err(crate::Error::StatusCode)?;
+            let message = response.as_str()?.to_string();
+            return Err(crate::Error::HttpResponse { status, message });
+        }
+
+        serde_json::from_slice(&response.body).map_err(crate::Error::SerdeJsonError)
+    }
+
+    fn deserialize_str<T: FromStr>(&self, _response: &Response) -> Result<T, crate::Error>
+    where
+        <T as FromStr>::Err: std::fmt::Debug,
+    {
+        unimplemented!("It's currently not required by `FeeEstimatesApi`")
+    }
+}
+
+#[derive(Debug)]
+pub enum Error<E> {
+    Client(E),
+}
+
+#[async_trait]
+pub trait Client {
+    fn request(&self, base_url: &str) -> Request;
+
+    fn send<F, E>(&self, base_url: &str, handler: &mut F) -> Result<Response, Error<E>>
+    where
+        F: FnMut(Request) -> Result<Response, E>,
+    {
+        let request = self.request(base_url);
+        handler(request).map_err(Error::Client)
+    }
+
+    async fn send_async<'a, F, Fut, E>(
+        &'a self,
+        base_url: &'a str,
+        handler: &'a mut F,
+    ) -> Result<Response, Error<E>>
+    where
+        F: FnMut(Request) -> Fut + Send,
+        Fut: Future<Output = Result<Response, E>> + Send + Sync,
+        Self: Sync,
+    {
+        let request = self.request(base_url);
+        handler(request).await.map_err(Error::Client)
+    }
+
+    fn deserialize_decodable<T: Decodable>(&self, response: &Response) -> Result<T, crate::Error>;
+
+    fn deserialize_json<T: serde::de::DeserializeOwned>(
+        &self,
+        response: &Response,
+    ) -> Result<T, crate::Error>;
+
+    fn deserialize_str<T: FromStr>(&self, response: &Response) -> Result<T, crate::Error>
+    where
+        <T as FromStr>::Err: std::fmt::Debug;
+}
+
 #[derive(Deserialize, Clone, Debug, PartialEq, Eq)]
 pub struct PrevOut {
     pub value: u64,
diff --git a/src/async.rs b/src/async.rs
index 62b1689..7870de6 100644
--- a/src/async.rs
+++ b/src/async.rs
@@ -14,9 +14,7 @@
 use std::collections::HashMap;
 use std::str::FromStr;
 
-use bitcoin::consensus::{deserialize, serialize};
 use bitcoin::hashes::{sha256, Hash};
-use bitcoin::hex::{DisplayHex, FromHex};
 use bitcoin::{
     block::Header as BlockHeader, Block, BlockHash, MerkleBlock, Script, Transaction, Txid,
 };
@@ -24,24 +22,53 @@ use bitcoin::{
 #[allow(unused_imports)]
 use log::{debug, error, info, trace};
 
-use reqwest::{header, Client, StatusCode};
+use reqwest::header;
 
-use crate::{BlockStatus, BlockSummary, Builder, Error, MerkleProof, OutputStatus, Tx, TxStatus};
+use crate::{
+    AddressApi, BlockStatus, BlockSummary, BlocksApi, Builder, Client, Error, FeeEstimatesApi,
+    MerkleProof, OutputStatus, Response, TransactionApi, Tx, TxStatus,
+};
+
+pub(crate) async fn handler(
+    client: &reqwest::Client,
+    request: crate::Request,
+) -> Result<Response, reqwest::Error> {
+    let reqwest_req = match request.method {
+        crate::Method::Get => client.request(
+            reqwest::Method::GET,
+            reqwest::Url::from_str(&request.url).unwrap(),
+        ),
+        crate::Method::Post => client
+            .request(
+                reqwest::Method::POST,
+                reqwest::Url::from_str(&request.url).unwrap(),
+            )
+            .body(request.body.expect("It should've a non-empty body!")),
+    };
+
+    let response = reqwest_req.send().await?;
+
+    Ok(Response::new(
+        response.status().as_u16().into(),
+        response.bytes().await.unwrap().to_vec(),
+    ))
+}
 
 #[derive(Debug, Clone)]
 pub struct AsyncClient {
     url: String,
-    client: Client,
+    client: reqwest::Client,
 }
 
 impl AsyncClient {
     /// build an async client from a builder
     pub fn from_builder(builder: Builder) -> Result<Self, Error> {
-        let mut client_builder = Client::builder();
+        let mut client_builder = reqwest::Client::builder();
 
         #[cfg(not(target_arch = "wasm32"))]
         if let Some(proxy) = &builder.proxy {
-            client_builder = client_builder.proxy(reqwest::Proxy::all(proxy)?);
+            client_builder = client_builder
+                .proxy(reqwest::Proxy::all(proxy).map_err(crate::api::Error::Client)?);
         }
 
         #[cfg(not(target_arch = "wasm32"))]
@@ -61,33 +88,29 @@ impl AsyncClient {
             client_builder = client_builder.default_headers(headers);
         }
 
-        Ok(Self::from_client(builder.base_url, client_builder.build()?))
+        Ok(Self::from_client(
+            builder.base_url,
+            client_builder.build().map_err(crate::api::Error::Client)?,
+        ))
     }
 
-    /// build an async client from the base url and [`Client`]
-    pub fn from_client(url: String, client: Client) -> Self {
+    /// build an async client from the base url and [`reqwest::Client`]
+    pub fn from_client(url: String, client: reqwest::Client) -> Self {
         AsyncClient { url, client }
     }
 
     /// Get a [`Transaction`] option given its [`Txid`]
     pub async fn get_tx(&self, txid: &Txid) -> Result<Option<Transaction>, Error> {
-        let resp = self
-            .client
-            .get(&format!("{}/tx/{}/raw", self.url, txid))
-            .send()
-            .await?;
-
-        if let StatusCode::NOT_FOUND = resp.status() {
-            return Ok(None);
-        }
-
-        if resp.status().is_server_error() || resp.status().is_client_error() {
-            Err(Error::HttpResponse {
-                status: resp.status().as_u16(),
-                message: resp.text().await?,
+        let tx_api = TransactionApi::Tx(*txid);
+        let response = tx_api
+            .send_async(&self.url, &mut move |request| {
+                handler(&self.client, request)
             })
-        } else {
-            Ok(Some(deserialize(&resp.bytes().await?)?))
+            .await?;
+        match tx_api.deserialize_decodable::<Transaction>(&response) {
+            Ok(transaction) => Ok(Some(transaction)),
+            Err(Error::HttpResponse { status: 404, .. }) => Ok(None),
+            Err(e) => Err(e),
         }
     }
 
@@ -100,173 +123,121 @@ impl AsyncClient {
         }
     }
 
-    /// Get a [`Txid`] of a transaction given its index in a block with a given
-    /// hash.
-    pub async fn get_txid_at_block_index(
-        &self,
-        block_hash: &BlockHash,
-        index: usize,
-    ) -> Result<Option<Txid>, Error> {
-        let resp = self
-            .client
-            .get(&format!("{}/block/{}/txid/{}", self.url, block_hash, index))
-            .send()
-            .await?;
-
-        if let StatusCode::NOT_FOUND = resp.status() {
-            return Ok(None);
-        }
-
-        if resp.status().is_server_error() || resp.status().is_client_error() {
-            Err(Error::HttpResponse {
-                status: resp.status().as_u16(),
-                message: resp.text().await?,
-            })
-        } else {
-            Ok(Some(Txid::from_str(&resp.text().await?)?))
-        }
-    }
-
     /// Get the status of a [`Transaction`] given its [`Txid`].
     pub async fn get_tx_status(&self, txid: &Txid) -> Result<TxStatus, Error> {
-        let resp = self
-            .client
-            .get(&format!("{}/tx/{}/status", self.url, txid))
-            .send()
-            .await?;
-        if resp.status().is_server_error() || resp.status().is_client_error() {
-            Err(Error::HttpResponse {
-                status: resp.status().as_u16(),
-                message: resp.text().await?,
+        let tx_api = TransactionApi::TxStatus(*txid);
+        let response = tx_api
+            .send_async(&self.url, &mut move |request: crate::Request| {
+                handler(&self.client, request)
             })
-        } else {
-            Ok(resp.json().await?)
+            .await?;
+        match tx_api.deserialize_json::<TxStatus>(&response) {
+            Ok(tx_status) => Ok(tx_status),
+            Err(e) => Err(e),
         }
     }
 
     /// Get transaction info given it's [`Txid`].
     pub async fn get_tx_info(&self, txid: &Txid) -> Result<Option<Tx>, Error> {
-        let resp = self
-            .client
-            .get(&format!("{}/tx/{}", self.url, txid))
-            .send()
+        let tx_api = TransactionApi::TxInfo(*txid);
+        let response = tx_api
+            .send_async(&self.url, &mut move |request: crate::Request| {
+                handler(&self.client, request)
+            })
             .await?;
-        if resp.status() == StatusCode::NOT_FOUND {
-            return Ok(None);
+        match tx_api.deserialize_json::<Tx>(&response) {
+            Ok(tx) => Ok(Some(tx)),
+            Err(Error::HttpResponse { status: 404, .. }) => Ok(None),
+            Err(e) => Err(e),
         }
-        if resp.status().is_server_error() || resp.status().is_client_error() {
-            Err(Error::HttpResponse {
-                status: resp.status().as_u16(),
-                message: resp.text().await?,
+    }
+
+    /// Get a [`Txid`] of a transaction given its index in a block with a given
+    /// hash.
+    pub async fn get_txid_at_block_index(
+        &self,
+        block_hash: &BlockHash,
+        index: usize,
+    ) -> Result<Option<Txid>, Error> {
+        let api = BlocksApi::BlockTxIdAtIndex(*block_hash, index);
+        let response = api
+            .send_async(&self.url, &mut move |request: crate::Request| {
+                handler(&self.client, request)
             })
-        } else {
-            Ok(Some(resp.json().await?))
+            .await?;
+        match api.deserialize_str::<Txid>(&response) {
+            Ok(txid) => Ok(Some(txid)),
+            Err(Error::HttpResponse { status: 404, .. }) => Ok(None),
+            Err(e) => Err(e),
         }
     }
 
     /// Get a [`BlockHeader`] given a particular block hash.
     pub async fn get_header_by_hash(&self, block_hash: &BlockHash) -> Result<BlockHeader, Error> {
-        let resp = self
-            .client
-            .get(&format!("{}/block/{}/header", self.url, block_hash))
-            .send()
-            .await?;
-
-        if resp.status().is_server_error() || resp.status().is_client_error() {
-            Err(Error::HttpResponse {
-                status: resp.status().as_u16(),
-                message: resp.text().await?,
+        let api = BlocksApi::BlockHeader(*block_hash);
+        let response = api
+            .send_async(&self.url, &mut move |request: crate::Request| {
+                handler(&self.client, request)
             })
-        } else {
-            let header = deserialize(&Vec::from_hex(&resp.text().await?)?)?;
-            Ok(header)
-        }
+            .await?;
+        api.deserialize_decodable::<BlockHeader>(&response)
     }
 
     /// Get the [`BlockStatus`] given a particular [`BlockHash`].
     pub async fn get_block_status(&self, block_hash: &BlockHash) -> Result<BlockStatus, Error> {
-        let resp = self
-            .client
-            .get(&format!("{}/block/{}/status", self.url, block_hash))
-            .send()
-            .await?;
-
-        if resp.status().is_server_error() || resp.status().is_client_error() {
-            Err(Error::HttpResponse {
-                status: resp.status().as_u16(),
-                message: resp.text().await?,
+        let api = BlocksApi::BlockStatus(*block_hash);
+        let response = api
+            .send_async(&self.url, &mut move |request: crate::Request| {
+                handler(&self.client, request)
             })
-        } else {
-            Ok(resp.json().await?)
-        }
+            .await?;
+        api.deserialize_json::<BlockStatus>(&response)
     }
 
     /// Get a [`Block`] given a particular [`BlockHash`].
     pub async fn get_block_by_hash(&self, block_hash: &BlockHash) -> Result<Option<Block>, Error> {
-        let resp = self
-            .client
-            .get(&format!("{}/block/{}/raw", self.url, block_hash))
-            .send()
-            .await?;
-
-        if let StatusCode::NOT_FOUND = resp.status() {
-            return Ok(None);
-        }
-
-        if resp.status().is_server_error() || resp.status().is_client_error() {
-            Err(Error::HttpResponse {
-                status: resp.status().as_u16(),
-                message: resp.text().await?,
+        let api = BlocksApi::BlockRaw(*block_hash);
+        let response = api
+            .send_async(&self.url, &mut move |request: crate::Request| {
+                handler(&self.client, request)
             })
-        } else {
-            Ok(Some(deserialize(&resp.bytes().await?)?))
+            .await?;
+        match api.deserialize_decodable::<Block>(&response) {
+            Ok(block) => Ok(Some(block)),
+            Err(Error::HttpResponse { status: 404, .. }) => Ok(None),
+            Err(e) => Err(e),
         }
     }
 
     /// Get a merkle inclusion proof for a [`Transaction`] with the given
     /// [`Txid`].
-    pub async fn get_merkle_proof(&self, tx_hash: &Txid) -> Result<Option<MerkleProof>, Error> {
-        let resp = self
-            .client
-            .get(&format!("{}/tx/{}/merkle-proof", self.url, tx_hash))
-            .send()
-            .await?;
-
-        if let StatusCode::NOT_FOUND = resp.status() {
-            return Ok(None);
-        }
-
-        if resp.status().is_server_error() || resp.status().is_client_error() {
-            Err(Error::HttpResponse {
-                status: resp.status().as_u16(),
-                message: resp.text().await?,
+    pub async fn get_merkle_proof(&self, txid: &Txid) -> Result<Option<MerkleProof>, Error> {
+        let tx_api = TransactionApi::TxMerkleProof(*txid);
+        let response = tx_api
+            .send_async(&self.url, &mut move |request: crate::Request| {
+                handler(&self.client, request)
             })
-        } else {
-            Ok(Some(resp.json().await?))
+            .await?;
+        match tx_api.deserialize_json::<MerkleProof>(&response) {
+            Ok(merkle_proof) => Ok(Some(merkle_proof)),
+            Err(Error::HttpResponse { status: 404, .. }) => Ok(None),
+            Err(e) => Err(e),
         }
     }
 
     /// Get a [`MerkleBlock`] inclusion proof for a [`Transaction`] with the
     /// given [`Txid`].
-    pub async fn get_merkle_block(&self, tx_hash: &Txid) -> Result<Option<MerkleBlock>, Error> {
-        let resp = self
-            .client
-            .get(&format!("{}/tx/{}/merkleblock-proof", self.url, tx_hash))
-            .send()
-            .await?;
-
-        if let StatusCode::NOT_FOUND = resp.status() {
-            return Ok(None);
-        }
-
-        if resp.status().is_server_error() || resp.status().is_client_error() {
-            Err(Error::HttpResponse {
-                status: resp.status().as_u16(),
-                message: resp.text().await?,
+    pub async fn get_merkle_block(&self, txid: &Txid) -> Result<Option<MerkleBlock>, Error> {
+        let tx_api = TransactionApi::TxMerkeBlockProof(*txid);
+        let response = tx_api
+            .send_async(&self.url, &mut move |request: crate::Request| {
+                handler(&self.client, request)
             })
-        } else {
-            let merkle_block = deserialize(&Vec::from_hex(&resp.text().await?)?)?;
-            Ok(Some(merkle_block))
+            .await?;
+        match tx_api.deserialize_decodable::<MerkleBlock>(&response) {
+            Ok(merkle_block) => Ok(Some(merkle_block)),
+            Err(Error::HttpResponse { status: 404, .. }) => Ok(None),
+            Err(e) => Err(e),
         }
     }
 
@@ -277,101 +248,80 @@ impl AsyncClient {
         txid: &Txid,
         index: u64,
     ) -> Result<Option<OutputStatus>, Error> {
-        let resp = self
-            .client
-            .get(&format!("{}/tx/{}/outspend/{}", self.url, txid, index))
-            .send()
-            .await?;
-
-        if let StatusCode::NOT_FOUND = resp.status() {
-            return Ok(None);
-        }
-
-        if resp.status().is_server_error() || resp.status().is_client_error() {
-            Err(Error::HttpResponse {
-                status: resp.status().as_u16(),
-                message: resp.text().await?,
+        let tx_api = TransactionApi::TxOutputStatus(*txid, index);
+        let response = tx_api
+            .send_async(&self.url, &mut move |request: crate::Request| {
+                handler(&self.client, request)
             })
-        } else {
-            Ok(Some(resp.json().await?))
+            .await?;
+        match tx_api.deserialize_json::<OutputStatus>(&response) {
+            Ok(output_status) => Ok(Some(output_status)),
+            Err(Error::HttpResponse { status: 404, .. }) => Ok(None),
+            Err(e) => Err(e),
         }
     }
 
     /// Broadcast a [`Transaction`] to Esplora
     pub async fn broadcast(&self, transaction: &Transaction) -> Result<(), Error> {
-        let resp = self
-            .client
-            .post(&format!("{}/tx", self.url))
-            .body(serialize(transaction).to_lower_hex_string())
-            .send()
+        let tx_api = TransactionApi::Broadcast(transaction.clone());
+        let response = tx_api
+            .send_async(&self.url, &mut move |request: crate::Request| {
+                handler(&self.client, request)
+            })
             .await?;
 
-        if resp.status().is_server_error() || resp.status().is_client_error() {
-            Err(Error::HttpResponse {
-                status: resp.status().as_u16(),
-                message: resp.text().await?,
-            })
-        } else {
-            Ok(())
+        if !response.is_status_ok() {
+            let status = u16::try_from(response.status_code).map_err(Error::StatusCode)?;
+            let message = response.as_str().unwrap_or_default().to_string();
+            return Err(Error::HttpResponse { status, message });
         }
+
+        Ok(())
     }
 
-    /// Get the current height of the blockchain tip
+    /// Get the height of the current blockchain tip.
     pub async fn get_height(&self) -> Result<u32, Error> {
-        let resp = self
-            .client
-            .get(&format!("{}/blocks/tip/height", self.url))
-            .send()
-            .await?;
-
-        if resp.status().is_server_error() || resp.status().is_client_error() {
-            Err(Error::HttpResponse {
-                status: resp.status().as_u16(),
-                message: resp.text().await?,
+        let api = BlocksApi::BlockTipHeight;
+        let response = api
+            .send_async(&self.url, &mut move |request: crate::Request| {
+                handler(&self.client, request)
             })
-        } else {
-            Ok(resp.text().await?.parse()?)
-        }
+            .await?;
+        api.deserialize_str::<u32>(&response)
     }
 
     /// Get the [`BlockHash`] of the current blockchain tip.
     pub async fn get_tip_hash(&self) -> Result<BlockHash, Error> {
-        let resp = self
-            .client
-            .get(&format!("{}/blocks/tip/hash", self.url))
-            .send()
-            .await?;
-
-        if resp.status().is_server_error() || resp.status().is_client_error() {
-            Err(Error::HttpResponse {
-                status: resp.status().as_u16(),
-                message: resp.text().await?,
+        let api = BlocksApi::BlockTipHash;
+        let response = api
+            .send_async(&self.url, &mut move |request: crate::Request| {
+                handler(&self.client, request)
             })
-        } else {
-            Ok(BlockHash::from_str(&resp.text().await?)?)
-        }
+            .await?;
+        api.deserialize_str::<BlockHash>(&response)
     }
 
     /// Get the [`BlockHash`] of a specific block height
     pub async fn get_block_hash(&self, block_height: u32) -> Result<BlockHash, Error> {
-        let resp = self
-            .client
-            .get(&format!("{}/block-height/{}", self.url, block_height))
-            .send()
+        let api = BlocksApi::BlockHash(block_height);
+        let response = api
+            .send_async(&self.url, &mut move |request: crate::Request| {
+                handler(&self.client, request)
+            })
             .await?;
+        api.deserialize_str::<BlockHash>(&response)
+    }
 
-        if let StatusCode::NOT_FOUND = resp.status() {
-            return Err(Error::HeaderHeightNotFound(block_height));
-        }
-
-        if resp.status().is_server_error() || resp.status().is_client_error() {
-            Err(Error::HttpResponse {
-                status: resp.status().as_u16(),
-                message: resp.text().await?,
+    /// Get an map where the key is the confirmation target (in number of
+    /// blocks) and the value is the estimated feerate (in sat/vB).
+    pub async fn get_fee_estimates(&self) -> Result<HashMap<u16, f64>, Error> {
+        let api = FeeEstimatesApi::FeeRate;
+        let response = api
+            .send_async(&self.url, &mut move |request: crate::Request| {
+                handler(&self.client, request)
             })
-        } else {
-            Ok(BlockHash::from_str(&resp.text().await?)?)
-        }
+            .await?;
+        api.deserialize_json::<HashMap<u16, f64>>(&response)
     }
 
     /// Get confirmed transaction history for the specified address/scripthash,
@@ -384,42 +334,18 @@ impl AsyncClient {
         last_seen: Option<Txid>,
     ) -> Result<Vec<Tx>, Error> {
         let script_hash = sha256::Hash::hash(script.as_bytes());
-        let url = match last_seen {
-            Some(last_seen) => format!(
-                "{}/scripthash/{:x}/txs/chain/{}",
-                self.url, script_hash, last_seen
-            ),
-            None => format!("{}/scripthash/{:x}/txs", self.url, script_hash),
+        let address_api = match last_seen {
+            Some(last_seen) => AddressApi::ScriptHashConfirmedTxHistory(script_hash, last_seen),
+            None => AddressApi::ScriptHashTxHistory(script_hash),
         };
-
-        let resp = self.client.get(url).send().await?;
-
-        if resp.status().is_server_error() || resp.status().is_client_error() {
-            Err(Error::HttpResponse {
-                status: resp.status().as_u16(),
-                message: resp.text().await?,
+        let response = address_api
+            .send_async(&self.url, &mut move |request: crate::Request| {
+                handler(&self.client, request)
             })
-        } else {
-            Ok(resp.json::<Vec<Tx>>().await?)
-        }
-    }
-
-    /// Get an map where the key is the confirmation target (in number of
-    /// blocks) and the value is the estimated feerate (in sat/vB).
-    pub async fn get_fee_estimates(&self) -> Result<HashMap<u16, f64>, Error> {
-        let resp = self
-            .client
-            .get(&format!("{}/fee-estimates", self.url,))
-            .send()
             .await?;
-
-        if resp.status().is_server_error() || resp.status().is_client_error() {
-            Err(Error::HttpResponse {
-                status: resp.status().as_u16(),
-                message: resp.text().await?,
-            })
-        } else {
-            Ok(resp.json::<HashMap<u16, f64>>().await?)
+        match address_api.deserialize_json::<Vec<Tx>>(&response) {
+            Ok(txs) => Ok(txs),
+            Err(e) => Err(e),
         }
     }
 
@@ -429,21 +355,13 @@ impl AsyncClient {
     /// The maximum number of summaries returned depends on the backend itself:
     /// esplora returns `10` while [mempool.space](https://mempool.space/docs/api) returns `15`.
     pub async fn get_blocks(&self, height: Option<u32>) -> Result<Vec<BlockSummary>, Error> {
-        let url = match height {
-            Some(height) => format!("{}/blocks/{}", self.url, height),
-            None => format!("{}/blocks", self.url),
-        };
-
-        let resp = self.client.get(&url).send().await?;
-
-        if resp.status().is_server_error() || resp.status().is_client_error() {
-            Err(Error::HttpResponse {
-                status: resp.status().as_u16(),
-                message: resp.text().await?,
+        let api = BlocksApi::BlockSummaries(height);
+        let response = api
+            .send_async(&self.url, &mut move |request: crate::Request| {
+                handler(&self.client, request)
             })
-        } else {
-            Ok(resp.json::<Vec<BlockSummary>>().await?)
-        }
+            .await?;
+        api.deserialize_json::<Vec<BlockSummary>>(&response)
     }
 
     /// Get the underlying base URL.
@@ -451,8 +369,8 @@ impl AsyncClient {
         &self.url
     }
 
-    /// Get the underlying [`Client`].
-    pub fn client(&self) -> &Client {
+    /// Get the underlying [`reqwest::Client`].
+    pub fn client(&self) -> &reqwest::Client {
         &self.client
     }
 }
diff --git a/src/blocking.rs b/src/blocking.rs
index 22c95fd..d0dc9fc 100644
--- a/src/blocking.rs
+++ b/src/blocking.rs
@@ -13,21 +13,63 @@
 
 use std::collections::HashMap;
 use std::convert::TryFrom;
-use std::str::FromStr;
 
 #[allow(unused_imports)]
 use log::{debug, error, info, trace};
 
-use minreq::{Proxy, Request};
+use minreq::Proxy;
 
-use bitcoin::consensus::{deserialize, serialize, Decodable};
 use bitcoin::hashes::{sha256, Hash};
-use bitcoin::hex::{DisplayHex, FromHex};
 use bitcoin::{
     block::Header as BlockHeader, Block, BlockHash, MerkleBlock, Script, Transaction, Txid,
 };
 
-use crate::{BlockStatus, BlockSummary, Builder, Error, MerkleProof, OutputStatus, Tx, TxStatus};
+use crate::{
+    AddressApi, BlockStatus, BlockSummary, BlocksApi, Builder, Client, Error, FeeEstimatesApi,
+    MerkleProof, OutputStatus, TransactionApi, Tx, TxStatus,
+};
+
+pub(crate) fn handler(
+    client: &BlockingClient,
+) -> impl FnMut(crate::Request) -> Result<crate::Response, minreq::Error> + '_ {
+    move |request| {
+        let mut minreq_request = match request.method {
+            crate::Method::Get => minreq::Request::new(minreq::Method::Get, request.url),
+            crate::Method::Post => minreq::Request::new(minreq::Method::Post, request.url)
+                .with_body(request.body.expect("It should've a non-empty body!")),
+        };
+
+        // FIXME: (@leonardo) I don't think that we should have the proxy, timeout and headers
+        // coming from client. How should we do it ?
+
+        if let Some(proxy) = &client.proxy {
+            let proxy = Proxy::new(proxy.as_str())?;
+            minreq_request = minreq_request.with_proxy(proxy);
+        }
+
+        if let Some(timeout) = client.timeout {
+            minreq_request = minreq_request.with_timeout(timeout);
+        }
+
+        if !client.headers.is_empty() {
+            for (key, value) in &client.headers {
+                minreq_request = minreq_request.with_header(key, value);
+            }
+        }
+
+        let minreq_response = minreq_request.send()?;
+
+        let response = crate::Response::new(
+            minreq_response.status_code,
+            minreq_response.as_bytes().to_vec(),
+            // minreq_response.reason_phrase,
+            // minreq_response.headers,
+            // minreq_response.url,
+        );
+
+        Ok(response)
+    }
+}
 
 #[derive(Debug, Clone)]
 pub struct BlockingClient {
@@ -56,138 +98,15 @@ impl BlockingClient {
         &self.url
     }
 
-    /// Perform a raw HTTP GET request with the given URI `path`.
-    pub fn get_request(&self, path: &str) -> Result<Request, Error> {
-        let mut request = minreq::get(format!("{}{}", self.url, path));
-
-        if let Some(proxy) = &self.proxy {
-            let proxy = Proxy::new(proxy.as_str())?;
-            request = request.with_proxy(proxy);
-        }
-
-        if let Some(timeout) = &self.timeout {
-            request = request.with_timeout(*timeout);
-        }
-
-        if !self.headers.is_empty() {
-            for (key, value) in &self.headers {
-                request = request.with_header(key, value);
-            }
-        }
-
-        Ok(request)
-    }
-
-    fn get_opt_response<T: Decodable>(&self, path: &str) -> Result<Option<T>, Error> {
-        match self.get_request(path)?.send() {
-            Ok(resp) if is_status_not_found(resp.status_code) => Ok(None),
-            Ok(resp) if !is_status_ok(resp.status_code) => {
-                let status = u16::try_from(resp.status_code).map_err(Error::StatusCode)?;
-                let message = resp.as_str().unwrap_or_default().to_string();
-                Err(Error::HttpResponse { status, message })
-            }
-            Ok(resp) => Ok(Some(deserialize::<T>(resp.as_bytes())?)),
-            Err(e) => Err(Error::Minreq(e)),
-        }
-    }
-
-    fn get_opt_response_txid(&self, path: &str) -> Result<Option<Txid>, Error> {
-        match self.get_request(path)?.send() {
-            Ok(resp) if is_status_not_found(resp.status_code) => Ok(None),
-            Ok(resp) if !is_status_ok(resp.status_code) => {
-                let status = u16::try_from(resp.status_code).map_err(Error::StatusCode)?;
-                let message = resp.as_str().unwrap_or_default().to_string();
-                Err(Error::HttpResponse { status, message })
-            }
-            Ok(resp) => Ok(Some(
-                Txid::from_str(resp.as_str().map_err(Error::Minreq)?).map_err(Error::HexToArray)?,
-            )),
-            Err(e) => Err(Error::Minreq(e)),
-        }
-    }
-
-    fn get_opt_response_hex<T: Decodable>(&self, path: &str) -> Result<Option<T>, Error> {
-        match self.get_request(path)?.send() {
-            Ok(resp) if is_status_not_found(resp.status_code) => Ok(None),
-            Ok(resp) if !is_status_ok(resp.status_code) => {
-                let status = u16::try_from(resp.status_code).map_err(Error::StatusCode)?;
-                let message = resp.as_str().unwrap_or_default().to_string();
-                Err(Error::HttpResponse { status, message })
-            }
-            Ok(resp) => {
-                let hex_str = resp.as_str().map_err(Error::Minreq)?;
-                let hex_vec = Vec::from_hex(hex_str).unwrap();
-                deserialize::<T>(&hex_vec)
-                    .map_err(Error::BitcoinEncoding)
-                    .map(|r| Some(r))
-            }
-            Err(e) => Err(Error::Minreq(e)),
-        }
-    }
-
-    fn get_response_hex<T: Decodable>(&self, path: &str) -> Result<T, Error> {
-        match self.get_request(path)?.send() {
-            Ok(resp) if !is_status_ok(resp.status_code) => {
-                let status = u16::try_from(resp.status_code).map_err(Error::StatusCode)?;
-                let message = resp.as_str().unwrap_or_default().to_string();
-                Err(Error::HttpResponse { status, message })
-            }
-            Ok(resp) => {
-                let hex_str = resp.as_str().map_err(Error::Minreq)?;
-                let hex_vec = Vec::from_hex(hex_str).unwrap();
-                deserialize::<T>(&hex_vec).map_err(Error::BitcoinEncoding)
-            }
-            Err(e) => Err(Error::Minreq(e)),
-        }
-    }
-
-    fn get_response_json<'a, T: serde::de::DeserializeOwned>(
-        &'a self,
-        path: &'a str,
-    ) -> Result<T, Error> {
-        let response = self.get_request(path)?.send();
-        match response {
-            Ok(resp) if !is_status_ok(resp.status_code) => {
-                let status = u16::try_from(resp.status_code).map_err(Error::StatusCode)?;
-                let message = resp.as_str().unwrap_or_default().to_string();
-                Err(Error::HttpResponse { status, message })
-            }
-            Ok(resp) => Ok(resp.json::<T>().map_err(Error::Minreq)?),
-            Err(e) => Err(Error::Minreq(e)),
-        }
-    }
-
-    fn get_opt_response_json<T: serde::de::DeserializeOwned>(
-        &self,
-        path: &str,
-    ) -> Result<Option<T>, Error> {
-        match self.get_request(path)?.send() {
-            Ok(resp) if is_status_not_found(resp.status_code) => Ok(None),
-            Ok(resp) if !is_status_ok(resp.status_code) => {
-                let status = u16::try_from(resp.status_code).map_err(Error::StatusCode)?;
-                let message = resp.as_str().unwrap_or_default().to_string();
-                Err(Error::HttpResponse { status, message })
-            }
-            Ok(resp) => Ok(Some(resp.json::<T>()?)),
-            Err(e) => Err(Error::Minreq(e)),
-        }
-    }
-
-    fn get_response_str(&self, path: &str) -> Result<String, Error> {
-        match self.get_request(path)?.send() {
-            Ok(resp) if !is_status_ok(resp.status_code) => {
-                let status = u16::try_from(resp.status_code).map_err(Error::StatusCode)?;
-                let message = resp.as_str().unwrap_or_default().to_string();
-                Err(Error::HttpResponse { status, message })
-            }
-            Ok(resp) => Ok(resp.as_str()?.to_string()),
-            Err(e) => Err(Error::Minreq(e)),
-        }
-    }
-
     /// Get a [`Transaction`] option given its [`Txid`]
     pub fn get_tx(&self, txid: &Txid) -> Result<Option<Transaction>, Error> {
-        self.get_opt_response(&format!("/tx/{}/raw", txid))
+        let tx_api = TransactionApi::Tx(*txid);
+        let response = tx_api.send(&self.url, &mut handler(self))?;
+        match tx_api.deserialize_decodable::<Transaction>(&response) {
+            Ok(transaction) => Ok(Some(transaction)),
+            Err(Error::HttpResponse { status: 404, .. }) => Ok(None),
+            Err(e) => Err(e),
+        }
     }
 
     /// Get a [`Transaction`] given its [`Txid`].
@@ -199,6 +118,27 @@ impl BlockingClient {
         }
     }
 
+    /// Get the status of a [`Transaction`] given its [`Txid`].
+    pub fn get_tx_status(&self, txid: &Txid) -> Result<TxStatus, Error> {
+        let tx_api = TransactionApi::TxStatus(*txid);
+        let response = tx_api.send(&self.url, &mut handler(self))?;
+        match tx_api.deserialize_json::<TxStatus>(&response) {
+            Ok(tx_status) => Ok(tx_status),
+            Err(e) => Err(e),
+        }
+    }
+
+    /// Get transaction info given it's [`Txid`].
+    pub fn get_tx_info(&self, txid: &Txid) -> Result<Option<Tx>, Error> {
+        let tx_api = TransactionApi::TxInfo(*txid);
+        let response = tx_api.send(&self.url, &mut handler(self))?;
+        match tx_api.deserialize_json::<Tx>(&response) {
+            Ok(tx) => Ok(Some(tx)),
+            Err(Error::HttpResponse { status: 404, .. }) => Ok(None),
+            Err(e) => Err(e),
+        }
+    }
+
     /// Get a [`Txid`] of a transaction given its index in a block with a given
     /// hash.
     pub fn get_txid_at_block_index(
@@ -206,44 +146,62 @@ impl BlockingClient {
         block_hash: &BlockHash,
         index: usize,
     ) -> Result<Option<Txid>, Error> {
-        self.get_opt_response_txid(&format!("/block/{}/txid/{}", block_hash, index))
-    }
-
-    /// Get the status of a [`Transaction`] given its [`Txid`].
-    pub fn get_tx_status(&self, txid: &Txid) -> Result<TxStatus, Error> {
-        self.get_response_json(&format!("/tx/{}/status", txid))
-    }
-
-    /// Get transaction info given it's [`Txid`].
-    pub fn get_tx_info(&self, txid: &Txid) -> Result<Option<Tx>, Error> {
-        self.get_opt_response_json(&format!("/tx/{}", txid))
+        let api = BlocksApi::BlockTxIdAtIndex(*block_hash, index);
+        let response = api.send(&self.url, &mut handler(self))?;
+        match api.deserialize_str::<Txid>(&response) {
+            Ok(txid) => Ok(Some(txid)),
+            Err(Error::HttpResponse { status: 404, .. }) => Ok(None),
+            Err(e) => Err(e),
+        }
     }
 
     /// Get a [`BlockHeader`] given a particular block hash.
     pub fn get_header_by_hash(&self, block_hash: &BlockHash) -> Result<BlockHeader, Error> {
-        self.get_response_hex(&format!("/block/{}/header", block_hash))
+        let api = BlocksApi::BlockHeader(*block_hash);
+        let response = api.send(&self.url, &mut handler(self))?;
+        api.deserialize_decodable::<BlockHeader>(&response)
     }
 
     /// Get the [`BlockStatus`] given a particular [`BlockHash`].
     pub fn get_block_status(&self, block_hash: &BlockHash) -> Result<BlockStatus, Error> {
-        self.get_response_json(&format!("/block/{}/status", block_hash))
+        let api = BlocksApi::BlockStatus(*block_hash);
+        let response = api.send(&self.url, &mut handler(self))?;
+        api.deserialize_json::<BlockStatus>(&response)
     }
 
     /// Get a [`Block`] given a particular [`BlockHash`].
     pub fn get_block_by_hash(&self, block_hash: &BlockHash) -> Result<Option<Block>, Error> {
-        self.get_opt_response(&format!("/block/{}/raw", block_hash))
+        let api = BlocksApi::BlockRaw(*block_hash);
+        let response = api.send(&self.url, &mut handler(self))?;
+        match api.deserialize_decodable::<Block>(&response) {
+            Ok(block) => Ok(Some(block)),
+            Err(Error::HttpResponse { status: 404, .. }) => Ok(None),
+            Err(e) => Err(e),
+        }
     }
 
     /// Get a merkle inclusion proof for a [`Transaction`] with the given
     /// [`Txid`].
     pub fn get_merkle_proof(&self, txid: &Txid) -> Result<Option<MerkleProof>, Error> {
-        self.get_opt_response_json(&format!("/tx/{}/merkle-proof", txid))
+        let tx_api = TransactionApi::TxMerkleProof(*txid);
+        let response = tx_api.send(&self.url, &mut handler(self))?;
+        match tx_api.deserialize_json::<MerkleProof>(&response) {
+            Ok(merkle_proof) => Ok(Some(merkle_proof)),
+            Err(Error::HttpResponse { status: 404, .. }) => Ok(None),
+            Err(e) => Err(e),
+        }
     }
 
     /// Get a [`MerkleBlock`] inclusion proof for a [`Transaction`] with the
     /// given [`Txid`].
     pub fn get_merkle_block(&self, txid: &Txid) -> Result<Option<MerkleBlock>, Error> {
-        self.get_opt_response_hex(&format!("/tx/{}/merkleblock-proof", txid))
+        let tx_api = TransactionApi::TxMerkeBlockProof(*txid);
+        let response = tx_api.send(&self.url, &mut handler(self))?;
+        match tx_api.deserialize_decodable::<MerkleBlock>(&response) {
+            Ok(merkle_block) => Ok(Some(merkle_block)),
+            Err(Error::HttpResponse { status: 404, .. }) => Ok(None),
+            Err(e) => Err(e),
+        }
     }
 
     /// Get the spending status of an output given a [`Txid`] and the output
@@ -253,60 +211,56 @@ impl BlockingClient {
         txid: &Txid,
         index: u64,
     ) -> Result<Option<OutputStatus>, Error> {
-        self.get_opt_response_json(&format!("/tx/{}/outspend/{}", txid, index))
+        let tx_api = TransactionApi::TxOutputStatus(*txid, index);
+        let response = tx_api.send(&self.url, &mut handler(self))?;
+        match tx_api.deserialize_json::<OutputStatus>(&response) {
+            Ok(output_status) => Ok(Some(output_status)),
+            Err(Error::HttpResponse { status: 404, .. }) => Ok(None),
+            Err(e) => Err(e),
+        }
     }
 
     /// Broadcast a [`Transaction`] to Esplora
     pub fn broadcast(&self, transaction: &Transaction) -> Result<(), Error> {
-        let mut request = minreq::post(format!("{}/tx", self.url)).with_body(
-            serialize(transaction)
-                .to_lower_hex_string()
-                .as_bytes()
-                .to_vec(),
-        );
-
-        if let Some(proxy) = &self.proxy {
-            let proxy = Proxy::new(proxy.as_str())?;
-            request = request.with_proxy(proxy);
-        }
+        let tx_api = TransactionApi::Broadcast(transaction.clone());
+        let response = tx_api.send(&self.url, &mut handler(self))?;
 
-        if let Some(timeout) = &self.timeout {
-            request = request.with_timeout(*timeout);
+        if !response.is_status_ok() {
+            let status = u16::try_from(response.status_code).map_err(Error::StatusCode)?;
+            let message = response.as_str().unwrap_or_default().to_string();
+            return Err(Error::HttpResponse { status, message });
         }
 
-        match request.send() {
-            Ok(resp) if !is_status_ok(resp.status_code) => {
-                let status = u16::try_from(resp.status_code).map_err(Error::StatusCode)?;
-                let message = resp.as_str().unwrap_or_default().to_string();
-                Err(Error::HttpResponse { status, message })
-            }
-            Ok(_resp) => Ok(()),
-            Err(e) => Err(Error::Minreq(e)),
-        }
+        Ok(())
     }
 
     /// Get the height of the current blockchain tip.
     pub fn get_height(&self) -> Result<u32, Error> {
-        self.get_response_str("/blocks/tip/height")
-            .map(|s| u32::from_str(s.as_str()).map_err(Error::Parsing))?
+        let api = BlocksApi::BlockTipHeight;
+        let response = api.send(&self.url, &mut handler(self))?;
+        api.deserialize_str::<u32>(&response)
     }
 
     /// Get the [`BlockHash`] of the current blockchain tip.
     pub fn get_tip_hash(&self) -> Result<BlockHash, Error> {
-        self.get_response_str("/blocks/tip/hash")
-            .map(|s| BlockHash::from_str(s.as_str()).map_err(Error::HexToArray))?
+        let api = BlocksApi::BlockTipHash;
+        let response = api.send(&self.url, &mut handler(self))?;
+        api.deserialize_str::<BlockHash>(&response)
     }
 
     /// Get the [`BlockHash`] of a specific block height
     pub fn get_block_hash(&self, block_height: u32) -> Result<BlockHash, Error> {
-        self.get_response_str(&format!("/block-height/{}", block_height))
-            .map(|s| BlockHash::from_str(s.as_str()).map_err(Error::HexToArray))?
+        let api = BlocksApi::BlockHash(block_height);
+        let response = api.send(&self.url, &mut handler(self))?;
+        api.deserialize_str::<BlockHash>(&response)
     }
 
     /// Get an map where the key is the confirmation target (in number of
     /// blocks) and the value is the estimated feerate (in sat/vB).
     pub fn get_fee_estimates(&self) -> Result<HashMap<u16, f64>, Error> {
-        self.get_response_json("/fee-estimates")
+        let api = FeeEstimatesApi::FeeRate;
+        let response = api.send(&self.url, &mut handler(self))?;
+        api.deserialize_json::<HashMap<u16, f64>>(&response)
     }
 
     /// Get confirmed transaction history for the specified address/scripthash,
@@ -319,11 +273,15 @@ impl BlockingClient {
         last_seen: Option<Txid>,
     ) -> Result<Vec<Tx>, Error> {
         let script_hash = sha256::Hash::hash(script.as_bytes());
-        let path = match last_seen {
-            Some(last_seen) => format!("/scripthash/{:x}/txs/chain/{}", script_hash, last_seen),
-            None => format!("/scripthash/{:x}/txs", script_hash),
+        let address_api = match last_seen {
+            Some(last_seen) => AddressApi::ScriptHashConfirmedTxHistory(script_hash, last_seen),
+            None => AddressApi::ScriptHashTxHistory(script_hash),
         };
-        self.get_response_json(&path)
+        let response = address_api.send(&self.url, &mut handler(self))?;
+        match address_api.deserialize_json::<Vec<Tx>>(&response) {
+            Ok(txs) => Ok(txs),
+            Err(e) => Err(e),
+        }
     }
 
     /// Gets some recent block summaries starting at the tip or at `height` if
@@ -332,18 +290,8 @@ impl BlockingClient {
     /// The maximum number of summaries returned depends on the backend itself:
     /// esplora returns `10` while [mempool.space](https://mempool.space/docs/api) returns `15`.
     pub fn get_blocks(&self, height: Option<u32>) -> Result<Vec<BlockSummary>, Error> {
-        let path = match height {
-            Some(height) => format!("/blocks/{}", height),
-            None => "/blocks".to_string(),
-        };
-        self.get_response_json(&path)
+        let api = BlocksApi::BlockSummaries(height);
+        let response = api.send(&self.url, &mut handler(self))?;
+        api.deserialize_json::<Vec<BlockSummary>>(&response)
     }
 }
-
-fn is_status_ok(status: i32) -> bool {
-    status == 200
-}
-
-fn is_status_not_found(status: i32) -> bool {
-    status == 404
-}
diff --git a/src/lib.rs b/src/lib.rs
index 7b7efc3..2dd3ec1 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -66,12 +66,11 @@
 
 #![allow(clippy::result_large_err)]
 
+use bitcoin::consensus;
 use std::collections::HashMap;
 use std::fmt;
 use std::num::TryFromIntError;
 
-use bitcoin::consensus;
-
 pub mod api;
 
 #[cfg(feature = "async")]
@@ -167,12 +166,15 @@ impl Builder {
 pub enum Error {
     /// Error during `minreq` HTTP request
     #[cfg(feature = "blocking")]
-    Minreq(::minreq::Error),
+    Minreq(api::Error<::minreq::Error>),
     /// Error during reqwest HTTP request
     #[cfg(feature = "async")]
-    Reqwest(::reqwest::Error),
+    Reqwest(api::Error<::reqwest::Error>),
     /// HTTP response error
-    HttpResponse { status: u16, message: String },
+    HttpResponse {
+        status: u16,
+        message: String,
+    },
     /// Invalid number returned
     Parsing(std::num::ParseIntError),
     /// Invalid status code, unable to convert to `u16`
@@ -193,6 +195,10 @@ pub enum Error {
     InvalidHttpHeaderName(String),
     /// Invalid HTTP Header value specified
     InvalidHttpHeaderValue(String),
+    // Invalid UTF-8 value in body.
+    InvalidUtf8InBody(core::str::Utf8Error),
+    /// Ran into a Serde error.
+    SerdeJsonError(serde_json::Error),
 }
 
 impl fmt::Display for Error {
@@ -216,9 +222,11 @@ macro_rules! impl_error {
 
 impl std::error::Error for Error {}
 #[cfg(feature = "blocking")]
-impl_error!(::minreq::Error, Minreq, Error);
+impl_error!(api::Error<minreq::Error>, Minreq, Error);
+// impl_error!(api::Error<minreq::Error>, Minreq, Error);
 #[cfg(feature = "async")]
-impl_error!(::reqwest::Error, Reqwest, Error);
+// impl_error!(::reqwest::Error, Reqwest, Error);
+impl_error!(api::Error<::reqwest::Error>, Reqwest, Error);
 impl_error!(std::num::ParseIntError, Parsing, Error);
 impl_error!(consensus::encode::Error, BitcoinEncoding, Error);
 impl_error!(bitcoin::hex::HexToArrayError, HexToArray, Error);