canonical: https://jentic.com/apis/deeparteffects.com/deeparteffects-api

# Deep Art Effects

Deep Art Effects is an AI artistic style transfer service whose three-endpoint API lets a client list available styles, upload an image with a chosen style, and retrieve the rendered output. Jentic maintains a curated, agent-optimized OpenAPI 3.0.0 specification converted from the Swagger 2.0 document Deep Art Effects publishes on its own documentation host, with operation ids and per-operation descriptions added for agent tooling. The submit-then-poll pattern keeps client logic simple while supporting the heavy GPU work that style transfer requires. Authentication is an x-api-key header.

## For AI agents

Apply AI artistic style transfer to images by listing styles, submitting an image, and retrieving the stylised result via the Deep Art Effects API.

## Scope

Does not handle background removal, super resolution, or text-to-image generation - use for Deep Art Effects artistic style transfer only.

## Capabilities

- List available artistic styles via GET /noauth/styles
- Submit an image and chosen style for processing through POST /noauth/upload
- Retrieve the stylised output once processing completes with GET /noauth/result
- Authenticate every call with the x-api-key header
- Drive a submit-and-poll style-transfer pipeline that fits inside an async media workflow

## Use cases

### Stylised user content in mobile and web apps

Apps that let users transform photos into art-style variants need a stable catalogue and a submit-and-poll flow. /noauth/styles returns the catalogue, /noauth/upload accepts the user image with a chosen style, and /noauth/result returns the rendered output. The split between submit and result lets the client show progress while the GPU job runs.

Example prompt: GET /noauth/styles, render the picker, POST /noauth/upload with the user's image and chosen style id, then poll /noauth/result for the rendered output.

### Brand-locked editorial illustration generation

Editorial workflows that want a consistent visual treatment across a content series can lock in a single style id from /noauth/styles and apply it to every source photo through /noauth/upload. Because the same style id renders the same look, the published series stays visually coherent without per-piece manual editing.

Example prompt: POST /noauth/upload for each editorial photo using the locked-in style id, then GET /noauth/result for each job and store the output URLs.

### Style catalogue refresh on a schedule

Integrations that surface a style picker should keep it in sync with the live catalogue. Calling /noauth/styles on a daily schedule lets the client pick up any new or seasonal styles without redeploying. This is especially useful when Deep Art Effects launches limited-time styles tied to events or holidays.

Example prompt: GET /noauth/styles each day and diff the response against the cached catalogue to pick up new styles.

### AI agent stylising photos through Jentic

An agent producing stylised creative for a campaign can search Jentic for 'apply artistic style to a photo', list styles via Jentic, and execute the upload-and-result pair without holding the API key. Because the catalogue and the result endpoint are separate, the agent can also branch logic on which styles are available before submitting.

Example prompt: Search Jentic for 'apply artistic style to a photo', GET /noauth/styles, POST /noauth/upload with the chosen style and image, then GET /noauth/result.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| GET | /noauth/styles | List available artistic styles |
| POST | /noauth/upload | Submit an image with a chosen style |
| GET | /noauth/result | Retrieve the stylised result |

## Key resources

- **noauth** — Style catalogue, upload, and result retrieval endpoints despite their /noauth prefix

## Why Jentic

- **Setup:** Wiring the Deep Art Effects API by hand means learning its x-api-key header and building the flow across its /noauth style, upload, and result endpoints yourself. Through Jentic you install once, import the Deep Art Effects API from the API Directory, store the API key once, and your agent calls it.
- **Permission scoping:** Deep Art Effects carries the image and style choice in the request rather than as a resource id in the URL path, so limit the agent to the operations it needs, such as listing styles, uploading an image, and reading the result. Because you pick the operations, the agent runs only the style-transfer calls you grant.
- **Credential handling:** Your Deep Art Effects 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 'apply artistic style to a photo' or 'list available art styles', and Jentic returns the matching operation with its input schema so the agent calls the right endpoint without learning the /noauth path quirk by hand.

## Related APIs

- **DeepAI API** — Multi-model vision API including text-to-image, colorization, and super resolution.
- **DeepImage API** — AI enhancement, upscaling, and background removal with submit-and-poll.
- **Replicate API** — Run thousands of community-hosted vision models including various style-transfer variants.

## FAQ

### Which OpenAPI specification does this Deep Art Effects page describe?

A curated, agent-optimized Jentic specification covering the three Deep Art Effects operations. Deep Art Effects also publishes its own Swagger 2.0 document in its documentation at http://docs.deeparteffects.com/swagger.json, which has been unchanged since 13 September 2017 and carries neither operation ids nor per-operation descriptions. The Jentic variant is a validated OpenAPI 3.0.0 conversion of that same document, matching it operation for operation and adding the operation ids and descriptions agent tooling needs. Get started with Jentic One, the self-hosted execution layer.

### What authentication does the Deep Art Effects API use?

Deep Art Effects uses an API key passed in the x-api-key header. Despite the /noauth path prefix, every endpoint requires the key. Through Jentic the key is held in the encrypted vault and applied to the header at execution time, so it never enters the agent's context.

### How do I find the right style id before uploading?

GET /noauth/styles returns the catalogue of available styles with their identifiers. Cache the result on the client to populate a picker, and pass the chosen style id in the /noauth/upload request body.

### How do I get the stylised output after submitting an image?

Call GET /noauth/result after /noauth/upload completes. Heavier styles can take several seconds to render, so build retry-with-backoff into the polling client rather than calling once and giving up.

### What are the rate limits for the Deep Art Effects API?

The OpenAPI spec does not document explicit rate limits. Treat /noauth/styles as cacheable client-side and reserve /noauth/upload for actual user-driven submissions to keep request volume bounded.

### How do I apply style transfer through Jentic?

Run pip install jentic, search for 'apply artistic style to a photo', and Jentic returns the /noauth/upload operation with its input schema. List styles via /noauth/styles, load /noauth/upload with the chosen style id and image, execute, then poll /noauth/result.

### Can I limit what my agent is allowed to do with the Deep Art Effects API?

Yes. Because you run Jentic One yourself, your own rules decide which of the Deep Art Effects operations the agent may call and which credentials it may use. You can grant only the calls a given task needs, such as listing styles with GET /noauth/styles, submitting an image with POST /noauth/upload, and reading the output with GET /noauth/result, and withhold the rest. Since the image and chosen style travel in the request body rather than as a resource id in the URL path, scoping happens at the operation level so the agent runs only the style-transfer calls you allow.