API વડે ફોટાનું બેકગ્રાઉન્ડ કેવી રીતે દૂર કરવું

હાથથી ફોટાનું બેકગ્રાઉન્ડ દૂર કરવામાં દરેક ફોટા પર થોડી મિનિટો લાગે છે. તમારી એપમાં અપલોડ થતી દરેક પ્રોડક્ટ ઇમેજ, પ્રોફાઇલ ફોટો અથવા થંબનેલ માટે આ કરવું હોય તો બેકગ્રાઉન્ડ રિમૂવ API જોઈએ: એક HTTP રિક્વેસ્ટ મોકલો, અને તૈયાર cut-out પાછું મેળવો.

આ ગાઇડ બતાવે છે કે તેને યોગ્ય રીતે કેવી રીતે ઇન્ટિગ્રેટ કરવું. તમને ચાલતો cURL, Python અને JavaScript કોડ મળશે, જાણવા જેવા આઉટપુટ વિકલ્પો, ધીમા ફોટા અને બલ્ક જૉબ કેવી રીતે સંભાળવા, અને બે વાર ચૂકવ્યા વિના retry કેવી રીતે કરવું. ઉદાહરણોમાં અમારી સહયોગી પ્રોડક્ટ removebackground.dev વપરાઈ છે, પરંતુ આ પદ્ધતિઓ કોઈ પણ પ્રોવાઇડરને લાગુ પડે છે.

બેકગ્રાઉન્ડ રિમૂવ API કેવી રીતે કામ કરે છે

તમે એક ફોટો મોકલો છો, પ્રોવાઇડર segmentation મોડલ ચલાવે છે જે subjectને બેકગ્રાઉન્ડથી અલગ કરે છે, અને તમને નવો ફોટો પાછો મળે છે. પરિણામનો મુખ્ય ભાગ alpha channel છે: દરેક પિક્સેલની એક વેલ્યૂ, જે જણાવે છે કે તે પિક્સેલ કેટલો subjectનો ભાગ છે. સંપૂર્ણ અપારદર્શક પિક્સેલ subject છે, સંપૂર્ણ પારદર્શક પિક્સેલ બેકગ્રાઉન્ડ છે, અને વચ્ચેની વેલ્યૂ વાળ, રુવાંટી અને કાચ જેવી નરમ કિનારીઓ સંભાળે છે.

આ matteમાંથી API ઘણી વસ્તુઓ પાછી આપી શકે છે:

• પારદર્શક cut-out, સામાન્ય રીતે બેકગ્રાઉન્ડ દૂર કરેલું PNG અથવા WebP
• ઘન રંગ પર subject, જે માર્કેટપ્લેસને સફેદ બેકગ્રાઉન્ડ જોઈએ તેમના માટે JPGમાં flatten કરેલું
• mask પોતે, એક grayscale ઇમેજ જે તમે તમારી compositing pipelineમાં વાપરી શકો
• crop કે resize કરેલું વર્ઝન, subject પ્રમાણે trim કરીને ચોક્કસ સાઇઝમાં ફિટ કરેલું

રિક્વેસ્ટ મોકલવી સરળ ભાગ છે. પ્રોડક્શન ઇન્ટિગ્રેશને સામાન્ય કરતાં વધુ સમય લેતા ફોટા, મોટી બેચ, rate limits, retry અને API keyને યુઝર્સથી દૂર રાખવાનું પણ સંભાળવું પડે છે.

બેકગ્રાઉન્ડ રિમૂવ APIમાં શું જોવું

કોડ લખતા પહેલાં, આ મુદ્દાઓ તમારા પોતાના ફોટા અને ટ્રાફિક સામે તપાસો.

સ્ટેપ 1: API key બનાવો

removebackground.dev પર સાઇન અપ કરો અને તમારા એકાઉન્ટ પેજ પર key બનાવો. નવા એકાઉન્ટને 50 મફત ક્રેડિટ મળે છે, જે નીચેનાં ઉદાહરણો ચલાવવા અને તમારા પોતાના ફોટા પર ટેસ્ટ કરવા માટે પૂરતી છે.

keyને તમારા સર્વર પર environment variableમાં રાખો:

export REMOVEBG_API_KEY="your_api_key"

દરેક કૉલ x-api-key headerમાં key મોકલે છે, અને દરેક કૉલ તે એકાઉન્ટની ક્રેડિટ ખર્ચે છે. દરેક એપ કે 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-outsને માનવ સમીક્ષા માટે ચિહ્નિત કરી શકો.

સ્ટેપ 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થી વધુ હોય ત્યારે પરિણામોને સ્થાન પ્રમાણે નહીં પણ 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 અક્ષરો સુધીની કોઈ પણ અનન્ય string, જેમ કે 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 પાછી મેળવવાનો પ્રયાસ કરવાને બદલે નવી બનાવો.

ઉદાહરણ: YouTube થંબનેલ માટે cut-outs

જો તમે ક્રિએટર્સ માટે ટૂલ્સ બનાવો છો, તો થંબનેલ એક સ્પષ્ટ ઉપયોગ છે. થંબનેલ મોટા ભાગે નાની સાઇઝમાં જોવાય છે, એટલે 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ની સરખામણી અને સ્પીચ ટુ ટેક્સ્ટ ઇન્ટિગ્રેશન ગાઇડ ટેક્સ્ટ માટે એ જ પ્રોડક્શન પદ્ધતિઓ વાપરે છે.