DeepSwapAI face swap API

Quick start

Submit a photo task, then poll it

1. Verify the account email. New generation requests require a verified account.
2. Complete one credit purchase. API keys require at least one order in PAID or COMPLETED state; reward and trial credits are web-only.
3. Create an API key. Use the key manager below and save the key when it is shown. Each account can hold at most three keys.
4. Submit multipart media. Keep the returned taskId.
5. Poll the same route. Stop at COMPLETED, FAILED, or CANCELLED.

1. Create the task

curl --request POST 'https://deepswapai.com/api/ai-tasks' \
  --header 'Authorization: Bearer $DEEPSWAPAI_API_KEY' \
  --form 'sourceImage=@identity.jpg' \
  --form 'targetImage=@scene.jpg'

Accepted response

{
  "taskId": "b6de3ea5-52ef-41a5-8a4b-276cf548dd9c",
  "status": "PENDING"
}

2. Poll the task

curl --get 'https://deepswapai.com/api/ai-tasks' \
  --header 'Authorization: Bearer $DEEPSWAPAI_API_KEY' \
  --data-urlencode 'taskId=b6de3ea5-52ef-41a5-8a4b-276cf548dd9c'

Current completion contract: polling is supported. Webhook callbacks and official language SDKs are not currently published.

Designing the orchestration around this contract? Use the face swap pipeline architecture guide for validation, task states, retries, settlement, observability, and retention boundaries.

Runnable server examples

Start with Node.js 20 or Python

Both examples create one photo task and poll the documented endpoint until a terminal state. Set DEEPSWAPAI_API_KEY, keep the key on the server, and replace the two local file names. Python requires the requests package; the Node.js example uses built-in web APIs.

import { openAsBlob } from 'node:fs';

const apiKey = process.env.DEEPSWAPAI_API_KEY;
if (!apiKey) throw new Error('Set DEEPSWAPAI_API_KEY first.');

async function apiRequest(path, options = {}) {
  const response = await fetch(`https://deepswapai.com${path}`, {
    ...options,
    headers: {
      Authorization: `Bearer ${apiKey}`,
      Accept: 'application/json',
      ...options.headers,
    },
  });
  const payload = await response.json();
  if (!response.ok) throw new Error(payload.error || 'API request failed');
  return payload;
}

const form = new FormData();
form.append('sourceImage', await openAsBlob('identity.jpg'), 'identity.jpg');
form.append('targetImage', await openAsBlob('scene.jpg'), 'scene.jpg');

const task = await apiRequest('/api/ai-tasks', { method: 'POST', body: form });
const terminal = new Set(['COMPLETED', 'FAILED', 'CANCELLED']);
let state = task;
while (!terminal.has(state.status)) {
  await new Promise((resolve) => setTimeout(resolve, 3000));
  state = await apiRequest(`/api/ai-tasks?taskId=${encodeURIComponent(task.taskId)}`);
}
console.log(state);

import os
import time
import requests

api_key = os.environ["DEEPSWAPAI_API_KEY"]
base_url = "https://deepswapai.com"
headers = {"Authorization": f"Bearer {api_key}", "Accept": "application/json"}

with open("identity.jpg", "rb") as source, open("scene.jpg", "rb") as target:
    response = requests.post(
        f"{base_url}/api/ai-tasks",
        headers=headers,
        files={"sourceImage": source, "targetImage": target},
        timeout=60,
    )
response.raise_for_status()
task = response.json()

terminal = {"COMPLETED", "FAILED", "CANCELLED"}
state = task
while state["status"] not in terminal:
    time.sleep(3)
    response = requests.get(
        f"{base_url}/api/ai-tasks",
        headers=headers,
        params={"taskId": task["taskId"]},
        timeout=30,
    )
    response.raise_for_status()
    state = response.json()
print(state)

Support boundary: these are plain HTTP examples and a Postman collection, not official SDKs. The OpenAPI file remains the machine-readable source of truth.

API key manager

Create and revoke keys without leaving the reference

Key management uses your signed-in DeepSwapAI account session. Creating a key requires a verified email and at least one PAID or COMPLETED credit order. Reward and trial credits cannot be automated through API keys. Each account can hold at most three keys; a new secret is displayed once. Store it in a server-side secret manager; never place it in browser code, mobile binaries, public repositories, logs, or support messages.

Workflow matrix

Choose the endpoint that matches the output unit

API pricing in USD

What does one face swap API generation cost?

The API uses the same one-time credit balance as the browser workflows. The USD figures below are credit-value equivalents: workflow credits multiplied by the selected package price and divided by that package's credits. Checkout sells complete packages, not individual generation requests, and the live credit-plan endpoint is the current price source.

How to use these figures: compare the task length first, then the package. A 60-second face-only task uses 60 credits at the fixed highest 1080p tier. Taxes, payment-currency conversion, and the final checkout total are not included in the equivalent. Use the exact task calculator and current package table before funding an integration.

Source-checked API contract landscape

Compare six published face swap API contracts

The table normalizes what each provider currently publishes about media inputs, request transport, multiple-face or batch behavior, completion, client assets, machine-readable contracts, pricing units, and output availability. It does not turn unlike credit, frame, second, resolution, face-count, or subscription units into a false price ranking.

Official sources and row notes

Open each provider record to inspect the exact first-party pages used. Product behavior and pricing can change after the row review date.

Task lifecycle

Keep the taskId and stop at a terminal state

Use the same API key to poll a task. A taskId can only be read by its owning account. Poll at a measured interval rather than in a tight loop. The response includes the task type, current status, credit cost, timestamps, parameters, and a result object when available.

Errors and limits

Handle status codes before retrying

Generation requests are limited to 6 per API key per minute, with a broader 20-request-per-minute API default. When the per-key limit is exhausted, the response supplies Retry-After, X-RateLimit-Limit, and X-RateLimit-Remaining. Separate account-level protection allows one active generation at a time.

Billing and delivered output

API access is paid-only; credits settle with each task

Creating or using an API key requires a verified email and at least one PAID or COMPLETED credit order. Reward and trial credits are web-only and cannot be automated through API keys. Existing keys on accounts without a qualifying order are blocked until the account pays.

Each account can hold no more than three API keys. Generation credits are reserved with the task and failed processing tasks are refunded automatically. Review current credit pricing before funding an integration.

Trial image exports show DeepSwapAI.com and the account's 100% complete email address; it is never masked, shortened, hashed, or omitted. This boundary applies only to image exports, and a completed purchase makes future image exports watermark-free.

API questions

Current integration boundaries