API से इमेज का बैकग्राउंड कैसे हटाएं

किसी फोटो का बैकग्राउंड हाथ से हटाने में हर फोटो पर कुछ मिनट लगते हैं। आपके ऐप में अपलोड होने वाली हर प्रोडक्ट इमेज, प्रोफ़ाइल फोटो या थंबनेल के लिए यही करना हो, तो बैकग्राउंड रिमूव API चाहिए: एक HTTP रिक्वेस्ट भेजें, और तैयार cut-out वापस पाएं।

यह गाइड बताती है कि इसे सही तरीके से कैसे इंटीग्रेट करें। आपको चलने वाला cURL, Python और JavaScript कोड मिलेगा, जानने लायक आउटपुट विकल्प, धीमी इमेज और बल्क जॉब को कैसे संभालें, और दो बार पैसे दिए बिना retry कैसे करें। उदाहरणों में हमारे सहयोगी प्रोडक्ट removebackground.dev का इस्तेमाल है, लेकिन ये तरीके किसी भी प्रोवाइडर पर लागू होते हैं।

बैकग्राउंड रिमूव API कैसे काम करती है

आप एक इमेज भेजते हैं, प्रोवाइडर एक segmentation मॉडल चलाता है जो subject को बैकग्राउंड से अलग करता है, और आपको एक नई इमेज वापस मिलती है। नतीजे का मूल हिस्सा alpha channel है: हर पिक्सेल की एक वैल्यू जो बताती है कि वह पिक्सेल कितना subject का हिस्सा है। पूरी तरह opaque पिक्सेल subject हैं, पूरी तरह ट्रांसपेरेंट पिक्सेल बैकग्राउंड हैं, और बीच की वैल्यू बाल, फ़र और कांच जैसे मुलायम किनारों को संभालती हैं।

इस matte से API कई चीज़ें लौटा सकती है:

• ट्रांसपेरेंट cut-out, आमतौर पर बैकग्राउंड हटाई गई PNG या WebP
• ठोस रंग पर subject, उन मार्केटप्लेस के लिए JPG में flatten किया गया जिन्हें सफ़ेद बैकग्राउंड चाहिए
• mask खुद, एक grayscale इमेज जिसे आप अपनी compositing pipeline में इस्तेमाल कर सकते हैं
• crop या resize किया गया वर्शन, subject के हिसाब से trim करके तय साइज़ में फ़िट किया गया

रिक्वेस्ट भेजना आसान हिस्सा है। प्रोडक्शन इंटीग्रेशन को उन इमेज से भी निपटना होता है जिनमें सामान्य से ज़्यादा समय लगता है, बड़े बैच, rate limit, retry, और API key को यूज़र्स से दूर रखना।

बैकग्राउंड रिमूव API में क्या देखें

कोड लिखने से पहले, इन बातों को अपनी इमेज और ट्रैफ़िक के हिसाब से जांचें।

स्टेप 1: API key बनाएं

removebackground.dev पर साइन अप करें और अपने अकाउंट पेज पर key बनाएं। नए अकाउंट को 50 मुफ़्त क्रेडिट मिलते हैं, जो नीचे दिए उदाहरण चलाने और अपनी इमेज पर टेस्ट करने के लिए काफ़ी हैं।

key को अपने सर्वर पर एक environment variable में रखें:

export REMOVEBG_API_KEY="your_api_key"

हर कॉल key को x-api-key header में भेजती है, और हर कॉल उस अकाउंट के क्रेडिट खर्च करती है। हर ऐप या environment के लिए अलग key बनाएं ताकि एक को revoke करने से बाकी न टूटें।

स्टेप 2: cURL से बैकग्राउंड हटाएं

real-time endpoint POST https://removebackground.dev/v1/remove है। सबसे तेज़ टेस्ट फ़ाइल अपलोड है:

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

ज़्यादातर अकेली इमेज उसी रिस्पॉन्स में तैयार होकर लौटती हैं, आमतौर पर कुछ सेकंड में, फ़ुल रेज़ोल्यूशन वाली ट्रांसपेरेंट PNG के रूप में।

endpoint इमेज को चार तरीकों से स्वीकार करता है। इनमें से एक भेजें:

अगर एक रिक्वेस्ट में कई तरीके हों, तो पहले image_file, फिर image_file_b64, फिर image_url, फिर raw body को प्राथमिकता मिलती है। विकल्प form fields, JSON keys या query-string वैल्यू के रूप में भेजे जा सकते हैं।

एक बात का ध्यान रखें: -o status चाहे जो हो, body सेव कर देता है। अगर key गलत है या इमेज अमान्य है, तो आपकी "PNG" असल में एक JSON एरर है। फ़ाइल पर भरोसा करने से पहले status code जांचें।

स्टेप 3: Python में 200, 202 और एरर संभालें

बैकग्राउंड रिमूव API यह वादा नहीं कर सकती कि हर इमेज एक HTTP रिक्वेस्ट में पूरी हो जाएगी। जब queue असामान्य रूप से व्यस्त हो और किसी इमेज में लगभग 55 सेकंड से ज़्यादा लगें, तो removebackground.dev इमेज की जगह एक जॉब id के साथ 202 Accepted लौटाता है। जॉब चलती रहती है, और आप id से नतीजा लाते हैं।

मुख्य नियम: 202 के बाद इमेज कभी दोबारा न भेजें। इससे दूसरी जॉब शुरू होती है और दूसरा क्रेडिट लग सकता है। यह रहा पूरा Python वर्शन जो इमेज एक बार भेजता है और सिर्फ़ सुरक्षित कॉल को retry करता है:

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: a retry with the same key returns the same job, never a second charge.
    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 is the image; anything else raises

    # 202: still processing. Wait for the same job.
    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 /v1/jobs/{job_id} later.")


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

इसके लिए Python 3 और requests (pip install requests) चाहिए। दो बातें आसानी से छूट जाती हैं। पहली, अपनी स्क्रिप्ट रोकने से जॉब नहीं रुकती: वह फिर भी पूरी होकर चार्ज हो सकती है, और नतीजा आपके अकाउंट के Studio में दिखता है। दूसरी, जॉब चलते समय GET /v1/jobs/:id/result 409 not_ready लौटाता है, इसलिए इसे विफलता नहीं, "रुको" समझें।

JavaScript (Node.js) में यही फ़्लो

Node.js 18 या उसके बाद के वर्शन में यही फ़्लो, built-in fetch, FormData और Blob के साथ, लोकल फ़ाइल अपलोड करते हुए:

import { readFile, writeFile } from "node:fs/promises"
import { randomUUID } from "node:crypto"

const API = "https://removebackground.dev"
const KEY = process.env.REMOVEBG_API_KEY // server side only
const EXT = { "image/png": ".png", "image/jpeg": ".jpg", "image/webp": ".webp" }
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))

async function save(res, stem) {
  const mime = (res.headers.get("content-type") || "").split(";")[0]
  if (res.status !== 200 || !EXT[mime]) {
    throw new Error("HTTP " + res.status + ": " + (await res.text()).slice(0, 500))
  }
  const path = stem + EXT[mime]
  await writeFile(path, Buffer.from(await res.arrayBuffer()))
  return path
}

export async function removeBackground(filePath, stem = "result", maxWaitMs = 300000) {
  const form = new FormData()
  form.append("image_file", new Blob([await readFile(filePath)]), "upload")
  form.append("format", "png")

  const res = await fetch(API + "/v1/remove", {
    method: "POST",
    // Reuse the same Idempotency-Key if you retry this POST.
    headers: { "x-api-key": KEY, "Idempotency-Key": randomUUID() },
    body: form,
  })
  if (res.status !== 202) return save(res, stem)

  const { id } = await res.json()
  const deadline = Date.now() + maxWaitMs
  while (Date.now() < deadline) {
    await sleep(2000)
    const result = await fetch(API + "/v1/jobs/" + id + "/result", {
      headers: { "x-api-key": KEY },
    })
    if (result.status === 409) {
      const body = await result.json()
      if (body.error && body.error.code === "not_ready") continue
      throw new Error("Job " + id + ": " + body.error.code)
    }
    return save(result, stem)
  }
  throw new Error("Job " + id + " is still running. Check /v1/jobs/" + id + " later.")
}

console.log(await removeBackground("photo.jpg"))

API CORS रिक्वेस्ट स्वीकार करती है, जो टूल और टेस्टिंग के लिए सुविधाजनक है। इसका मतलब यह नहीं कि अपनी key वाले वेब पेज से इसे कॉल करना सुरक्षित है। इस पर ज़्यादा नीचे सिक्योरिटी सेक्शन में।

स्टेप 4: आउटपुट नियंत्रित करें

ज़्यादातर ऐप्स को फ़ुल रेज़ोल्यूशन का कच्चा cut-out नहीं चाहिए। उन्हें सफ़ेद बैकग्राउंड पर चौकोर प्रोडक्ट इमेज, एक छोटा preview, या mask चाहिए। API से सीधे फ़ाइनल फ़ाइल मांगने से दूसरा प्रोसेसिंग स्टेप बचता है। /v1/remove के विकल्प ये हैं:

हर विकल्प का खर्च वही 1 क्रेडिट है, और अनजान पैरामीटर चुपचाप अनदेखे कर दिए जाते हैं, इसलिए typo से कोई एरर नहीं आएगा। बीच में प्रोडक्ट और 10% padding वाली चौकोर मार्केटप्लेस इमेज ऐसी दिखती है:

curl -X POST https://removebackground.dev/v1/remove \
  -H "x-api-key: $REMOVEBG_API_KEY" \
  -F 'image_file=@product.jpg' \
  -F 'crop=1:1' -F 'padding=10%' \
  -F 'width=1000' -F 'height=1000' \
  -F 'format=jpg' -F 'bg_color=white' \
  -o product-square.jpg

सफल रिस्पॉन्स के साथ कुछ उपयोगी headers भी आते हैं। X-Credits-Remaining इमेज के बाद आपका बैलेंस दिखाता है। X-Matte-Confidence (0 से 1) बताता है कि mask कितना निर्णायक है, और X-Matte-Ambiguous-Ratio बाल, कांच या motion blur जैसे मुलायम पिक्सेल का हिस्सा बताता है। इन दोनों को लॉग करने से आप हर इमेज जांचने के बजाय कम भरोसे वाले cut-out को इंसानी समीक्षा के लिए चिह्नित कर सकते हैं।

स्टेप 5: इमेज बल्क में प्रोसेस करें

कैटलॉग इम्पोर्ट और backfill के लिए सैकड़ों अकेली रिक्वेस्ट न भेजें। POST /v1/batch 100 तक पब्लिक इमेज URL को एक जॉब के रूप में queue करता है, /v1/remove वाले ही विकल्पों के साथ, और तुरंत 202 लौटाता है:

import os
import time
import uuid
import requests

API = "https://removebackground.dev"
s = requests.Session()
s.headers["x-api-key"] = os.environ["REMOVEBG_API_KEY"]

urls = ["https://example.com/front.jpg", "https://example.com/back.jpg"]

job = s.post(f"{API}/v1/batch",
             json={"image_urls": urls, "format": "png", "size": "hd"},
             headers={"Idempotency-Key": str(uuid.uuid4())}, timeout=30)
job.raise_for_status()
job_id = job.json()["id"]  # save it: it's how you resume after a restart

while True:
    time.sleep(3)
    status = s.get(f"{API}/v1/jobs/{job_id}", timeout=30).json()
    if status["done"]:
        break

print(status["status"], "credits charged:", status["credits_charged"])
for item in status["items"]:
    if item["status"] != "succeeded":
        print("failed:", item["input"], item.get("error"))
        continue
    img = s.get(item["result_url"], timeout=60)
    with open(f"out-{item['position']}.{item['format']}", "wb") as f:
        f.write(img.content)

डॉक्स के कुछ नियम जिनके हिसाब से डिज़ाइन करें:

• जॉब का status आख़िर में succeeded, partial (कुछ इमेज फ़ेल हुईं) या failed होता है। items में हर आइटम का अपना status होता है और विफलता पर एक एरर code।
• जो एंट्री http(s) URL नहीं हैं और दोहराए गए URL हटा दिए जाते हैं और कभी चार्ज नहीं होते। जब इनमें से कोई भी गिनती 0 से ऊपर हो, तो नतीजों को position के बजाय input से मिलाएं।
• एक अकाउंट में एक साथ ज़्यादा से ज़्यादा 3 batch जॉब खुली रह सकती हैं। done के true होते ही बैच गिनती में नहीं रहता।
• अगर बैच के बीच में क्रेडिट ख़त्म हो जाएं, तो पूरी हुई इमेज का भुगतान बना रहता है और बाकी को out_of_credits के साथ skipped चिह्नित किया जाता है, बिना किसी चार्ज के।
• API में cancel endpoint, webhooks या ZIP डाउनलोड नहीं है, इसलिए polling ही तरीका है। जॉब पढ़ना मुफ़्त है और उस पर rate limit नहीं है।

ऐसी स्क्रिप्ट चाहिए जिसे सीधे चला सकें? Python से बैच गाइड फ़ोल्डर से फ़ोल्डर तक का पूरा वर्कफ़्लो समझाती है।

स्टेप 6: सुरक्षित retry करें और बिलिंग का अनुमान लगाने लायक रखें

डबल चार्ज नेटवर्क timeout से आते हैं। आपका क्लाइंट हार मानता है, retry करता है, और अब एक इमेज के लिए दो जॉब मौजूद हैं। इसका हल Idempotency-Key header है: 255 अक्षरों तक की कोई भी यूनिक स्ट्रिंग, जैसे UUID, हर इमेज या बैच के लिए एक। अगर आप वही रिक्वेस्ट उसी key के साथ दोबारा भेजते हैं, तो आपको पहली रिक्वेस्ट से बनी जॉब मिलती है, Idempotent-Replayed: true header के साथ, और कोई नया चार्ज नहीं। किसी दूसरी इमेज के लिए key दोबारा इस्तेमाल करने पर 409 idempotency_key_reused मिलता है।

बिलिंग एक सीधे नियम पर चलती है: इमेज सफल होने पर 1 क्रेडिट, फ़ेल होने पर कुछ नहीं। प्रोसेसिंग से पहले अस्वीकार की गई रिक्वेस्ट, न पढ़ी जा सकने वाली इमेज और प्रोवाइडर के अपने retry के बाद की विफलताएं मुफ़्त हैं, और सेव रहने तक पूरा हुआ नतीजा दोबारा डाउनलोड करना भी मुफ़्त है।

डिज़ाइन करते समय ध्यान रखने वाली लिमिट

अगर आपको प्रति मिनट 60 से ज़्यादा इमेज चाहिए, तो batch endpoint ही जवाब है: एक रिक्वेस्ट में 100 इमेज तक आ जाती हैं। नतीजे डाउनलोड करते ही अपने bucket में सेव करें, क्योंकि 48 घंटे बाद नतीजों के लिंक 410 लौटाते हैं। प्रोवाइडर के डॉक्स के अनुसार, अपलोड की गई इमेज से मॉडल ट्रेन नहीं किए जाते।

remove.bg API से माइग्रेट करना

remove.bg की स्टैंडअलोन वेबसाइट और self-serve API 1 दिसंबर 2026, 09:00 CET को बंद हो रही हैं। इसकी API Leonardo.Ai पर जा रही है, जिसके लिए आपको अपना इंटीग्रेशन बदलना होगा। अगर आप कुछ भी दोबारा नहीं लिखना चाहते, तो removebackground.dev पर remove.bg-compatible endpoint है, और माइग्रेशन बस एक लाइन का है:

आप वही X-Api-Key header (removebackground.dev की key के साथ), वही पैरामीटर नाम, वही response headers और वही एरर format रखते हैं:

curl -H "X-Api-Key: $REMOVEBG_API_KEY" \
  -F 'image_file=@photo.jpg' -F 'size=auto' \
  -F 'crop=true' -F 'crop_margin=10%' -F 'bg_color=ffffff' \
  -o no-bg.jpg https://removebackground.dev/v1.0/removebg

स्विच करने से पहले अंतर जान लें:

• कोई 202 नहीं। compatible endpoint 110 सेकंड तक इंतज़ार करता है, फिर 503 timeout लौटाता है। जॉब चलती रहती है और सफल होने पर चार्ज होती है, इसलिए उस रिक्वेस्ट को आंख मूंदकर retry करने से दूसरी जॉब शुरू हो जाती है।
• इस endpoint पर idempotency keys नहीं हैं। अगर सुरक्षित retry चाहिए, तो धीरे-धीरे /v1/remove पर जाएं।
• कुछ विकल्प स्वीकार होते हैं लेकिन अनदेखे किए जाते हैं: type और type_level (subject अपने आप पहचाना जाता है), semitransparency, और shadow विकल्प (कोई shadow नहीं जोड़ी जाती)।
• साइज़ कोई भी हो, हमेशा 1 क्रेडिट, फ़ुल रेज़ोल्यूशन समेत।

माइग्रेशन गाइड में cURL, Python, Node और PHP के लिए पहले और बाद का कोड है, साथ ही Zapier, Make और n8n के स्टेप भी।

अपनी API key क्लाइंट से दूर रखें

यही वह गलती है जिसमें असली पैसा जाता है। अगर आपकी key किसी वेब पेज, मोबाइल ऐप, पब्लिक repository या URL में है, तो कोई भी उसे पढ़कर आपके क्रेडिट खर्च कर सकता है।

• अपने यूज़र्स को बैकग्राउंड हटाने देने के लिए, उनकी इमेज अपने बैकएंड से भेजें और API को वहीं से कॉल करें।
• उस बैकएंड में अपना साइन-इन और हर यूज़र के लिए खर्च की सीमा जोड़ें।
• हर ऐप या environment के लिए एक key इस्तेमाल करें।
• अगर key लीक हो जाए, तो उसे अकाउंट पेज पर revoke करें। वह तुरंत काम करना बंद कर देती है। प्रोवाइडर हर key का सिर्फ़ hash रखता है, इसलिए पुरानी key वापस पाने की कोशिश के बजाय नई key बनाएं।

उदाहरण: YouTube थंबनेल के लिए cut-out

अगर आप क्रिएटर्स के लिए टूल बनाते हैं, तो थंबनेल एक स्पष्ट उपयोग है। थंबनेल ज़्यादातर छोटे साइज़ में दिखता है, इसलिए cut-out को ही उसे संभालना होता है: एक चेहरा या प्रोडक्ट, बड़ा, सादे बैकग्राउंड पर साफ़ किनारे के साथ। YouTube 16:9 पर 3840 x 2160 px और कम से कम 640 px चौड़ाई की सलाह देता है, और कंप्यूटर से 50 MB तक JPG या PNG स्वीकार करता है, लेकिन मोबाइल ऐप से सिर्फ़ 2 MB।

API की तरफ़ बस एक कॉल है जो subject तक trim की गई ट्रांसपेरेंट PNG लौटाती है, जिसे सीधे 16:9 कैनवास पर रखा जा सकता है:

curl -X POST https://removebackground.dev/v1/remove \
  -H "x-api-key: $REMOVEBG_API_KEY" \
  -F 'image_file=@me.jpg' \
  -F 'crop=true' -F 'padding=5%' \
  -o me-cutout.png

cut-out के लिए वीडियो फ़्रेम लेने के बजाय एक स्थिर फोटो खींचें, क्योंकि फ़्रेम में अक्सर motion blur होता है, और नीचे दाएं कोने को खाली रखें क्योंकि YouTube वहां वीडियो की लंबाई दिखाता है। YouTube थंबनेल पेज डिज़ाइन वाला पहलू बताता है, और हमारी पहले 1,000 सब्सक्राइबर पाने वाली गाइड बताती है कि थंबनेल इतने अहम क्यों हैं।

ChatGPT, Claude या Cursor से बैकग्राउंड हटाना

हर काम के लिए कोड ज़रूरी नहीं है। removebackground.dev https://removebackground.dev/mcp पर एक MCP सर्वर भी चलाता है, ताकि आप ChatGPT, Claude, Cursor, VS Code या n8n में फोटो अपलोड करके बैकग्राउंड हटाने को कह सकें। Claude Code में यह एक कमांड है:

claude mcp add --transport http removebackground https://removebackground.dev/mcp

फिर साइन इन करने के लिए Claude Code में /mcp टाइप करें। सर्वर तीन टूल देता है: remove_background, कुछ सेकंड से ज़्यादा समय लेने वाले काम के लिए get_job, और check_credits। हर इमेज पर 1 क्रेडिट लगता है, API जितना ही।

इसकी कीमत

removebackground.dev बिना सब्सक्रिप्शन के pay-as-you-go है। क्रेडिट कभी expire नहीं होते, फ़ेल इमेज मुफ़्त हैं, और नए अकाउंट को 50 मुफ़्त क्रेडिट मिलते हैं। API के ज़रिए, 1 क्रेडिट फ़ुल रेज़ोल्यूशन पर एक सफल बैकग्राउंड रिमूवल है।

कीमतें USD में हैं, और बिना इस्तेमाल हुए क्रेडिट 30 दिनों के भीतर रिफ़ंड हो सकते हैं। Scale से ऊपर की वॉल्यूम कीमत अनुरोध पर उपलब्ध है। मौजूदा जानकारी के लिए प्राइसिंग पेज देखें।

निष्कर्ष

एक मज़बूत बैकग्राउंड रिमूवल इंटीग्रेशन कुछ आदतों पर टिका है: key अपने सर्वर पर रखें, body सेव करने से पहले status जांचें, 202 के बाद दोबारा भेजने के बजाय जॉब का इंतज़ार करें, हर POST के साथ Idempotency-Key भेजें, और बल्क काम के लिए batch endpoint इस्तेमाल करें।

OpenAPI 3.1 spec समेत पूरा रेफ़रेंस API डॉक्स में है। अगर आप इमेज के साथ वीडियो पर भी काम करते हैं, तो हमारी YouTube ट्रांसक्रिप्ट API की तुलना और स्पीच टू टेक्स्ट इंटीग्रेशन गाइड टेक्स्ट के लिए यही प्रोडक्शन तरीके इस्तेमाल करती हैं।