Удаление фона

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

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

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

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

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

<?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

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

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

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