Install Jentic One Beta

Connect the DeepImage API to your agent

Jentic One is a self-hosted execution layer for AI agents. It lets your agent call the DeepImage API, or any other public or private API you need. You set the rules, the agent never sees your credentials, and every call is logged.

Two steps, two machines. Install the instance in a safe environment, then register your agent from wherever it runs.

Step 1: Jentic One Host machine

# On the machine that will host your Jentic One instance:
curl -fsSL "https://jentic.com/install.sh?src=apis&api=%2Fapis%2Fdeep-image.ai%2Fdeep-image" | sh

Step 2: Agent machine

# On the machine where your agent runs (keep this separate from the instance):
curl -fsSL "https://jentic.com/install.sh?src=apis&api=%2Fapis%2Fdeep-image.ai%2Fdeep-image" | sh
jentic register       # connects your agent to your Jentic One instance

Jentic One is in public beta. The setup above keeps your agent separate from the instance, which is what you want before using real credentials: an agent running as the same OS user as Jentic One can read its stored keys directly. Just evaluating? A single local install is fine to start. See the secure deployment guide for the tiers.

Capabilities

What an agent can do with DeepImage API.

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

GET STARTED

Start building with DeepImage API

Explore with Jentic One

View OpenAPI Document

Use Cases

Patterns agents use DeepImage API for, with concrete tasks.

★ 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.

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.

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.

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.

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

2 endpoints — deep-image.

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

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

Why Jentic?

What agents get from Jentic-routed access to this vendor.

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 isolation

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.

Intent-based discovery

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.

FAQs

Specific to using DeepImage API through Jentic.

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.

DeepImage API

Name: DeepImage API
Brand: DeepImage API
Availability: InStock

Official vendor OpenAPI document · agent-readyMediaImage ProcessingapiKey2 EndpointsREST

For 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.

Use for: I need to upscale an image with AI, Remove the background from a product photo, Sharpen and denoise a low-quality photo, Submit an image for AI enhancement

Not supported: 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.

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.

Jentic One on Github View OpenAPI Document