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. Create an API key. Use the key manager below and save the key when it is shown.
3. Submit multipart media. Keep the returned taskId.
4. 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. 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 output unit first, then the package. For example, a 60-second 720p task uses 120 credits, while the same duration at 1080p uses 300 credits. 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

API-key limits can vary by environment or account. 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

Credits settle with the task; trial image identity remains visible

Generation credits are reserved with the task and failed processing tasks are refunded automatically. Reward credits do not count as a paid purchase.

Until the account has a PAID or COMPLETED credit order, every delivered trial image export contains DeepSwapAI.com and the account's 100% complete email address. Every character is visible: the email is never masked, shortened, hashed, or omitted. A trial image cannot be delivered without that complete-email watermark.

After a completed one-time credit purchase, future image exports are watermark-free. Existing trial files do not change retroactively. This statement applies only to image exports and does not describe GIF or video watermark behavior. Review the complete export policy and current credit pricing.

API questions

Current integration boundaries