The DuupFlow API, step by step

The API gives you access, without going through the website, to the same processing as the DuupFlow dashboard:

• Duplicate an image into 1 to 20 unique copies (metadata, invisible pixel changes, device identity).
• Duplicate a video into 1 to 10 unique copies that look identical.
• Compress an image without ever making it heavier.
• Remove AI detection from an image, or enable it as an option on a duplication.

Typical uses: automate a multi-account publishing flow, plug DuupFlow into Make / n8n / Zapier (HTTP module), or let an AI agent (Claude Code, scripts) run duplications.

• API duplications are unlimited on Pro and Agency — no monthly quota, no per-call cost.
• Guests of a Pro or Agency team can create their own keys.
• No free API trial. The monthly Pro plan has no commitment (cancel anytime). A personalised demo is available through Telegram support.
• Up-to-date prices are always on the Pricing page.

1. 1Switch to the Pro or Agency plan.
2. 2In the dashboard, open Developers and click Generate a key.
3. 3Copy the key right away: it is shown only once.
4. 4Check it works with GET /me (example below).
5. 5Run your first duplication.

curl -H "Authorization: Bearer dflw_live_YOUR_KEY" \
  https://www.duupflow.com/api/v1/me

{ "user_id": "…", "plan": "pro", "api_version": "v1" }

• Every request sends the header Authorization: Bearer dflw_live_….
• Up to 3 keys per account (one per integration, for example).
• A deleted key is disabled immediately and cannot be recovered.
• If the subscription drops below Pro or a payment is overdue, the API answers 403 plan_required until it is resolved.

Response: 1 copy → the image file directly; several copies → a zip archive. File names are neutral (no mention of DuupFlow).

curl -X POST https://www.duupflow.com/api/v1/images/duplicate \
  -H "Authorization: Bearer dflw_live_YOUR_KEY" \
  -F "file=@photo.jpg" \
  -F "count=3" \
  -F "iphone_meta=1" \
  -o copies.zip

• visual: invisible micro-variations of brightness, contrast and colour.
• motion: subtle camera movement.
• metadata_technical: unique encoding parameters and technical metadata.
• pixel_magic: imperceptible noise for a unique fingerprint.

Original resolution and quality are preserved (4K included), and a copy is never heavier than the source. Vertical 9:16 is supported.

curl -X POST https://www.duupflow.com/api/v1/videos/duplicate \
  -H "Authorization: Bearer dflw_live_YOUR_KEY" \
  -F "file=@clip.mp4" \
  -F "count=3" \
  -F "packs=visual,motion,metadata_technical"

{
  "job_id": "3f1c…",
  "status": "queued",
  "poll_url": "https://www.duupflow.com/api/v1/jobs/3f1c…"
}

• status: queued → processing → completed or failed.
• progress: 0 to 100; message: current step.
• When completed, result.files lists every copy with its url.
• When failed, error explains why (unreadable file, too long…).
• If the server is momentarily busy, the job is retried automatically (it goes back to queued) — nothing to do on your side.

{
  "id": "3f1c…",
  "type": "videos.duplicate",
  "status": "completed",
  "progress": 100,
  "message": "Done",
  "result": {
    "files": [
      { "name": "…_c01_….mp4", "bytes": 8123456, "url": "https://www.duupflow.com/api/v1/jobs/3f1c…/files/…_c01_….mp4" }
    ]
  },
  "error": null,
  "created_at": "2026-10-29T10:00:00Z"
}

curl -H "Authorization: Bearer dflw_live_YOUR_KEY" \
  "https://www.duupflow.com/api/v1/jobs/JOB_ID/files/FILE_NAME" -o copy.mp4

import time, requests

API = "https://www.duupflow.com/api/v1"
H = {"Authorization": "Bearer dflw_live_YOUR_KEY"}

# 1) Start the job
with open("clip.mp4", "rb") as f:
    r = requests.post(f"{API}/videos/duplicate", headers=H,
                      files={"file": f}, data={"count": "3"})
r.raise_for_status()
job_id = r.json()["job_id"]

# 2) Poll until it's done
while True:
    job = requests.get(f"{API}/jobs/{job_id}", headers=H).json()
    if job["status"] in ("completed", "failed"):
        break
    time.sleep(8)

# 3) Download every copy
if job["status"] == "completed":
    for f in job["result"]["files"]:
        data = requests.get(f["url"], headers=H).content
        open(f["name"], "wb").write(data)
else:
    print("Failed:", job["error"])

const API = "https://www.duupflow.com/api/v1";
const H = { Authorization: "Bearer dflw_live_YOUR_KEY" };

const form = new FormData();
form.append("file", new Blob([await fs.promises.readFile("clip.mp4")]), "clip.mp4");
form.append("count", "3");

const { job_id } = await (await fetch(`${API}/videos/duplicate`, { method: "POST", headers: H, body: form })).json();

let job;
do {
  await new Promise((r) => setTimeout(r, 8000));
  job = await (await fetch(`${API}/jobs/${job_id}`, { headers: H })).json();
} while (job.status === "queued" || job.status === "processing");

for (const f of job.result?.files ?? []) {
  const buf = Buffer.from(await (await fetch(f.url, { headers: H })).arrayBuffer());
  await fs.promises.writeFile(f.name, buf);
}

In Make, n8n or Zapier: an HTTP "multipart/form-data" module to start the job, a loop with an 8 s delay on GET /jobs/:id, then one HTTP module per file to download it.

The result is never heavier than the original (otherwise the original is returned). Savings are reported in the X-DuupFlow-Saved-Percent, X-DuupFlow-Original-Bytes and X-DuupFlow-Output-Bytes headers. Video compression through the API is not available yet.

curl -X POST https://www.duupflow.com/api/v1/compress \
  -H "Authorization: Bearer dflw_live_YOUR_KEY" \
  -F "file=@photo.jpg" -F "level=strong" -D headers.txt -o compressed.jpg

Erases AI provenance metadata (C2PA, XMP…) and invisibly retouches the pixels (grain, micro-blur, colours), keeping format and resolution. jpg, png or webp image ≤ 25 MB. For videos, use the remove_ai_detection option of /videos/duplicate.

curl -X POST https://www.duupflow.com/api/v1/ai-detection \
  -H "Authorization: Bearer dflw_live_YOUR_KEY" \
  -F "file=@image.png" -o cleaned.png

Every error uses the same JSON format:

{ "error": { "code": "file_too_large", "message": "File exceeds the 150 MB limit." } }

• Poll a job every 5 to 10 seconds, not more often.
• On 429 or 5xx: retry with an increasing delay (backoff).
• Keep the right extension in the uploaded file name: it determines the format.
• Download results as soon as the job completes (they expire after 16 h).
• One key per integration: if something goes wrong, you revoke one without breaking the others.
• Every call produces different copies: running the same source again gives new variants.