> ## Documentation Index
> Fetch the complete documentation index at: https://docs.cutbg.net/llms.txt
> Use this file to discover all available pages before exploring further.

# Background removal

> Call background endpoints with a managed token in Authorization header.

## Prerequisite

Before calling background endpoints, complete [Authentication and token flow](/en/guides/authentication).

## Supported endpoints

* `POST /api/v1/background/remove/url`
* `POST /api/v1/background/remove/base64`
* `POST /api/v1/background/remove/multipart`

All three endpoints require:

* Header `Authorization: <managed_token>`

## Remove by URL and decode in memory

Use one example below. Each snippet sends `POST /background/remove/url` and decodes `image_base64` in memory.

<Tabs>
  <Tab title="Python">
    ```python theme={null}
    import base64
    import requests
    from io import BytesIO
    from PIL import Image

    response = requests.post(
        "https://api.cutbg.net/api/v1/background/remove/url",
        headers={
            "Authorization": "<managed_token>",
            "Content-Type": "application/json"
        },
        json={"image_url": "https://example.com/photo.jpg"},
        timeout=30
    )
    response.raise_for_status()

    image_base64 = response.json()["image_base64"]
    image_bytes = base64.b64decode(image_base64)
    image = Image.open(BytesIO(image_bytes))  # in-memory PIL image
    ```
  </Tab>

  <Tab title="JavaScript (Node.js)">
    ```javascript theme={null}
    const response = await fetch("https://api.cutbg.net/api/v1/background/remove/url", {
      method: "POST",
      headers: {
        Authorization: "<managed_token>",
        "Content-Type": "application/json"
      },
      body: JSON.stringify({ image_url: "https://example.com/photo.jpg" })
    });

    if (!response.ok) {
      throw new Error(`HTTP ${response.status}`);
    }

    const { image_base64 } = await response.json();
    const imageBuffer = Buffer.from(image_base64, "base64"); // bytes in memory
    ```
  </Tab>

  <Tab title="TypeScript (Node.js)">
    ```typescript theme={null}
    type RemoveResponse = { image_base64: string };

    const response = await fetch("https://api.cutbg.net/api/v1/background/remove/url", {
      method: "POST",
      headers: {
        Authorization: "<managed_token>",
        "Content-Type": "application/json"
      },
      body: JSON.stringify({ image_url: "https://example.com/photo.jpg" })
    });

    if (!response.ok) {
      throw new Error(`HTTP ${response.status}`);
    }

    const data = (await response.json()) as RemoveResponse;
    const imageBuffer: Buffer = Buffer.from(data.image_base64, "base64"); // bytes in memory
    ```
  </Tab>

  <Tab title="Java">
    ```java theme={null}
    import java.net.URI;
    import java.net.http.HttpClient;
    import java.net.http.HttpRequest;
    import java.net.http.HttpResponse;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import java.util.Base64;
    import java.io.ByteArrayInputStream;
    import java.awt.image.BufferedImage;
    import javax.imageio.ImageIO;

    HttpClient client = HttpClient.newHttpClient();
    String payload = "{\"image_url\":\"https://example.com/photo.jpg\"}";

    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.cutbg.net/api/v1/background/remove/url"))
        .header("Authorization", "<managed_token>")
        .header("Content-Type", "application/json")
        .POST(HttpRequest.BodyPublishers.ofString(payload))
        .build();

    HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
    if (response.statusCode() != 200) {
      throw new RuntimeException("HTTP " + response.statusCode());
    }

    ObjectMapper mapper = new ObjectMapper();
    String imageBase64 = mapper.readTree(response.body()).get("image_base64").asText();
    byte[] imageBytes = Base64.getDecoder().decode(imageBase64);
    BufferedImage image = ImageIO.read(new ByteArrayInputStream(imageBytes)); // in memory
    ```
  </Tab>

  <Tab title="C#">
    ```csharp theme={null}
    using System;
    using System.Net.Http;
    using System.Text;
    using System.Text.Json;
    using System.IO;
    using System.Drawing;

    using var client = new HttpClient();
    using var request = new HttpRequestMessage(HttpMethod.Post, "https://api.cutbg.net/api/v1/background/remove/url");
    request.Headers.Add("Authorization", "<managed_token>");
    request.Content = new StringContent(
        JsonSerializer.Serialize(new { image_url = "https://example.com/photo.jpg" }),
        Encoding.UTF8,
        "application/json"
    );

    using var response = await client.SendAsync(request);
    response.EnsureSuccessStatusCode();

    string json = await response.Content.ReadAsStringAsync();
    using var document = JsonDocument.Parse(json);
    string imageBase64 = document.RootElement.GetProperty("image_base64").GetString()!;
    byte[] imageBytes = Convert.FromBase64String(imageBase64);
    using var stream = new MemoryStream(imageBytes);
    using var image = Image.FromStream(stream); // in-memory image
    ```
  </Tab>

  <Tab title="Go">
    ```go theme={null}
    import (
      "bytes"
      "encoding/base64"
      "encoding/json"
      "fmt"
      "image"
      "net/http"
    )

    payload, _ := json.Marshal(map[string]string{
      "image_url": "https://example.com/photo.jpg",
    })

    req, _ := http.NewRequest(http.MethodPost, "https://api.cutbg.net/api/v1/background/remove/url", bytes.NewReader(payload))
    req.Header.Set("Authorization", "<managed_token>")
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
      panic(err)
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
      panic(fmt.Sprintf("HTTP %d", resp.StatusCode))
    }

    var result struct {
      ImageBase64 string `json:"image_base64"`
    }
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
      panic(err)
    }

    imageBytes, err := base64.StdEncoding.DecodeString(result.ImageBase64)
    if err != nil {
      panic(err)
    }
    img, _, err := image.Decode(bytes.NewReader(imageBytes)) // in-memory image.Image
    if err != nil {
      panic(err)
    }
    _ = img
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
    <?php
    $apiUrl = "https://api.cutbg.net/api/v1/background/remove/url";
    $payload = json_encode([
        "image_url" => "https://example.com/photo.jpg"
    ]);

    $context = stream_context_create([
        "http" => [
            "method" => "POST",
            "header" => "Authorization: <managed_token>\r\nContent-Type: application/json\r\n",
            "content" => $payload
        ]
    ]);

    $responseJson = file_get_contents($apiUrl, false, $context);
    if ($responseJson === false) {
        throw new RuntimeException("Request failed");
    }

    $data = json_decode($responseJson, true);
    $imageBase64 = $data["image_base64"];
    $imageBytes = base64_decode($imageBase64, true);
    $image = imagecreatefromstring($imageBytes); // GD image resource/object in memory
    ```
  </Tab>

  <Tab title="Ruby">
    ```ruby theme={null}
    require "base64"
    require "json"
    require "net/http"
    require "uri"
    require "stringio"
    require "mini_magick"

    uri = URI("https://api.cutbg.net/api/v1/background/remove/url")
    request = Net::HTTP::Post.new(uri)
    request["Authorization"] = "<managed_token>"
    request["Content-Type"] = "application/json"
    request.body = { image_url: "https://example.com/photo.jpg" }.to_json

    response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
    raise "HTTP #{response.code}" unless response.code == "200"

    image_base64 = JSON.parse(response.body).fetch("image_base64")
    image_bytes = Base64.decode64(image_base64)
    image = MiniMagick::Image.read(StringIO.new(image_bytes)) # in-memory image
    ```
  </Tab>

  <Tab title="Kotlin (JVM)">
    ```kotlin theme={null}
    import java.net.URI
    import java.net.http.HttpClient
    import java.net.http.HttpRequest
    import java.net.http.HttpResponse
    import java.util.Base64
    import java.io.ByteArrayInputStream
    import java.awt.image.BufferedImage
    import javax.imageio.ImageIO
    import org.json.JSONObject

    val client = HttpClient.newHttpClient()
    val payload = """{"image_url":"https://example.com/photo.jpg"}"""

    val request = HttpRequest.newBuilder()
      .uri(URI.create("https://api.cutbg.net/api/v1/background/remove/url"))
      .header("Authorization", "<managed_token>")
      .header("Content-Type", "application/json")
      .POST(HttpRequest.BodyPublishers.ofString(payload))
      .build()

    val response = client.send(request, HttpResponse.BodyHandlers.ofString())
    check(response.statusCode() == 200) { "HTTP ${response.statusCode()}" }

    val imageBase64 = JSONObject(response.body()).getString("image_base64")
    val imageBytes = Base64.getDecoder().decode(imageBase64)
    val image: BufferedImage = ImageIO.read(ByteArrayInputStream(imageBytes)) // in memory
    ```
  </Tab>

  <Tab title="Swift (iOS)">
    ```swift theme={null}
    import UIKit

    let url = URL(string: "https://api.cutbg.net/api/v1/background/remove/url")!
    var request = URLRequest(url: url)
    request.httpMethod = "POST"
    request.setValue("<managed_token>", forHTTPHeaderField: "Authorization")
    request.setValue("application/json", forHTTPHeaderField: "Content-Type")
    request.httpBody = try JSONSerialization.data(
      withJSONObject: ["image_url": "https://example.com/photo.jpg"]
    )

    URLSession.shared.dataTask(with: request) { data, response, error in
      guard let data = data, error == nil else { return }
      guard let http = response as? HTTPURLResponse, http.statusCode == 200 else { return }
      guard
        let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
        let imageBase64 = json["image_base64"] as? String,
        let imageData = Data(base64Encoded: imageBase64),
        let image = UIImage(data: imageData)
      else { return }

      print(image.size) // in-memory UIImage
    }.resume()
    ```
  </Tab>
</Tabs>