AI Image Deblur API

• API Endpoint Access URL
• Image Deblurring API
• API Pricing
• HTTP Methods
• HTTP Parameters
• HTTP Response
• Code Samples
• Frequently Asked Questions
• Similar API Endpoints

API Endpoint Access URL

https://api.pixlab.io/deblur

AI Image Deblurring and Photo Restoration

The PixLab Image Deblur API (DEBLUR) reduces motion blur and camera shake in photographs with one REST request. Upload a JPEG, PNG, or WebP image or provide its public URL. The processed image preserves the original width, height, and aspect ratio.

Image deblurring estimates clearer detail from blurred visual information. It differs from sharpening, which increases contrast around existing edges. To enlarge a photo instead, use the Image Upscale and Enhancement API.

Built for developers supporting marketing teams, ecommerce businesses, and creative agencies, DEBLUR brings photo restoration into existing publishing workflows. Call it from your backend to process campaign photography, supplier images, property listings, or customer uploads before review and publication. Python, JavaScript, PHP, and Ruby examples are included below.

Compare motion blur with clearer window edges, brickwork, and bicycle detail in the same scene. This is an illustrative comparison, not an API output sample; actual results depend on the source photo.

What DEBLUR provides:

• A REST endpoint for backend services, automation workers, and scheduled jobs. No SDK is required.
• Motion-blur reduction without a client-generated image mask.
• Restoration at the original image dimensions, without cropping the scene.
• Input through a public image URL or direct file upload, with output as Base64 JSON data, raw image bytes, or a file in your connected AWS S3 bucket.
• JPEG, PNG, and WebP inputs up to 4,000,000 pixels and 10 MiB. Larger inputs are rejected rather than silently resized.

Bulk photo deblurring for catalogs and campaign libraries

Connect DEBLUR to your product information management (PIM), content management (CMS), or digital asset management (DAM) system through your own application. Each request processes one image. Queue catalog imports and campaign assets with bounded concurrency, within your account limits. For sustained high-volume processing, contact the PixLab support team with your daily volume and typical image dimensions.

Image deblurring for marketing, ecommerce, and real estate

• Marketing teams: reduce camera shake in event photos, lifestyle imagery, and campaign assets before preparing social media posts, email newsletters, and landing pages.
• Ecommerce and marketplaces: restore blurred supplier and seller photos for product detail pages and catalogs. Review labels, colors, and product features against the original before publishing.
• Creative and digital agencies: add a photo-restoration step to client asset intake and content production, with an approval stage for brand-sensitive imagery.
• Real estate and hospitality: reduce motion blur in property interiors, exterior views, and accommodation photos without changing their proportions.
• SaaS and photo-editing tools: integrate image deblurring into upload flows and editing applications using the same REST request pattern.
• Publishers and media archives: process scanned photographs and extracted video frames when reshooting is not possible, retaining the source for editorial review.

Output quality depends on the source image. Severe blur, compression, and missing detail can prevent faithful restoration. Keep the original and review faces, lettering, and repeated patterns before publishing the result.

Image processing and storage: Keep your source images for comparison. With a connected AWS S3 bucket, output can be written to your own storage. Review the PixLab Privacy Policy for processing and retention details.

To get started, create an API key in the PixLab Console ↗, submit a public image URL or upload a file, and consume the returned image data. See the Python, JavaScript, PHP, and Ruby samples below ↓.

Build a complete product-photo workflow with the Background Removal API for subject isolation and the Image Upscale API for larger gallery images. For authorized cleanup of text overlays on marketing assets, use the Text and Watermark Removal API.

Image Deblur API Pricing

PixLab offers monthly API plans for developers and businesses. Check your account for DEBLUR usage and rate limits before processing a large image collection.

• Starter: Review the current monthly allowance and account limits for your integration.
• Pro: Compare the available quota and throughput options as your image workload grows.
• Business and Enterprise: High-volume options for larger workloads, support, and dedicated deployment discussions.

Plan your workload: each DEBLUR request processes one image. Account for daily volume and peak concurrency when choosing a plan.

Review the current PixLab monthly API plans → or open the PixLab Console ↗ to check your usage and account limits.

HTTP Methods

GET, POST

Use GET with a public image URL or POST to upload a local file. Each request processes one source image.

HTTP Parameters

HTTP Response

Code Samples

import base64
import os
from pathlib import Path

import requests

with open("photo.jpg", "rb") as image:
    response = requests.post(
        "https://api.pixlab.io/deblur",
        headers={"WWW-Authenticate": os.environ["PIXLAB_API_KEY"]},
        files={"file": ("photo.jpg", image, "image/jpeg")},
        timeout=(10, 120),
    )

response.raise_for_status()
result = response.json()
if result.get("status") != 200:
    raise RuntimeError(result.get("error", "Image processing failed"))

if result.get("link"):
    print("Image URL:", result["link"])
else:
    extension = result["extension"]
    if extension not in {"png", "jpeg", "jpg", "webp"}:
        raise ValueError("Unexpected output format")
    output = Path(f"deblur-output.{extension}")
    output.write_bytes(base64.b64decode(result["imgData"], validate=True))
    print(output)

// Run server-side with Node.js 20+ as an .mjs file.
import { readFile, writeFile } from "node:fs/promises";

async function processImage() {
    const apiKey = process.env.PIXLAB_API_KEY;
    if (!apiKey) throw new Error("Set PIXLAB_API_KEY in your environment.");

    const form = new FormData();
    const image = await readFile("photo.jpg");
    form.append("file", new Blob([image], { type: "image/jpeg" }), "photo.jpg");

    const response = await fetch("https://api.pixlab.io/deblur", {
        method: "POST",
        headers: { "WWW-Authenticate": apiKey },
        body: form,
        signal: AbortSignal.timeout(120000),
    });
    if (!response.ok) throw new Error("HTTP " + response.status);

    const result = await response.json();
    if (result.status !== 200) {
        throw new Error(result.error || "Image processing failed");
    }
    if (result.link) {
        console.log("Image URL:", result.link);
        return;
    }
    if (!["png", "jpeg", "jpg", "webp"].includes(result.extension)) {
        throw new Error("Unexpected output format");
    }
    const output = "deblur-output." + result.extension;
    await writeFile(output, Buffer.from(result.imgData, "base64"));
    console.log(output);
}

processImage().catch((error) => {
    console.error(error.message);
    process.exitCode = 1;
});

<?php
$apiKey = getenv('PIXLAB_API_KEY');
$imagePath = realpath('photo.jpg');
if (!$apiKey || $imagePath === false) {
    throw new RuntimeException('Set PIXLAB_API_KEY and provide photo.jpg.');
}

$ch = curl_init('https://api.pixlab.io/deblur');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CONNECTTIMEOUT => 10,
    CURLOPT_TIMEOUT => 120,
    CURLOPT_HTTPHEADER => ['WWW-Authenticate: ' . $apiKey],
    CURLOPT_POSTFIELDS => [
        'file' => new CURLFile($imagePath, 'image/jpeg', 'photo.jpg'),
    ],
]);

$response = curl_exec($ch);
$error = curl_error($ch);
$httpStatus = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

if ($response === false) {
    throw new RuntimeException($error);
}
if ($httpStatus < 200 || $httpStatus >= 300) {
    throw new RuntimeException('HTTP ' . $httpStatus);
}
$result = json_decode($response, true, 512, JSON_THROW_ON_ERROR);
if (($result['status'] ?? null) !== 200) {
    throw new RuntimeException($result['error'] ?? 'Image processing failed');
}

if (!empty($result['link'])) {
    echo $result['link'] . PHP_EOL;
} else {
    $extension = $result['extension'];
    if (!in_array($extension, ['png', 'jpeg', 'jpg', 'webp'], true)) {
        throw new RuntimeException('Unexpected output format');
    }
    $image = base64_decode($result['imgData'], true);
    if ($image === false) {
        throw new RuntimeException('Invalid image data');
    }
    $output = 'deblur-output.' . $extension;
    if (file_put_contents($output, $image) === false) {
        throw new RuntimeException('Could not save output image');
    }
    echo $output . PHP_EOL;
}

require 'net/http'
require 'json'
require 'base64'

uri = URI('https://api.pixlab.io/deblur')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
http.open_timeout = 10
http.read_timeout = 120
http.write_timeout = 120

request = Net::HTTP::Post.new(uri)
request['WWW-Authenticate'] = ENV.fetch('PIXLAB_API_KEY')

response = File.open('photo.jpg', 'rb') do |image|
  request.set_form(
    [['file', image, { filename: 'photo.jpg', content_type: 'image/jpeg' }]],
    'multipart/form-data'
  )
  http.request(request)
end

raise "HTTP #{response.code}" unless response.is_a?(Net::HTTPSuccess)

result = JSON.parse(response.body)
raise(result['error'] || 'Image processing failed') unless result['status'] == 200

if result['link']
  puts result['link']
else
  extension = result.fetch('extension')
  raise 'Unexpected output format' unless %w[png jpeg jpg webp].include?(extension)

  output = "deblur-output.#{extension}"
  File.binwrite(output, Base64.strict_decode64(result.fetch('imgData')))
  puts output
end

Frequently Asked Questions