Så tar du bort bakgrunden från bilder med ett API

Att ta bort en bakgrund för hand tar några minuter per foto. Att göra det för varje produktuppladdning, profilbild eller miniatyrbild i din app kräver ett API för att ta bort bakgrund: en HTTP-förfrågan in, en färdig frilagd bild ut.

Den här guiden visar hur du integrerar ett på rätt sätt. Du får fungerande kod i cURL, Python och JavaScript, de utdataval som är värda att känna till, hur du hanterar långsamma bilder och bulkjobb, och hur du gör omförsök utan att betala två gånger. Exemplen använder removebackground.dev, vår systerprodukt, men mönstren gäller för alla leverantörer.

Så fungerar ett API för att ta bort bakgrund

Du skickar en bild, leverantören kör en segmenteringsmodell som skiljer motivet från bakgrunden, och du får tillbaka en ny bild. Kärnan i resultatet är en alfakanal: ett värde per pixel som anger hur mycket av varje pixel som hör till motivet. Helt täckande pixlar är motivet, helt transparenta pixlar är bakgrund, och värdena däremellan hanterar mjuka kanter som hår, päls och glas.

Utifrån den masken kan API:et returnera flera saker:

• En transparent frilagd bild, oftast en PNG eller WebP utan bakgrund
• Motivet mot en enfärgad bakgrund, utplattat till en JPG för marknadsplatser som kräver vit bakgrund
• Själva masken, en gråskalebild som du kan använda i ditt eget kompositionsflöde
• En beskuren eller skalad version, tajtad kring motivet och anpassad till en exakt storlek

Förfrågan är den enkla delen. En integration i produktion måste också hantera bilder som tar längre tid än vanligt, stora batcher, anropsgränser, omförsök och att hålla API-nyckeln borta från användarna.

Vad du ska titta efter i ett API för att ta bort bakgrund

Innan du skriver kod, kontrollera de här punkterna mot dina egna bilder och din egen trafik.

Steg 1: Skapa en API-nyckel

Registrera dig på removebackground.dev och skapa en nyckel på din kontosida. Nya konton får 50 gratis krediter, vilket räcker för att köra exemplen nedan och testa på dina egna bilder.

Spara nyckeln i en miljövariabel på din server:

export REMOVEBG_API_KEY="your_api_key"

Varje anrop skickar nyckeln i headern x-api-key, och varje anrop förbrukar det kontots krediter. Skapa en separat nyckel per app eller miljö så att du kan återkalla en utan att förstöra de andra.

Steg 2: Ta bort en bakgrund med cURL

Realtids-endpointen är POST https://removebackground.dev/v1/remove. Det snabbaste testet är en filuppladdning:

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

De flesta enskilda bilder kommer tillbaka färdiga i samma svar, oftast inom några sekunder, som en transparent PNG i full upplösning.

Endpointen tar emot bilden på fyra sätt. Skicka ett av dem:

Om en förfrågan innehåller flera vinner image_file, sedan image_file_b64, sedan image_url och sist den råa bodyn. Alternativ kan skickas som formulärfält, JSON-nycklar eller query string-värden.

En sak att se upp med: -o sparar bodyn oavsett status. Om nyckeln är fel eller bilden ogiltig är din "PNG" i själva verket ett JSON-fel. Kontrollera statuskoden innan du litar på filen.

Steg 3: Hantera 200, 202 och fel i Python

Ett API för att ta bort bakgrund kan inte lova att varje bild blir klar inom en HTTP-förfrågan. När kön är ovanligt full och en bild tar längre tid än ungefär 55 sekunder svarar removebackground.dev 202 Accepted med ett jobb-id i stället för bilden. Jobbet fortsätter att köra, och du hämtar resultatet med id:t.

Den viktigaste regeln: skicka aldrig bilden igen efter ett 202. Det startar ett andra jobb och kan kosta en andra kredit. Här är en komplett Python-version som skickar bilden en gång och bara upprepar de säkra anropen:

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"))

Den kräver Python 3 och requests (pip install requests). Två detaljer är lätta att missa. För det första stoppar du inte jobbet genom att stoppa skriptet: det kan ändå bli klart och debiteras, och resultatet dyker upp i ditt kontos Studio. För det andra svarar GET /v1/jobs/:id/result med 409 not_ready medan jobbet körs, så behandla det som "vänta", inte som ett fel.

Samma flöde i JavaScript (Node.js)

Samma flöde i Node.js 18 eller senare, med inbyggda fetch, FormData och Blob, och en lokal filuppladdning:

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:et accepterar CORS-förfrågningar, vilket är praktiskt för verktyg och tester. Det gör det ändå inte säkert att anropa det från en webbsida med din nyckel i. Mer om det i säkerhetsavsnittet nedan.

Steg 4: Styr utdatan

De flesta appar vill inte ha en rå frilagd bild i full upplösning. De vill ha en kvadratisk produktbild på vitt, en liten förhandsvisning eller en mask. Att be API:et om den färdiga filen sparar dig ett andra bearbetningssteg. Det här är alternativen för /v1/remove:

Varje alternativ kostar samma 1 kredit, och okända parametrar ignoreras tyst, så ett stavfel ger inget fel. En kvadratisk bild för en marknadsplats med produkten centrerad och 10 % marginal ser ut så här:

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

Ett lyckat svar innehåller också användbara headers. X-Credits-Remaining visar ditt saldo efter bilden. X-Matte-Confidence (0 till 1) anger hur tydlig masken är, och X-Matte-Ambiguous-Ratio anger andelen mjuka pixlar som hår, glas eller rörelseoskärpa. Om du loggar de två kan du flagga frilagda bilder med låg säkerhet för manuell granskning i stället för att kontrollera varje bild.

Steg 5: Bearbeta bilder i bulk

För katalogimporter och efterbearbetning ska du inte skicka hundratals enskilda förfrågningar. POST /v1/batch köar upp till 100 publika bild-URL:er som ett jobb, med samma alternativ som /v1/remove, och svarar 202 direkt:

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)

Några regler från dokumentationen att bygga runt:

• Jobbets status slutar som succeeded, partial (vissa bilder misslyckades) eller failed. Varje objekt i items har sin egen status och, vid fel, en felkod.
• Poster som inte är http(s)-URL:er och upprepade URL:er tas bort och debiteras aldrig. När någon av de siffrorna är över 0, matcha resultaten via input i stället för position.
• Du kan ha högst 3 öppna batchjobb per konto. En batch slutar räknas när done är true.
• Om krediterna tar slut mitt i en batch förblir färdiga bilder betalda och resten markeras som överhoppade med out_of_credits, utan kostnad.
• API:et har ingen avbryt-endpoint, inga webhooks och ingen ZIP-nedladdning, så polling är mönstret. Att läsa ett jobb är gratis och omfattas inte av anropsgränsen.

Föredrar du ett skript som du kan köra som det är? Guiden om batchbearbetning med Python går igenom ett komplett flöde från mapp till mapp.

Steg 6: Gör säkra omförsök och håll faktureringen förutsägbar

Nätverkstimeouter är orsaken till dubbeldebiteringar. Din klient ger upp, försöker igen, och nu finns det två jobb för en bild. Lösningen är en Idempotency-Key-header: valfri unik sträng på upp till 255 tecken, till exempel ett UUID, en per bild eller batch. Om du skickar samma förfrågan igen med samma nyckel får du jobbet som den första skapade, med headern Idempotent-Replayed: true, och ingen ny debitering. Att återanvända en nyckel för en annan bild ger svaret 409 idempotency_key_reused.

Faktureringen följer en enkel regel: 1 kredit när en bild lyckas, ingenting när den misslyckas. Förfrågningar som avvisas före bearbetning, oläsbara bilder och fel efter leverantörens egna omförsök är gratis, och att ladda ner ett färdigt resultat igen är gratis så länge det finns lagrat.

Gränser att designa runt

Om du behöver mer än 60 bilder i minuten är batch-endpointen lösningen: en förfrågan täcker upp till 100 bilder. Spara resultaten i din egen bucket så fort du laddat ner dem, eftersom resultatlänkarna svarar 410 efter 48 timmar. Enligt leverantörens dokumentation används uppladdade bilder inte för att träna modeller.

Byta från remove.bg:s API

remove.bg:s fristående webbplats och självbetjänings-API upphör den 1 december 2026 kl. 09:00 CET. API:et flyttar till Leonardo.Ai, vilket kräver att du ändrar din integration. Om du hellre vill slippa skriva om något har removebackground.dev en remove.bg-kompatibel endpoint, och bytet är en rad:

Du behåller samma X-Api-Key-header (med en removebackground.dev-nyckel), samma parameternamn, samma svarsheaders och samma felformat:

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

Känn till skillnaderna innan du byter:

• Inget 202. Den kompatibla endpointen väntar upp till 110 sekunder och returnerar sedan en 503-timeout. Jobbet fortsätter att köra och debiteras om det lyckas, så att blint försöka igen startar ett andra jobb.
• Inga idempotensnycklar på den här endpointen. Om du behöver säkra omförsök, gå över till /v1/remove med tiden.
• Vissa alternativ accepteras men ignoreras: type och type_level (motivet identifieras automatiskt), semitransparency och skuggalternativen (inga skuggor läggs till).
• Storlek kostar alltid 1 kredit, även full upplösning.

Migreringsguiden har kod före och efter för cURL, Python, Node och PHP, plus steg för Zapier, Make och n8n.

Håll din API-nyckel borta från klienten

Det här är misstaget som kostar riktiga pengar. Om din nyckel finns i en webbsida, en mobilapp, ett publikt repo eller en URL kan vem som helst läsa den och spendera dina krediter.

• Om dina egna användare ska kunna ta bort bakgrunder, skicka deras bilder via din backend och anropa API:et därifrån.
• Lägg till egen inloggning och utgiftsgränser per användare i den backenden.
• Använd en nyckel per app eller miljö.
• Om en nyckel läcker, återkalla den på kontosidan. Den slutar fungera direkt. Leverantören sparar bara en hash av varje nyckel, så skapa en ny i stället för att försöka återställa den gamla.

Exempel: frilagda bilder för YouTube-miniatyrer

Om du bygger verktyg för kreatörer är miniatyrbilder en självklar användning. En miniatyr ses oftast i litet format, så den frilagda bilden måste bära den: ett ansikte eller en produkt, stort, med tydlig kant mot en enkel bakgrund. YouTube rekommenderar 3840 x 2160 px i 16:9 med en minsta bredd på 640 px, och accepterar JPG eller PNG upp till 50 MB från en dator, men bara 2 MB från mobilappen.

På API-sidan är det ett enda anrop som returnerar en transparent PNG beskuren kring motivet, redo att läggas på en 16:9-yta:

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

Ta ett riktigt stillfoto för frilägningen i stället för att ta en bildruta från videon, eftersom bildrutor ofta har rörelseoskärpa, och håll nedre högra hörnet fritt eftersom YouTube visar videons längd där. Sidan om YouTube-miniatyrer täcker designdelen, och vår guide till dina första 1 000 prenumeranter förklarar varför miniatyrer betyder så mycket.

Ta bort bakgrunder från ChatGPT, Claude eller Cursor

Alla jobb kräver inte kod. removebackground.dev kör också en MCP-server på https://removebackground.dev/mcp, så du kan ladda upp ett foto i ChatGPT, Claude, Cursor, VS Code eller n8n och be om att få bakgrunden borttagen. I Claude Code är det ett kommando:

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

Skriv sedan /mcp i Claude Code för att logga in. Servern erbjuder tre verktyg: remove_background, get_job för borttagningar som tar längre än några sekunder, och check_credits. Varje bild kostar 1 kredit, samma som via API:et.

Vad det kostar

removebackground.dev är betala per användning utan prenumeration. Krediterna går aldrig ut, misslyckade bilder är gratis och nya konton får 50 gratis krediter. Via API:et motsvarar 1 kredit en lyckad bakgrundsborttagning i full upplösning.

Priserna är i USD, och oanvända krediter kan återbetalas inom 30 dagar. Volympriser över Scale finns på begäran. Se prissidan för aktuella detaljer.

Sammanfattning

En stabil integration för att ta bort bakgrund handlar om några vanor: håll nyckeln på din server, kontrollera statusen innan du sparar bodyn, vänta på jobbet i stället för att skicka igen efter ett 202, skicka en Idempotency-Key med varje POST och använd batch-endpointen för bulkarbete.

Den fullständiga referensen, inklusive OpenAPI 3.1-specifikationen, finns i API-dokumentationen. Om du arbetar med video lika väl som bilder använder vår jämförelse av API:er för YouTube-transkript och vår guide till tal till text-integration samma produktionsmönster för text.