diff --git a/Directory.Build.props b/Directory.Build.props
index 1c30f9e..c25f525 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -1,7 +1,7 @@
 <Project>
 
     <PropertyGroup>
-        <Version>0.7.0</Version>
+        <Version>0.8.0</Version>
         <Company>Code Happy, LLC</Company>
         <Authors>Code Happy, LLC</Authors>
         <Product>HTML/CSS To Image API</Product>
diff --git a/README.md b/README.md
index c5cbbb2..8a6ba76 100644
--- a/README.md
+++ b/README.md
@@ -31,7 +31,7 @@ var html_request = new CreateHtmlCssImageRequest()
     ViewportHeight = 200
 };
 
-var html_image = await client.CreateImageAsync(html_request);
+using var html_image = await client.CreateImageAsync(html_request);
 
 if(html_image.Success)
 {
@@ -58,4 +58,4 @@ Check out the package READMEs for more details on integrating:
 > Check out the [HTML/CSS To Image Docs](https://docs.htmlcsstoimage.com) for more details on the API's capabilities. 
 
 > [!TIP]
-> Get started for free at [htmlcsstoimage.com](https://htmlcsstoimage.com).
\ No newline at end of file
+> Get started for free at [htmlcsstoimage.com](https://htmlcsstoimage.com).
diff --git a/src/HtmlCssToImage/Client/HtmlCssToImageClient.Images.cs b/src/HtmlCssToImage/Client/HtmlCssToImageClient.Images.cs
index dff4513..5d356cc 100644
--- a/src/HtmlCssToImage/Client/HtmlCssToImageClient.Images.cs
+++ b/src/HtmlCssToImage/Client/HtmlCssToImageClient.Images.cs
@@ -8,6 +8,57 @@ namespace HtmlCssToImage;
 
 public partial class HtmlCssToImageClient
 {
+    /// <inheritdoc />
+    public async Task<ApiResult<bool?>> DeleteImageAsync(string imageId, CancellationToken cancellationToken = default)
+    {
+        var response = await _client.DeleteAsync(
+            $"{CREATE_OR_GET_PATH}/{Uri.EscapeDataString(imageId)}",
+            cancellationToken).ConfigureAwait(false);
+
+        return await CreateDeleteImageResultAsync(response, cancellationToken).ConfigureAwait(false);
+    }
+
+    /// <inheritdoc />
+    public async Task<ApiResult<bool?>> DeleteImageBatchAsync(IEnumerable<string> imageIds,
+        CancellationToken cancellationToken = default)
+    {
+        var request = new DeleteImageBatchRequest
+        {
+            Ids = imageIds.ToArray()
+        };
+        var request_message = new HttpRequestMessage(HttpMethod.Delete, BATCH_URL)
+        {
+            Content = JsonContent.Create(request, JsonContext.Default.DeleteImageBatchRequest)
+        };
+        var response = await _client.SendAsync(request_message, cancellationToken).ConfigureAwait(false);
+
+        return await CreateDeleteImageResultAsync(response, cancellationToken).ConfigureAwait(false);
+    }
+
+    private static async Task<ApiResult<bool?>> CreateDeleteImageResultAsync(HttpResponseMessage response,
+        CancellationToken cancellationToken)
+    {
+        var result = new ApiResult<bool?>
+        {
+            HttpResponseMessage = response,
+            StatusCode = (int)response.StatusCode,
+            Success = response.IsSuccessStatusCode
+        };
+
+        if (response.IsSuccessStatusCode)
+        {
+            result.Response = true;
+        }
+        else
+        {
+            result.ErrorDetails = await response.Content.ReadFromJsonAsync<ErrorDetails>(
+                JsonContext.Default.ErrorDetails,
+                cancellationToken).ConfigureAwait(false);
+        }
+
+        return result;
+    }
+
     /// <inheritdoc />
     public async Task<ApiResult<CreateImageResponse[]?>> CreateImageBatchAsync<T>(T? defaultOptions, IEnumerable<T> variations,
         CancellationToken cancellationToken = default) where T : IBatchAllowedImageRequest
@@ -27,11 +78,11 @@ public partial class HtmlCssToImageClient
         HttpResponseMessage response;
         if (request is CreateImageBatchRequest<CreateUrlImageRequest> url_request)
         {
-            response = await _client.PostAsJsonAsync(CREATE_BATCH_URL, url_request, JsonContext.Default.CreateImageBatchRequestCreateUrlImageRequest, cancellationToken).ConfigureAwait(false);
+            response = await _client.PostAsJsonAsync(BATCH_URL, url_request, JsonContext.Default.CreateImageBatchRequestCreateUrlImageRequest, cancellationToken).ConfigureAwait(false);
         }
         else if (request is CreateImageBatchRequest<CreateHtmlCssImageRequest> html_request)
         {
-            response = await _client.PostAsJsonAsync(CREATE_BATCH_URL, html_request, JsonContext.Default.CreateImageBatchRequestCreateHtmlCssImageRequest, cancellationToken).ConfigureAwait(false);
+            response = await _client.PostAsJsonAsync(BATCH_URL, html_request, JsonContext.Default.CreateImageBatchRequestCreateHtmlCssImageRequest, cancellationToken).ConfigureAwait(false);
         }
         else
         {
@@ -100,4 +151,4 @@ await response.Content.ReadFromJsonAsync<CreateImageBatchResponse>(
 
         return result;
     }
-}
\ No newline at end of file
+}
diff --git a/src/HtmlCssToImage/Client/HtmlCssToImageClient.cs b/src/HtmlCssToImage/Client/HtmlCssToImageClient.cs
index a930bad..70c25ae 100644
--- a/src/HtmlCssToImage/Client/HtmlCssToImageClient.cs
+++ b/src/HtmlCssToImage/Client/HtmlCssToImageClient.cs
@@ -39,7 +39,7 @@ internal HtmlCssToImageClient(HttpClient client, HtmlCssToImageOptions options,
     internal const string CREATE_OR_GET_PATH = "/v1/image";
     private const string CREATE_AND_RENDER_PATH = $"{CREATE_OR_GET_PATH}/create-and-render";
     private const string CREATE_URL = $"{CREATE_OR_GET_PATH}?includeId=true";
-    private const string CREATE_BATCH_URL = $"{CREATE_OR_GET_PATH}/batch";
+    private const string BATCH_URL = $"{CREATE_OR_GET_PATH}/batch";
 
     private const string TEMPLATE_VERSION_QUERY_PARAM = "template_version";
 }
diff --git a/src/HtmlCssToImage/IHtmlCssToImageClient.cs b/src/HtmlCssToImage/IHtmlCssToImageClient.cs
index 03f159b..a474598 100644
--- a/src/HtmlCssToImage/IHtmlCssToImageClient.cs
+++ b/src/HtmlCssToImage/IHtmlCssToImageClient.cs
@@ -24,6 +24,22 @@ public interface IHtmlCssToImageClient
     /// <returns>An <see cref="ApiResult{T}"/> object containing the response with metadata such as the image's URL and ID, as well as the status of the operation.</returns>
     public Task<ApiResult<CreateImageResponse?>> CreateImageAsync<T>(T request, CancellationToken cancellationToken = default) where T : ICreateImageRequestBase;
 
+    /// <summary>
+    /// Deletes an existing image and clears it from the CDN.
+    /// </summary>
+    /// <param name="imageId">The ID of the image to delete.</param>
+    /// <param name="cancellationToken">A cancellation token that can be used to cancel the operation.</param>
+    /// <returns>An <c>ApiResult&lt;bool?&gt;</c> whose response is <see langword="true"/> when the delete request is accepted.</returns>
+    public Task<ApiResult<bool?>> DeleteImageAsync(string imageId, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Deletes multiple existing images in one API call and clears them from the CDN.
+    /// </summary>
+    /// <param name="imageIds">The IDs of the images to delete.</param>
+    /// <param name="cancellationToken">A cancellation token that can be used to cancel the operation.</param>
+    /// <returns>An <c>ApiResult&lt;bool?&gt;</c> whose response is <see langword="true"/> when the batch delete request is accepted.</returns>
+    public Task<ApiResult<bool?>> DeleteImageBatchAsync(IEnumerable<string> imageIds, CancellationToken cancellationToken = default);
+
     /// <summary>
     /// Sends a batch request to create multiple images using the specified parameters.
     /// </summary>
diff --git a/src/HtmlCssToImage/JsonContext.cs b/src/HtmlCssToImage/JsonContext.cs
index 4d5d97f..b895f0d 100644
--- a/src/HtmlCssToImage/JsonContext.cs
+++ b/src/HtmlCssToImage/JsonContext.cs
@@ -31,6 +31,7 @@ namespace HtmlCssToImage;
 /// - <see cref="CreateUrlImageRequest"/>
 /// - <see cref="CreateTemplatedImageRequest"/>
 /// - <see cref="CreateImageBatchRequest{T}"/> (for specific batch image types)
+/// - <see cref="DeleteImageBatchRequest"/>
 /// - <see cref="CreateImageBatchResponse"/>
 /// - <see cref="CreateImageResponse"/>
 /// - <see cref="ErrorDetails"/>
@@ -46,6 +47,7 @@ namespace HtmlCssToImage;
 [JsonSerializable(typeof(CreateTemplatedImageRequest))]
 [JsonSerializable(typeof(CreateImageBatchRequest<CreateUrlImageRequest>))]
 [JsonSerializable(typeof(CreateImageBatchRequest<CreateHtmlCssImageRequest>))]
+[JsonSerializable(typeof(DeleteImageBatchRequest))]
 [JsonSerializable(typeof(CreateImageBatchResponse))]
 [JsonSerializable(typeof(CreateImageResponse))]
 [JsonSerializable(typeof(ErrorDetails))]
@@ -53,4 +55,4 @@ namespace HtmlCssToImage;
 [JsonSerializable(typeof(CreateTemplateRequest))]
 [JsonSerializable(typeof(CreateTemplateResponse))]
 [JsonSerializable(typeof(PaginatedResponse<Template>))]
-public partial class JsonContext : JsonSerializerContext { }
\ No newline at end of file
+public partial class JsonContext : JsonSerializerContext { }
diff --git a/src/HtmlCssToImage/Models/Requests/DeleteImageBatchRequest.cs b/src/HtmlCssToImage/Models/Requests/DeleteImageBatchRequest.cs
new file mode 100644
index 0000000..83f827b
--- /dev/null
+++ b/src/HtmlCssToImage/Models/Requests/DeleteImageBatchRequest.cs
@@ -0,0 +1,12 @@
+namespace HtmlCssToImage.Models.Requests;
+
+/// <summary>
+/// Represents a request to delete multiple images in one API call.
+/// </summary>
+public sealed class DeleteImageBatchRequest
+{
+    /// <summary>
+    /// Gets or sets the IDs of the images to delete.
+    /// </summary>
+    public string[] Ids { get; set; } = [];
+}
diff --git a/src/HtmlCssToImage/Models/Results/ApiResult.cs b/src/HtmlCssToImage/Models/Results/ApiResult.cs
index ccc41e1..bc7de02 100644
--- a/src/HtmlCssToImage/Models/Results/ApiResult.cs
+++ b/src/HtmlCssToImage/Models/Results/ApiResult.cs
@@ -7,8 +7,13 @@ namespace HtmlCssToImage.Models.Results;
 /// the associated response data, and additional metadata related to the HTTP response.
 /// </summary>
 /// <typeparam name="T">The type of the response data returned by the API if the operation is successful.</typeparam>
-public class ApiResult<T>
+/// <remarks>
+/// Dispose the result after reading it to release its owned <see cref="System.Net.Http.HttpResponseMessage"/>.
+/// </remarks>
+public sealed class ApiResult<T> : IDisposable
 {
+    private bool _disposed;
+
     /// <summary>
     /// The response item, when successful
     /// </summary>
@@ -32,7 +37,24 @@ public class ApiResult<T>
     public int StatusCode { get; set; }
 
     /// <summary>
-    /// The raw HTTP response message returned by the API.
+    /// The raw HTTP response message returned by the API. Use this for advanced scenarios that
+    /// need response headers, the originating <see cref="System.Net.Http.HttpResponseMessage.RequestMessage"/>,
+    /// the HTTP version, reason phrase, or other transport-level details. This message is disposed
+    /// when the <see cref="ApiResult{T}"/> is disposed.
     /// </summary>
     public HttpResponseMessage? HttpResponseMessage { get; internal set; } = null!;
-}
\ No newline at end of file
+
+    /// <summary>
+    /// Releases the owned HTTP response message.
+    /// </summary>
+    public void Dispose()
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        HttpResponseMessage?.Dispose();
+        _disposed = true;
+    }
+}
diff --git a/src/HtmlCssToImage/README.md b/src/HtmlCssToImage/README.md
index 1727de2..7b9e5f0 100644
--- a/src/HtmlCssToImage/README.md
+++ b/src/HtmlCssToImage/README.md
@@ -30,6 +30,20 @@ var client = new HtmlCssToImageClient(http, options);
 
 If you're using ASP.NET Core or similar frameworks supporting Microsoft DI, check out the [HtmlCssToImage.DependencyInjection Package Docs](https://github.com/htmlcsstoimage/dotnet-client/blob/main/src/HtmlCssToImage.DependencyInjection/README.md) for how to inject the client into your application.
 
+## Response Shape
+
+Most client methods that call the HCTI API return an [`ApiResult<T>`](https://github.com/htmlcsstoimage/dotnet-client/blob/main/src/HtmlCssToImage/Models/Results/ApiResult.cs). Signed URL helpers return a `string` instead because they do not make an HTTP request.
+
+An `ApiResult<T>` provides:
+
+- `Response`: The typed response body when the request succeeds.
+- `ErrorDetails`: The typed API error when the request fails.
+- `Success` and `StatusCode`: A quick way to inspect the outcome.
+- `HttpResponseMessage`: The raw HTTP response for advanced cases.
+
+The raw `HttpResponseMessage` is included so you can inspect response headers, the originating `RequestMessage`, the HTTP version, reason phrase, and other transport-level details that are not part of the typed response.
+
+`ApiResult<T>` owns that raw response and implements `IDisposable`. Use `using` or `using var` for every result so the underlying response and content are released promptly.
 
 ## Creating Images
 You can generate images using your HCTI client with strongly typed parameters:
@@ -51,7 +65,7 @@ var html_request = new CreateHtmlCssImageRequest()
     ViewportHeight = 400
 };
 
-var html_image = await client.CreateImageAsync(html_request);
+using var html_image = await client.CreateImageAsync(html_request);
 
 if(html_image.Success)
 {
@@ -61,7 +75,21 @@ if(html_image.Success)
 }
 ```
 
-Image creation responds with an [`ApiResult<CreateImageResponse>`](https://github.com/htmlcsstoimage/dotnet-client/blob/main/src/HtmlCssToImage/Models/Responses/CreateImageResponse.cs). [`ApiResult<T>`](https://github.com/htmlcsstoimage/dotnet-client/blob/main/src/HtmlCssToImage/Models/Results/ApiResult.cs) is a simple wrapper around Api responses that provides an indicator of `Success` and potentially `ErrorDetails` if the request failed.
+## Deleting Images
+
+Delete one or more existing images from HCTI and clear them from the CDN using their image IDs:
+
+```csharp
+using var result = await client.DeleteImageAsync("your-image-id");
+
+if (!result.Success)
+{
+    Console.WriteLine(result.ErrorDetails.Message);
+}
+
+using var batchResult = await client.DeleteImageBatchAsync(
+    ["first-image-id", "second-image-id"]);
+```
 
 ### Template Helpers
 When creating a templated image, you can use static helper methods `FromObject<T>` on the `CreateTemplatedImageRequest` class to generate a template, providing serialization options for AOT/serialization control. See more below in the [Performance & Native AOT](#performance--native-aot) section.
@@ -84,9 +112,7 @@ Call `CreateImageBatchAsync<T>` on the client to create a batch of images from a
 You can construct a `CreateImageBatchRequest` object directly or use the overload on `HtmlCssToImageClient` that accepts `defaultOptions` and `variations` as parameters.
 
 
-Batch creation responds with an [`ApiResult<CreateImageResponse[]>`](https://github.com/htmlcsstoimage/dotnet-client/blob/main/src/HtmlCssToImage/Models/Responses/CreateImageResponse.cs). [`ApiResult<T>`](https://github.com/htmlcsstoimage/dotnet-client/blob/main/src/HtmlCssToImage/Models/Results/ApiResult.cs) is a simple wrapper around Api responses that provides an indicator of `Success` and potentially `ErrorDetails` if the request failed.
-
-If your request is successful, the `Response` property will be an array in the order of your `variations`.
+Batch creation responds with an [`ApiResult<CreateImageResponse[]>`](https://github.com/htmlcsstoimage/dotnet-client/blob/main/src/HtmlCssToImage/Models/Responses/CreateImageResponse.cs). If your request is successful, the `Response` property will be an array in the order of your `variations`.
 
 ## Creating Image URLs
 
diff --git a/src/tests/HtmlCssToImage.Tests/HtmlCssToImageClientTemplatesTests.cs b/src/tests/HtmlCssToImage.Tests/HtmlCssToImageClientTemplatesTests.cs
index b49a90c..59b1ec4 100644
--- a/src/tests/HtmlCssToImage.Tests/HtmlCssToImageClientTemplatesTests.cs
+++ b/src/tests/HtmlCssToImage.Tests/HtmlCssToImageClientTemplatesTests.cs
@@ -68,7 +68,7 @@ public async Task ListTemplates_ReturnsSuccessResult()
                 Content = JsonContent.Create(expectedResponse, JsonContext.Default.PaginatedResponseTemplate)
             });
 
-        var result = await client.ListTemplatesAsync(cancellationToken: TestContext.Current.CancellationToken);
+        using var result = await client.ListTemplatesAsync(cancellationToken: TestContext.Current.CancellationToken);
 
         Assert.True(result.Success);
         Assert.NotNull(result.Response);
@@ -95,7 +95,7 @@ public async Task ListTemplates_UsesConfiguredHost()
 
         var client = CreateClient("https://example.test");
 
-        await client.ListTemplatesAsync(cancellationToken: TestContext.Current.CancellationToken);
+        using var result = await client.ListTemplatesAsync(cancellationToken: TestContext.Current.CancellationToken);
 
         Assert.NotNull(capturedRequest);
         Assert.Equal(new Uri("https://example.test/v1/template?count=10"), capturedRequest.RequestUri);
@@ -123,7 +123,7 @@ public async Task ListTemplateVersions_ReturnsSuccessResult()
                 Content = JsonContent.Create(expectedResponse, JsonContext.Default.PaginatedResponseTemplate)
             });
 
-        var result = await client.ListTemplateVersionsAsync(templateId, count: 20, cancellationToken: TestContext.Current.CancellationToken);
+        using var result = await client.ListTemplateVersionsAsync(templateId, count: 20, cancellationToken: TestContext.Current.CancellationToken);
 
         Assert.True(result.Success);
         Assert.NotNull(result.Response);
@@ -147,7 +147,7 @@ public async Task ListTemplatesCore_HandlesErrorResponse()
                 Content = JsonContent.Create(errorDetails, JsonContext.Default.ErrorDetails)
             });
 
-        var result = await client.ListTemplatesAsync(cancellationToken: TestContext.Current.CancellationToken);
+        using var result = await client.ListTemplatesAsync(cancellationToken: TestContext.Current.CancellationToken);
 
         Assert.False(result.Success);
         Assert.Equal(401, result.StatusCode);
@@ -173,7 +173,7 @@ public async Task ListTemplates_ClampsCountValue(int inputCount, uint expectedUs
                 Content = JsonContent.Create(new PaginatedResponse<Template> { Data = [], Pagination = new PaginatedResponse<Template>.PaginationInfo(null) }, JsonContext.Default.PaginatedResponseTemplate)
             });
 
-        await client.ListTemplatesAsync(count: inputCount, cancellationToken: TestContext.Current.CancellationToken);
+        using var result = await client.ListTemplatesAsync(count: inputCount, cancellationToken: TestContext.Current.CancellationToken);
         
         _handlerMock.Protected().Verify(
             "SendAsync",
diff --git a/src/tests/HtmlCssToImage.Tests/HtmlCssToImageClientTests.cs b/src/tests/HtmlCssToImage.Tests/HtmlCssToImageClientTests.cs
index c2cc129..b5837ab 100644
--- a/src/tests/HtmlCssToImage.Tests/HtmlCssToImageClientTests.cs
+++ b/src/tests/HtmlCssToImage.Tests/HtmlCssToImageClientTests.cs
@@ -348,13 +348,97 @@ public async Task CreateImageAsync_WhenSuccess_ReturnsResponseData()
                 Content = JsonContent.Create(new { url = "https://hcti.io/v1/image/img_1", id = "img_1" })
             });
 
-        var result = await client.CreateImageAsync(request, TestContext.Current.CancellationToken);
+        using var result = await client.CreateImageAsync(request, TestContext.Current.CancellationToken);
 
         Assert.True(result.Success);
         Assert.NotNull(result.Response);
         Assert.Equal("img_1", result.Response.Id);
     }
 
+    [Fact]
+    public async Task DeleteImageAsync_WhenAccepted_SendsDeleteAndReturnsTrue()
+    {
+        HttpRequestMessage? capturedRequest = null;
+        _handlerMock.Protected()
+            .Setup<Task<HttpResponseMessage>>(
+                "SendAsync",
+                ItExpr.IsAny<HttpRequestMessage>(),
+                ItExpr.IsAny<CancellationToken>())
+            .Callback<HttpRequestMessage, CancellationToken>((request, _) => capturedRequest = request)
+            .ReturnsAsync(new HttpResponseMessage
+            {
+                StatusCode = HttpStatusCode.Accepted
+            });
+
+        var client = CreateClient();
+        using var result = await client.DeleteImageAsync("image/id", TestContext.Current.CancellationToken);
+
+        Assert.NotNull(capturedRequest);
+        Assert.Equal(HttpMethod.Delete, capturedRequest.Method);
+        Assert.Equal(new Uri("https://hcti.io/v1/image/image%2Fid"), capturedRequest.RequestUri);
+        Assert.True(result.Success);
+        Assert.Equal(202, result.StatusCode);
+        Assert.True(result.Response);
+    }
+
+    [Fact]
+    public async Task DeleteImageAsync_WhenError_PopulatesErrorDetails()
+    {
+        _handlerMock.Protected()
+            .Setup<Task<HttpResponseMessage>>(
+                "SendAsync",
+                ItExpr.IsAny<HttpRequestMessage>(),
+                ItExpr.IsAny<CancellationToken>())
+            .ReturnsAsync(new HttpResponseMessage
+            {
+                StatusCode = HttpStatusCode.NotFound,
+                Content = JsonContent.Create(new { message = "Image not found", error = "not_found" })
+            });
+
+        var client = CreateClient();
+        using var result = await client.DeleteImageAsync("missing-image", TestContext.Current.CancellationToken);
+
+        Assert.False(result.Success);
+        Assert.Equal(404, result.StatusCode);
+        Assert.Null(result.Response);
+        Assert.NotNull(result.ErrorDetails);
+        Assert.Equal("Image not found", result.ErrorDetails.Message);
+        Assert.Equal("not_found", result.ErrorDetails.ErrorType);
+    }
+
+    [Fact]
+    public async Task DeleteImageBatchAsync_SendsIdsInDeleteRequest()
+    {
+        HttpRequestMessage? capturedRequest = null;
+        _handlerMock.Protected()
+            .Setup<Task<HttpResponseMessage>>(
+                "SendAsync",
+                ItExpr.IsAny<HttpRequestMessage>(),
+                ItExpr.IsAny<CancellationToken>())
+            .Callback<HttpRequestMessage, CancellationToken>((request, _) => capturedRequest = request)
+            .ReturnsAsync(new HttpResponseMessage
+            {
+                StatusCode = HttpStatusCode.Accepted
+            });
+
+        var client = CreateClient();
+        using var result = await client.DeleteImageBatchAsync(
+            ["image-1", "image-2"],
+            TestContext.Current.CancellationToken);
+
+        Assert.NotNull(capturedRequest);
+        Assert.Equal(HttpMethod.Delete, capturedRequest.Method);
+        Assert.Equal(new Uri("https://hcti.io/v1/image/batch"), capturedRequest.RequestUri);
+        var request = await capturedRequest.Content!.ReadFromJsonAsync<DeleteImageBatchRequest>(
+            JsonContext.Default.DeleteImageBatchRequest,
+            TestContext.Current.CancellationToken);
+        Assert.NotNull(request);
+        Assert.Equal(["image-1", "image-2"], request.Ids);
+        Assert.True(result.Success);
+        Assert.Equal(202, result.StatusCode);
+        Assert.True(result.Response);
+    }
+
     [Fact]
     public async Task CreateImageAsync_UsesDefaultHost()
     {
@@ -374,7 +458,7 @@ public async Task CreateImageAsync_UsesDefaultHost()
         var client = CreateClient(DefaultHost);
         var request = new CreateHtmlCssImageRequest { Html = "<b>Test</b>" };
 
-        await client.CreateImageAsync(request, TestContext.Current.CancellationToken);
+        using var result = await client.CreateImageAsync(request, TestContext.Current.CancellationToken);
 
         Assert.NotNull(capturedRequest);
         Assert.Equal(new Uri("https://hcti.io/v1/image?includeId=true"), capturedRequest.RequestUri);
@@ -400,7 +484,7 @@ public async Task CreateImageAsync_UsesConfiguredHost()
         var client = CreateClient(configuredBaseUrl);
         var request = new CreateHtmlCssImageRequest { Html = "<b>Test</b>" };
 
-        await client.CreateImageAsync(request, TestContext.Current.CancellationToken);
+        using var result = await client.CreateImageAsync(request, TestContext.Current.CancellationToken);
 
         Assert.NotNull(capturedRequest);
         Assert.Equal(new Uri("https://example.test/v1/image?includeId=true"), capturedRequest.RequestUri);
@@ -434,7 +518,7 @@ public async Task CreateImageBatchAsync_WhenError_PopulatesErrorDetails()
                 Content = JsonContent.Create(new { message = "Invalid request", error = "missing_params" })
             });
 
-        var result = await client.CreateImageBatchAsync(request, TestContext.Current.CancellationToken);
+        using var result = await client.CreateImageBatchAsync(request, TestContext.Current.CancellationToken);
 
         Assert.False(result.Success);
         Assert.Equal(400, result.StatusCode);
diff --git a/src/tests/HtmlCssToImage.Tests/Models/Results/ApiResultTests.cs b/src/tests/HtmlCssToImage.Tests/Models/Results/ApiResultTests.cs
new file mode 100644
index 0000000..e8f1b70
--- /dev/null
+++ b/src/tests/HtmlCssToImage.Tests/Models/Results/ApiResultTests.cs
@@ -0,0 +1,69 @@
+using System.Net;
+using HtmlCssToImage.Models.Results;
+
+namespace HtmlCssToImage.Tests.Models.Results;
+
+public class ApiResultTests
+{
+    [Fact]
+    public void Dispose_DisposesOwnedHttpResponseMessage()
+    {
+        var content = new TrackingHttpContent();
+        var response = new HttpResponseMessage
+        {
+            Content = content
+        };
+        var result = new ApiResult<object?>
+        {
+            HttpResponseMessage = response
+        };
+
+        result.Dispose();
+
+        Assert.True(content.IsDisposed);
+    }
+
+    [Fact]
+    public void Dispose_CanBeCalledMoreThanOnce()
+    {
+        var content = new TrackingHttpContent();
+        var result = new ApiResult<object?>
+        {
+            HttpResponseMessage = new HttpResponseMessage
+            {
+                Content = content
+            }
+        };
+
+        result.Dispose();
+        result.Dispose();
+
+        Assert.Equal(1, content.DisposeCount);
+    }
+
+    private sealed class TrackingHttpContent : HttpContent
+    {
+        public bool IsDisposed => DisposeCount > 0;
+
+        public int DisposeCount { get; private set; }
+
+        protected override Task SerializeToStreamAsync(Stream stream, TransportContext? context) =>
+            Task.CompletedTask;
+
+        protected override bool TryComputeLength(out long length)
+        {
+            length = 0;
+            return true;
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                DisposeCount++;
+            }
+
+            base.Dispose(disposing);
+        }
+    }
+}