canonical: https://jentic.com/apis/deep-image.ai/deep-image

# DeepImage API

Deep-image.ai is an AI image-editing service exposing a minimal two-endpoint API for image enhancement, upscaling, background removal, sharpening, denoising, and deblurring. Submit an image to `/rest_api/process_result` and the service returns a job identifier; poll `/rest_api/result/{job_id}` until processing finishes and the enhanced image URL is returned. Authentication is a single x-api-key header. The two-step async pattern keeps the API simple while still supporting heavy AI transforms.

## For AI agents

Submit an image for AI enhancement, upscaling, or background removal on Deep-image.ai and poll for the processed result via a job identifier.

## Scope

Does not handle text-to-image generation, video processing, or model fine-tuning - use for Deep-image.ai still-image enhancement and background removal only.

## Capabilities

- Submit an image to `/rest_api/process_result` with the desired enhancement options
- Apply upscaling, sharpening, denoising, deblurring, and background removal in a single processing job
- Poll `/rest_api/result/{job_id}` to retrieve the processed image URL once the job completes
- Authenticate every call with the x-api-key header
- Drive a fully asynchronous transform pipeline without holding a long HTTP connection

## Use cases

### E-commerce product photo enhancement

Online stores receiving low-quality supplier images need them upscaled and cleaned before they go on the storefront. Submitting each photo to `/rest_api/process_result` with upscaling and background removal enabled produces a clean, transparent-background asset, and polling `/rest_api/result/{job_id}` recovers the processed URL when ready. The async pattern fits naturally into a queue-driven media pipeline.

Example prompt: POST `/rest_api/process_result` with the image URL and {enhance: {upscale: true}, background: {remove: true}}, then poll `/rest_api/result/{job_id}` every 5 seconds until status='complete'.

### Restoring legacy or low-resolution photo archives

Archival projects with old, blurry, or noisy scans can run each image through Deep-image.ai with sharpening, denoising, and deblurring enabled. The single processing endpoint handles all three transforms in one job, so the workflow stays a simple submit-then-poll loop rather than chaining separate services for each step.

Example prompt: Submit each archived image to `/rest_api/process_result` with sharpen, denoise, and deblur flags, and store each returned output URL alongside the original.

### Pre-print upscaling for marketing assets

Marketing teams that receive low-resolution creative from agencies often need 4x upscales for print or large-format display. `/rest_api/process_result` with the upscale option produces a higher-resolution output, and the polled result endpoint returns a download URL the team can pull into their asset library or DAM.

Example prompt: POST `/rest_api/process_result` with the source URL and upscale options, then poll `/rest_api/result/{job_id}` and store the upscaled URL in the DAM.

### AI agent processing images through Jentic

An agent handling user-uploaded images can search Jentic for 'enhance an image with AI', submit each upload to Deep-image.ai without exposing the API key, and asynchronously check back via the job id. Because Jentic returns the schema for both endpoints, the agent can compose the submit-then-poll flow without studying Deep-image's docs.

Example prompt: Search Jentic for 'enhance an image with AI', execute `/rest_api/process_result`, then loop `/rest_api/result/{job_id}` until the job is complete.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/rest_api/process_result` | Submit an image for AI processing and receive a job id |
| GET | `/rest_api/result/{job_id}` | Poll for the processed image once the job completes |

## Key resources

- **Image Processing** — Submit-and-poll pair for AI image enhancements, upscaling, and background removal

## Why Jentic

- **Setup:** Wiring the Deep-image.ai API by hand means learning its x-api-key header and building the async flow yourself: submit an image for processing, then poll the result endpoint by job id. Through Jentic you install once, import the Deep-image.ai API from the API Directory, store the API key once, and your agent calls it.
- **Permission scoping:** Deep-image.ai carries the image and options in the request body and returns a job id you poll, so limit the agent to the operations it needs, such as submitting a process request and reading its result. Because you pick the operations, the agent runs only the enhancement and result-polling calls you grant.
- **Credential handling:** Your Deep-image.ai x-api-key is stored once, encrypted, by your own Jentic One instance and set in the header at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'enhance an image with AI' or 'remove the background from a photo', and Jentic returns the submit-and-poll pair with their input schemas so the agent composes the async flow without studying Deep-image's docs.

## Related APIs

- **remove.bg API** — Specialised background-removal API with synchronous response.
- **Cloudinary Upload API** — Image storage, on-the-fly transformations, and CDN delivery.
- **DeepAI API** — Multi-model AI API including image upscaling, colorization, and background removal.

## FAQ

### What authentication does the DeepImage API use?

Deep-image.ai uses an API key passed in the x-api-key request header on every call. Through Jentic the key is held in the encrypted vault and added to the header at execution time, so the raw key never enters the agent's context.

### Can I upscale and remove the background in a single Deep-image.ai call?

Yes. POST `/rest_api/process_result` accepts a payload that combines enhancement options, so upscale, background removal, sharpen, denoise, and deblur can run in one job. You still need to poll `/rest_api/result/{job_id}` to retrieve the output URL when the job completes.

### How do I get the processed image after submitting a job?

GET `/rest_api/result/{job_id}` with the job id returned from the submit call. Poll this endpoint until the status indicates completion, then use the output URL from the response. Build retry/backoff into your client because heavy transforms can take several seconds.

### What are the rate limits for the DeepImage API?

The OpenAPI spec does not document explicit rate limits. For batch workloads, queue submissions client-side and poll only the in-flight job ids rather than holding open connections, which keeps the API key well within typical service limits.

### How do I enhance an image through Jentic?

Run pip install jentic, search for 'enhance an image with AI', and Jentic returns the `/rest_api/process_result` operation with its input schema. Load it, supply the source URL and the enhancement flags, and execute. Then load `/rest_api/result/{job_id}` and poll until the job is complete.

### Does Deep-image.ai accept images by direct upload or only by URL?

Per the spec, `/rest_api/process_result` is the single submission endpoint. Provide the image as part of the request payload as documented by Deep-image.ai. The async pattern means the API returns a job id immediately rather than waiting for processing to finish.

### Can I limit what my agent is allowed to do with the DeepImage API?

Yes. Because you run Jentic One yourself, your own rules decide which Deep-image.ai operations and credentials the agent may use. The DeepImage API exposes only two operations, so you can grant just submitting a process request to POST `/rest_api/process_result` and reading its result from GET `/rest_api/result/{job_id}`, and withhold anything else. The agent runs only the enhancement and result-polling calls you allow, using the stored x-api-key that you control.