Struct HttpResponse 

pub struct HttpResponse { /* private fields */ }

HTTP response wrapper with body-reading helpers

Provides a reqwest-like API for reading response bodies:

• resp.error_for_status()? - Check status without reading body
• resp.bytes().await? - Read raw bytes
• resp.checked_bytes().await? - Read bytes with status check
• resp.json::<T>().await? - Parse as JSON with status check

All body reads enforce the configured max_body_size limit.

Implementations

impl HttpResponse

pub fn status(&self) -> StatusCode

Get the response status code

pub fn headers(&self) -> &HeaderMap

Get the response headers

pub fn into_inner(self) -> Response<ResponseBody>

Consume the wrapper and return the inner response with boxed body

Useful for advanced callers who need direct access to the response. Note: The body has already been through the decompression layer, so it contains decompressed bytes if the server sent compressed data.

pub fn error_for_status(self) -> Result<Self, HttpError>

Check status and return error for non-2xx responses

Does NOT read the response body. For non-2xx status, returns HttpError::HttpStatus with an empty body preview.

Errors

Returns HttpError::HttpStatus if the response status is not 2xx.

Example

let resp = client.get("https://example.com/api").send().await?;
let resp = resp.error_for_status()?;  // Fails if not 2xx
let body = resp.bytes().await?;

pub async fn bytes(self) -> Result<Bytes, HttpError>

Read response body as bytes without status check

Enforces max_body_size limit.

Errors

Returns HttpError::BodyTooLarge if body exceeds limit.

pub async fn checked_bytes(self) -> Result<Bytes, HttpError>

Read response body as bytes with status check

Returns HttpError::HttpStatus for non-2xx responses (with body preview). Enforces max_body_size limit for successful responses.

Errors

Returns HttpError::HttpStatus if status is not 2xx. Returns HttpError::BodyTooLarge if body exceeds limit.

pub async fn json<T: DeserializeOwned>(self) -> Result<T, HttpError>

Parse response body as JSON with status check

Equivalent to resp.checked_bytes().await? followed by JSON parsing.

Errors

Returns HttpError::HttpStatus if status is not 2xx. Returns HttpError::BodyTooLarge if body exceeds limit. Returns HttpError::Json if parsing fails.

pub async fn text(self) -> Result<String, HttpError>

Read response body as text (UTF-8) with status check

Equivalent to resp.checked_bytes().await? followed by UTF-8 conversion. Invalid UTF-8 sequences are replaced with the Unicode replacement character.

Errors

Returns HttpError::HttpStatus if status is not 2xx. Returns HttpError::BodyTooLarge if body exceeds limit.

Example

let body = client
    .get("https://example.com/text")
    .send()
    .await?
    .text()
    .await?;
println!("Response: {}", body);

pub fn into_body(self) -> ResponseBody

Returns the response body as a stream for incremental processing.

Warning: No Size Limit Enforcement

This method does NOT enforce max_body_size. For untrusted responses (especially compressed), prefer into_limited_body() to protect against decompression bombs and memory exhaustion.

Unlike bytes(), json(), or text(), this method does NOT:

• Check the HTTP status code (use error_for_status() first if needed)
• Enforce the max_body_size limit (caller is responsible for limiting)
• Buffer the entire body in memory

Use this only when:

• You trust the response source AND have external size limits
• You’re implementing custom streaming logic with your own limits
• Performance is critical and you can guarantee bounded responses

Example

use http_body_util::BodyExt;

let response = client.get("https://example.com/large-file").send().await?;

// Check status first (optional)
if !response.status().is_success() {
    return Err(/* handle error */);
}

// Get the body stream (WARNING: no size limit!)
let mut body = response.into_body();

// Process frames incrementally
while let Some(frame) = body.frame().await {
    let frame = frame?;
    if let Some(chunk) = frame.data_ref() {
        process_chunk(chunk);
    }
}

pub fn into_limited_body(self) -> LimitedBody

Returns the response body as a size-limited stream.

Unlike into_body(), this method wraps the body in a LimitedBody that enforces the configured max_body_size limit during streaming. This protects against decompression bombs where a small compressed payload expands to gigabytes of memory.

The limit is enforced on decompressed bytes, so a 1KB gzip payload that decompresses to 1GB will be rejected.

Errors

When the limit is exceeded, the next poll_frame() call returns HttpError::BodyTooLarge.

Example

use http_body_util::BodyExt;

let response = client.get("https://example.com/large-file").send().await?;
let mut body = response.into_limited_body();

while let Some(frame) = body.frame().await {
    let frame = frame?; // Returns BodyTooLarge if limit exceeded
    if let Some(chunk) = frame.data_ref() {
        process_chunk(chunk);
    }
}

println!("Total bytes read: {}", body.bytes_read());

pub fn max_body_size(&self) -> usize

Returns the configured max body size for this response.

This is the limit that would be applied by bytes(), checked_bytes(), json(), and text() methods.

Trait Implementations

impl Debug for HttpResponse

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.