બેકગ્રાઉન્ડ રિમૂવલ API: એક રિક્વેસ્ટ મોકલો, તૈયાર PNG મેળવો.

તમારી ઇમેજ મોકલો

POST /v1/remove ચાર માંથી કોઈપણ રીતે ઇમેજ લે છે. તેમાંથી એક મોકલો; જો કોઈ રિક્વેસ્ટમાં એકથી વધુ હોય, તો image_file ને પ્રાથમિકતા મળે છે, પછી image_file_b64, પછી image_url, પછી raw બૉડી. આ ઉદાહરણો તમારી કી REMOVEBG_API_KEY એન્વાયર્નમેન્ટ વેરિએબલમાંથી વાંચે છે (export REMOVEBG_API_KEY=… વડે સેટ કરો); ડબલ ક્વોટ્સ પર ધ્યાન આપો, તેનાથી શેલ વેલ્યૂ ભરી દે છે.

curl -X POST https://removebackground.dev/v1/remove \
  -H "x-api-key: $REMOVEBG_API_KEY" \
  -F 'image_file=@photo.jpg' \
  -o photo-no-bg.png

દરેક ઉદાહરણ બૉડીને ફાઇલમાં સેવ કરે છે. સ્ટેટસ 200 હોય ત્યારે જ તે ફાઇલ ઇમેજ હોય છે; જુઓ રિસ્પોન્સ સંભાળો.

રિસ્પોન્સ સંભાળો

મોટા ભાગની એકલ ઇમેજ એ જ રિસ્પોન્સમાં તૈયાર થઈને પાછી આવે છે. જ્યારે કતાર અસામાન્ય રીતે વ્યસ્ત હોય અને કોઈ ઇમેજને લગભગ 55 સેકન્ડથી વધુ સમય લાગે, ત્યારે તેના બદલે તમને job id સાથે 202 Accepted મળે છે. જોબ ચાલુ રહે છે: id વડે તેનું પરિણામ મેળવો. ઇમેજ ફરી મોકલવાથી બીજી જોબ શરૂ થશે અને બીજી ક્રેડિટ વપરાઈ શકે છે.

એક સંપૂર્ણ ઉદાહરણ

તૈયાર ઇમેજ, 202, નિષ્ફળ જોબ અને લોકલ સમય મર્યાદા સંભાળે છે. તે ઇમેજ એક જ વાર મોકલે છે અને ફક્ત સુરક્ષિત સ્ટેટસ ચેક જ ફરી અજમાવે છે.

import os
import time
import uuid

import requests

API = "https://removebackground.dev"
KEY = os.environ["REMOVEBG_API_KEY"]  # keep the key on your server
EXT = {"image/png": ".png", "image/jpeg": ".jpg", "image/webp": ".webp"}


def save(res, stem):
    """Save an image response with the right extension; raise on anything else."""
    mime = res.headers.get("Content-Type", "").split(";")[0]
    if res.status_code != 200 or mime not in EXT:
        raise RuntimeError(f"HTTP {res.status_code}: {res.text[:500]}")
    path = stem + EXT[mime]
    with open(path, "wb") as f:
        f.write(res.content)
    return path


def remove_background(image_url, stem="result", max_wait=300):
    s = requests.Session()
    s.headers["x-api-key"] = KEY

    # One key per image: resending with the same key returns the same job, never a second
    # charge, so this POST is safe to retry after a timeout or a dropped connection.
    idem = {"Idempotency-Key": str(uuid.uuid4())}
    for attempt in range(3):
        try:
            res = s.post(f"{API}/v1/remove", data={"image_url": image_url}, headers=idem, timeout=(10, 120))
            break
        except requests.ConnectionError:
            if attempt == 2:
                raise
            time.sleep(2)
    if res.status_code != 202:
        return save(res, stem)  # 200 = the image; anything else raises

    # 202: still processing. Wait for the same job; never send the image again.
    job_id = res.json()["id"]
    deadline = time.monotonic() + max_wait
    while time.monotonic() < deadline:
        time.sleep(2)  # the API sends Retry-After: 2
        res = s.get(f"{API}/v1/jobs/{job_id}/result", timeout=30)
        if res.status_code == 409 and res.json()["error"]["code"] == "not_ready":
            continue
        return save(res, stem)  # the image, or the job's own error
    raise TimeoutError(f"Job {job_id} is still running. Check it later at /v1/jobs/{job_id}.")


print(remove_background("https://example.com/photo.jpg"))

• તમારી સ્ક્રિપ્ટ અટકાવવાથી જોબ અટકતી નથી; તે હજી પૂર્ણ થઈ શકે છે અને ચાર્જ લાગી શકે છે. તેનું પરિણામ તમારા સ્ટુડિયોમાં દેખાશે.
• સમય મર્યાદા તમારી પસંદગી છે, અમારું વચન નથી; મોટા ભાગની ઇમેજ થોડી સેકન્ડમાં પૂર્ણ થાય છે.
• remove.bg-કૉમ્પેટિબલ એન્ડપૉઇન્ટ અલગ રીતે વર્તે છે: તે ક્યારેય 202 આપતો નથી (નીચે જુઓ).

બૅચ, શરૂથી અંત સુધી

1. સબમિટ કરો

curl -X POST https://removebackground.dev/v1/batch \
  -H "x-api-key: $REMOVEBG_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{ "image_urls": ["https://example.com/front.jpg", "https://example.com/back.jpg"], "format": "png", "size": "hd" }'

100 જેટલા પબ્લિક ઇમેજ URL, ઉપરાંત /v1/remove ના કોઈપણ વિકલ્પો. ઉપરના બે પ્લેસહોલ્ડર URL જો વાસ્તવિક ઇમેજ હોત તો વધુમાં વધુ 2 ક્રેડિટ લાગત. જવાબ તરત જ આવે છે:

202 Accepted
{
  "id": "3f6c2a9e-8d1b-4c7a-9e2f-5b8d0a1c4e77",
  "status": "queued",
  "total": 2,
  "invalid": 0,
  "duplicates": 0,
  "status_url": "https://removebackground.dev/v1/jobs/3f6c2a9e-8d1b-4c7a-9e2f-5b8d0a1c4e77"
}

invalid એવી એન્ટ્રી ગણે છે જે http(s) URL નથી અને duplicates પુનરાવર્તનો ગણે છે; બંને છોડી દેવાય છે અને ક્યારેય ચાર્જ થતાં નથી. id સેવ કરી રાખો: રીસ્ટાર્ટ પછી જોબ ફરી પકડવા માટે તે જ કામ લાગે છે.

2. જોબ પોલ કરો

done true ન થાય ત્યાં સુધી દર થોડી સેકન્ડે GET /v1/jobs/:id કરો. status queued થી processing માં જાય છે, પછી succeeded, partial (કેટલીક ઇમેજ નિષ્ફળ) અથવા failed તરીકે પૂર્ણ થાય છે. જે આઇટમ ફરી અજમાવાઈ રહી હોય તે retrying બતાવે છે.

{
  "id": "3f6c2a9e-…",
  "status": "partial",
  "done": true,
  "total": 2, "succeeded": 1, "failed": 1, "skipped": 0,
  "credits_charged": 1,
  "items": [
    { "position": 0, "input": "https://example.com/front.jpg", "status": "succeeded",
      "removal_id": "…", "width": 1600, "height": 1200, "format": "png",
      "result_url": "https://removebackground.dev/v1/jobs/3f6c2a9e-…/result?item=0" },
    { "position": 1, "input": "https://example.com/back.jpg", "status": "failed",
      "error": { "code": "fetch_failed", "message": "…" } }
  ]
}

3. દરેક પરિણામ ડાઉનલોડ કરો

દરેક સફળ આઇટમ માટે GET /v1/jobs/:id/result?item=N (અથવા તેનું result_url વાપરો). item એ શૂન્યથી શરૂ થતી position છે. અમાન્ય અને પુનરાવર્તિત URL દૂર થયા પછી પોઝિશન તમારી યાદીને અનુસરે છે, એટલે જ્યારે આમાંથી કોઈ ગણતરી 0 થી વધુ હોય, ત્યારે પરિણામો ઇન્ડેક્સથી નહીં પણ input થી મેળવો.

• done true થાય પછી બૅચ 3 ખુલ્લા બૅચની મર્યાદામાં ગણાતો નથી.
• API માં કોઈ cancel એન્ડપૉઇન્ટ, webhook કે ZIP ડાઉનલોડ નથી. બલ્ક પેજ પરથી શરૂ કરેલા બૅચ ત્યાં જ રદ કરી શકાય છે અથવા ZIP તરીકે ડાઉનલોડ કરી શકાય છે.

રીટ્રાય, ડુપ્લિકેટ અને બિલિંગ

Idempotency-Key મોકલો અને રીટ્રાયમાં બે વાર ચાર્જ નહીં લાગે. POST /v1/remove અથવા POST /v1/batch માં Idempotency-Key હેડર ઉમેરો (255 અક્ષર સુધીની કોઈપણ અનન્ય સ્ટ્રિંગ, જેમ કે UUID), દરેક ઇમેજ અથવા બૅચ માટે એક કી. જો તમે એ જ કી સાથે એ જ રિક્વેસ્ટ ફરી મોકલો, તો પહેલી રિક્વેસ્ટે બનાવેલી જોબ જ મળે છે, Idempotent-Replayed: true સાથે: કોઈ નવી જોબ નહીં અને કોઈ નવો ચાર્જ નહીં, ભલે પહેલી રિક્વેસ્ટ હજી ચાલુ હોય. અલગ ઇમેજ અથવા વિકલ્પો સાથે એ જ કી વાપરો તો જવાબ 409 idempotency_key_reused આવે છે. કી તમારા એકાઉન્ટની છે અને તેની મુદત પૂરી થતી નથી.

કી વગર, દરેક POST નવી જોબ બનાવે છે, અને સફળ થતી દરેક જોબ પર 1 ક્રેડિટ લાગે છે (remove.bg-કૉમ્પેટિબલ POST /v1.0/removebg માં કી નથી). જોબ વાંચવી (GET /v1/jobs/…) હંમેશાં મફત છે અને વારંવાર કરવી સુરક્ષિત છે.

IDEMPOTENCY_KEY=$(uuidgen)   # one per image; send the same one on every retry

curl -X POST https://removebackground.dev/v1/remove \
  -H "x-api-key: $REMOVEBG_API_KEY" \
  -H "Idempotency-Key: $IDEMPOTENCY_KEY" \
  -F 'image_file=@photo.jpg' \
  -o photo-no-bg.png

શેમાં ક્રેડિટ લાગે છે

ક્યારે ફરી પ્રયાસ કરવો

મર્યાદાઓ અને સ્ટોરેજ

પરિણામો કેટલો સમય રખાય છે

દરેક પરિણામ બન્યા પછી 48 કલાક સુધી તમારા એકાઉન્ટમાં ખાનગી રીતે સંગ્રહિત રહે છે, પછી ડિલીટ કરવામાં આવે છે. ત્યાં સુધી તમે તેને GET /v1/jobs/:id/result વડે અથવા તમારા સ્ટુડિયોમાંથી મફતમાં ફરી ડાઉનલોડ કરી શકો છો. તે પછી પરિણામની લિંકનો જવાબ 410 result_unavailable આવે છે; ઇમેજ ફરી પ્રોસેસ કરવી એ નવી જોબ છે. ઇમેજ ગયા પછી પણ જોબ સ્ટેટસના રેકોર્ડ વાંચી શકાય છે. અપલોડ કેવી રીતે સંભાળાય છે તે માટે ગોપનીયતા નીતિ જુઓ; અમે મૉડલને તાલીમ આપવા તમારી ઇમેજ વાપરતા નથી.

સુરક્ષા

તમારી API કી તમારા નિયંત્રણ હેઠળના સર્વર પર રાખો. તેને બ્રાઉઝર કોડ, મોબાઇલ ઍપ, પબ્લિક રિપોઝિટરી કે URL માં ન મૂકો. તમારા પોતાના યુઝર્સને બેકગ્રાઉન્ડ દૂર કરવા દેવા, તેમની ઇમેજ તમારા બૅકએન્ડ દ્વારા મોકલો, અને ત્યાં તમારું પોતાનું સાઇન-ઇન અને ખર્ચ મર્યાદા ઉમેરો.

• API માં CORS ચાલુ છે જેથી તે ટૂલ અને સર્વર-સાઇડ કોડમાંથી કામ કરે. તેનો અર્થ એ નથી કે વેબ પેજમાં કી મૂકવી સુરક્ષિત છે: ત્યાં કોઈપણ તેને વાંચી શકે છે.
• એકાઉન્ટ પરની બધી કી એ જ ક્રેડિટ બૅલેન્સ વાપરે છે. તમારા એકાઉન્ટ પેજ પર દરેક ઍપ અથવા એન્વાયર્નમેન્ટ માટે અલગ કી બનાવો, જેથી એકને રદ કરવાથી બીજી બંધ ન થાય.
• જો કોઈ કી લીક થાય, તો તરત જ એકાઉન્ટ પેજ પર તેને રદ કરો (તે તરત કામ કરતી બંધ થઈ જાય છે) અને નવી બનાવો. અમે દરેક કીનો ફક્ત હૅશ સંગ્રહિત કરીએ છીએ, એટલે તે તમને ફરી બતાવી શકતા નથી.

સમસ્યા નિવારણ