Alpha Matte

import requests

def get_alpha_matte(image_base64, api_key):
    url = "https://api.withoutbg.com/v1.0/alpha-channel-base64"
    headers = {
        'Content-Type': 'application/json',
        'X-API-Key': api_key
    }
    data = {"image_base64": image_base64}

    try:
        response = requests.post(url, json=data, headers=headers)

        if response.status_code == 200:
            return response.json()
        else:
            raise ConnectionError(f"API request failed with status code {response.status_code}: {response.text}")
    except requests.RequestException as e:
        raise SystemError(f"An error occurred while making the API request: {e}")

# Example usage
api_key = "YOUR_API_KEY"
image_base64 = "/9j/4AAQSkZJRgABAQAAA..."  # Replace with your base64-encoded image string

try:
    result = get_alpha_matte(image_base64, api_key)
    print(result)
except Exception as e:
    print(f"An error occurred: {e}")

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import org.json.JSONObject;

public class ImageBackgroundRemoval {

    public static String getAlphaMatte(String imageBase64, String apiKey) throws Exception {
        String urlString = "https://api.withoutbg.com/v1.0/alpha-channel-base64";
        URL url = new URL(urlString);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();

        conn.setRequestMethod("POST");
        conn.setRequestProperty("Content-Type", "application/json");
        conn.setRequestProperty("X-API-Key", apiKey);
        conn.setDoOutput(true);

        JSONObject jsonInput = new JSONObject();
        jsonInput.put("image_base64", imageBase64);

        try(OutputStream os = conn.getOutputStream()) {
            byte[] input = jsonInput.toString().getBytes("utf-8");
            os.write(input, 0, input.length);
        }

        int responseCode = conn.getResponseCode();
        if (responseCode != HttpURLConnection.HTTP_OK) {
            throw new RuntimeException("Failed : HTTP error code : " + responseCode);
        }

        StringBuilder response = new StringBuilder();
        try(BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"))) {
            String responseLine = null;
            while ((responseLine = br.readLine()) != null) {
                response.append(responseLine.trim());
            }
        }

        conn.disconnect();

        JSONObject jsonResponse = new JSONObject(response.toString());
        return jsonResponse.getString("alpha_base64");
    }

    public static void main(String[] args) {
        try {
            String apiKey = "YOUR_API_KEY";
            String imageBase64 = "/9j/4AAQSkZJRgABAQAAA..."; // Replace with your base64-encoded image string
            String alphaMatte = getAlphaMatte(imageBase64, apiKey);
            System.out.println("Alpha Matte: " + alphaMatte);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

<<php

function getAlphaMatte($imageBase64, $apiKey) {
    $url = "https://api.withoutbg.com/v1.0/alpha-channel-base64";

    $headers = array(
        'Content-Type: application/json',
        'X-API-Key: ' . $apiKey,
    );

    $postData = json_encode(array('image_base64' => $imageBase64));

    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_POSTFIELDS, $postData);

    $response = curl_exec($ch);

    if (curl_errno($ch)) {
        throw new Exception(curl_error($ch));
    }

    $httpStatusCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    if ($httpStatusCode != 200) {
        throw new Exception("Response with Status Code: " . $httpStatusCode);
    }

    curl_close($ch);

    $decodedResponse = json_decode($response, true);
    return $decodedResponse['alpha_base64'];
}

// Example usage
$apiKey = 'YOUR_API_KEY';
$imageBase64 = '/9j/4AAQSkZJRgABAQAAA...'; // Replace with your base64-encoded image string

try {
    $alphaMatte = getAlphaMatte($imageBase64, $apiKey);
    echo "Alpha Matte: " . $alphaMatte;
} catch (Exception $e) {
    echo "An error occurred: " . $e->getMessage();
}
?>

use reqwest;
use serde::{Deserialize, Serialize};
use serde_json::json;
use std::error::Error;

#[derive(Serialize)]
struct RequestBody {
    image_base64: String,
}

#[derive(Deserialize)]
struct ResponseBody {
    alpha_base64: String,
}

async fn get_alpha_matte(image_base64: String, api_key: String) -> Result<String, Box<dyn Error>> {
    let client = reqwest::Client::new();
    let url = "https://api.withoutbg.com/v1.0/alpha-channel-base64";
    let body = RequestBody { image_base64 };

    let response = client.post(url)
        .header("Content-Type", "application/json")
        .header("X-API-Key", api_key)
        .json(&body)
        .send()
        .await?;

    if response.status().is_success() {
        let parsed_response = response.json::<ResponseBody>().await?;
        Ok(parsed_response.alpha_base64)
    } else {
        Err(format!("Error: HTTP {}", response.status()).into())
    }
}

// Example usage (this needs to be inside an async context or runtime)
#[tokio::main]
async fn main() {
    let api_key = "YOUR_API_KEY".to_string();
    let image_base64 = "/9j/4AAQSkZJRgABAQAAA...".to_string(); // Replace with your base64-encoded image string

    match get_alpha_matte(image_base64, api_key).await {
        Ok(alpha_matte) => println!("Alpha Matte: {}", alpha_matte),
        Err(e) => eprintln!("An error occurred: {}", e),
    }
}

const axios = require('axios');

async function getAlphaMatte(imageBase64, apiKey) {
    const url = "https://api.withoutbg.com/v1.0/alpha-channel-base64";
    const headers = {
        'Content-Type': 'application/json',
        'X-API-Key': apiKey
    };
    const data = {
        image_base64: imageBase64
    };

    try {
        const response = await axios.post(url, data, { headers: headers });

        if (response.status === 200) {
            return response.data;
        } else {
            throw new Error(`API request failed with status code ${response.status}`);
        }
    } catch (error) {
        throw new Error(`An error occurred while making the API request: ${error.message}`);
    }
}

// Example usage
const apiKey = "YOUR_API_KEY";
const imageBase64 = "/9j/4AAQSkZJRgABAQAAA..."; // Replace with your base64-encoded image string

getAlphaMatte(imageBase64, apiKey)
    .then(result => console.log(result))
    .catch(error => console.error(`An error occurred: ${error}`));

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
)

type RequestData struct {
    ImageBase64 string `json:"image_base64"`
}

type ResponseData struct {
    AlphaBase64 string `json:"alpha_base64"`
}

func getAlphaMatte(imageBase64 string, apiKey string) (string, error) {
    url := "https://api.withoutbg.com/v1.0/alpha-channel-base64"

    requestData := RequestData{
        ImageBase64: imageBase64,
    }

    jsonReq, err := json.Marshal(requestData)
    if err != nil {
        return "", err
    }

    req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonReq))
    if err != nil {
        return "", err
    }
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("X-API-Key", apiKey)

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return "", fmt.Errorf("API request failed with status code: %d", resp.StatusCode)
    }

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return "", err
    }

    var responseData ResponseData
    err = json.Unmarshal(body, &responseData)
    if err != nil {
        return "", err
    }

    return responseData.AlphaBase64, nil
}

func main() {
    apiKey := "YOUR_API_KEY"
    imageBase64 := "/9j/4AAQSkZJRgABAQAAA..." // Replace with your base64-encoded image string

    alphaMatte, err := getAlphaMatte(imageBase64, apiKey)
    if err != nil {
        fmt.Println("An error occurred:", err)
    } else {
        fmt.Println("Alpha Matte:", alphaMatte)
    }
}

curl --request POST \
  --url https://api.withoutbg.com/v1.0/alpha-channel-base64 \
  --header 'Content-Type: application/json' \
  --header 'X-API-Key: YOUR_API_KEY' \
  --data '{
  "image_base64": "/9j/4AAQSkZJRgABAQAA..."
}'

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

public class ImageProcessor
{
    private readonly HttpClient _httpClient;

    public ImageProcessor(HttpClient httpClient)
    {
        _httpClient = httpClient;
    }

    public async Task<string> GetAlphaMatteAsync(string imageBase64, string apiKey)
    {
        var url = "https://api.withoutbg.com/v1.0/alpha-channel-base64";
        var request = new HttpRequestMessage(HttpMethod.Post, url)
        {
            Content = new StringContent(JsonConvert.SerializeObject(new { image_base64 = imageBase64 }), Encoding.UTF8, "application/json")
        };
        request.Headers.Add("X-API-Key", apiKey);

        try
        {
            var response = await _httpClient.SendAsync(request);
            response.EnsureSuccessStatusCode();

            var responseContent = await response.Content.ReadAsStringAsync();
            var result = JsonConvert.DeserializeObject<dynamic>(responseContent);
            return result.alpha_base64;
        }
        catch (HttpRequestException e)
        {
            throw new Exception($"Error making API request: {e.Message}");
        }
    }
}

// Example usage
public async Task ExampleUsageAsync()
{
    var httpClient = new HttpClient();
    var imageProcessor = new ImageProcessor(httpClient);

    string apiKey = "YOUR_API_KEY";
    string imageBase64 = "/9j/4AAQSkZJRgABAQAAA...";  // Replace with your base64-encoded image string

    try
    {
        string alphaMatte = await imageProcessor.GetAlphaMatteAsync(imageBase64, apiKey);
        Console.WriteLine("Alpha Matte: " + alphaMatte);
    }
    catch (Exception e)
    {
        Console.WriteLine("An error occurred: " + e.Message);
    }
}

import requests

def get_alpha_matte_from_file(file_path, api_key):
    url = "https://api.withoutbg.com/v1.0/alpha-channel"
    headers = {'X-API-Key': api_key}
    files = {'file': open(file_path, 'rb')}

    try:
        response = requests.post(url, headers=headers, files=files)

        if response.status_code == 200:
            # To save the output as a file
            with open("alpha-matte.png", "wb") as out_file:
                out_file.write(response.content)
            return "Alpha matte saved as alpha-matte.png"

            # Alternatively, return the binary content
            # return response.content
        else:
            raise ConnectionError(f"API request failed with status code {response.status_code}: {response.text}")
    except requests.RequestException as e:
        raise SystemError(f"An error occurred while making the API request: {e}")
    finally:
        files['file'].close()

# Example usage
api_key = "YOUR_API_KEY"
file_path = "input-image.jpg"  # Replace with your image file path

try:
    result = get_alpha_matte_from_file(file_path, api_key)
    print(result)
except Exception as e:
    print(f"An error occurred: {e}")

import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.UUID;

public class ImageBackgroundRemoval {

    public static String getAlphaMatteFromFile(String filePath, String apiKey) throws IOException {
        String url = "https://api.withoutbg.com/v1.0/alpha-channel";
        String boundary = UUID.randomUUID().toString();
        byte[] boundaryBytes = ("--" + boundary + "\r\n").getBytes("UTF-8");
        byte[] finishBoundaryBytes = ("--" + boundary + "--").getBytes("UTF-8");
        HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection();

        // Set up the body
        connection.setRequestMethod("POST");
        connection.setDoOutput(true);
        connection.setRequestProperty("Content-Type", "multipart/form-data; boundary=" + boundary);
        connection.setRequestProperty("X-API-Key", apiKey);

        try (OutputStream output = connection.getOutputStream()) {
            // File
            output.write(boundaryBytes);
            String fileHeader = "Content-Disposition: form-data; name=\"file\"; filename=\"" + filePath + "\"\r\n" +
                                "Content-Type: application/octet-stream\r\n\r\n";
            output.write(fileHeader.getBytes("UTF-8"));
            Files.copy(Paths.get(filePath), output);
            output.write("\r\n".getBytes("UTF-8"));

            // End of multipart/form-data
            output.write(finishBoundaryBytes);
        }

        // Get the response
        int status = connection.getResponseCode();
        InputStream in = (status == HttpURLConnection.HTTP_OK) ? connection.getInputStream() : connection.getErrorStream();

        ByteArrayOutputStream result = new ByteArrayOutputStream();
        byte[] buffer = new byte[1024];
        for (int length; (length = in.read(buffer)) != -1; ) {
            result.write(buffer, 0, length);
        }

        // Save the output if successful
        if (status == HttpURLConnection.HTTP_OK) {
            try (FileOutputStream fos = new FileOutputStream("alpha-matte.png")) {
                fos.write(result.toByteArray());
            }
            return "Alpha matte saved as alpha-matte.png";
        } else {
            throw new IOException("API request failed with status code " + status + ": " + result.toString("UTF-8"));
        }
    }

    public static void main(String[] args) {
        String apiKey = "YOUR_API_KEY";
        String filePath = "input-image.jpg"; // Replace with your image file path

        try {
            String result = getAlphaMatteFromFile(filePath, apiKey);
            System.out.println(result);
        } catch (IOException e) {
            System.err.println("An error occurred: " + e.getMessage());
        }
    }
}

<?php

function getAlphaMatteFromFile($filePath, $apiKey) {
    $url = "https://api.withoutbg.com/v1.0/alpha-channel";

    // Initialize cURL session
    $curl = curl_init();

    // Set cURL options
    curl_setopt($curl, CURLOPT_URL, $url);
    curl_setopt($curl, CURLOPT_POST, true);
    curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($curl, CURLOPT_HTTPHEADER, array(
        "X-API-Key: " . $apiKey,
    ));

    // Define the file to be sent
    $cfile = curl_file_create($filePath);

    // Set POST fields
    $postData = array(
        'file' => $cfile,
    );
    curl_setopt($curl, CURLOPT_POSTFIELDS, $postData);

    // Execute cURL session and get the response
    $response = curl_exec($curl);
    $status_code = curl_getinfo($curl, CURLINFO_HTTP_CODE);

    // Close cURL session
    curl_close($curl);

    // Check the response status
    if ($status_code == 200) {
        // Save the output as a file
        file_put_contents("alpha-matte.png", $response);
        return "Alpha matte saved as alpha-matte.png";
    } else {
        throw new Exception("API request failed with status code $status_code: $response");
    }
}

// Example usage
$apiKey = "YOUR_API_KEY";
$filePath = "input-image.jpg"; // Replace with your image file path

try {
    $result = getAlphaMatteFromFile($filePath, $apiKey);
    echo $result;
} catch (Exception $e) {
    echo "An error occurred: " . $e->getMessage();
}

?>

use reqwest::Client;
use std::fs::File;
use std::io::Read;
use reqwest::multipart::{Form, Part};
use std::error::Error;

async fn get_alpha_matte_from_file(file_path: &str, api_key: &str) -> Result<(), Box<dyn Error>> {
    let url = "https://api.withoutbg.com/v1.0/alpha-channel";

    // Open the file
    let mut file = File::open(file_path)?;
    let mut file_contents = Vec::new();
    file.read_to_end(&mut file_contents)?;

    // Create the form
    let form = Form::new()
        .part("file", Part::bytes(file_contents).file_name(file_path.to_string()));

    // Make the request
    let client = Client::new();
    let res = client.post(url)
        .header("X-API-Key", api_key)
        .multipart(form)
        .send()
        .await?;

    if res.status().is_success() {
        let content = res.bytes().await?;
        std::fs::write("alpha-matte.png", &content)?;
        println!("Alpha matte saved as alpha-matte.png");
    } else {
        return Err(format!("API request failed with status code {}", res.status()).into());
    }

    Ok(())
}

#[tokio::main]
async fn main() {
    let api_key = "YOUR_API_KEY";
    let file_path = "input-image.jpg"; // Replace with your image file path

    if let Err(e) = get_alpha_matte_from_file(file_path, api_key).await {
        eprintln!("An error occurred: {}", e);
    }
}

const axios = require('axios');
const FormData = require('form-data');
const fs = require('fs');

async function getAlphaMatteFromFile(filePath, apiKey) {
  const url = 'https://api.withoutbg.com/v1.0/alpha-channel';
  const headers = {
    'X-API-Key': apiKey,
  };

  try {
    const formData = new FormData();
    formData.append('file', fs.createReadStream(filePath));

    const response = await axios.post(url, formData, {
      headers: {
        ...formData.getHeaders(),
        ...headers,
      },
      responseType: 'arraybuffer'
    });

    if (response.status === 200) {
      // To save the output as a file
      fs.writeFileSync('alpha-matte.png', response.data);
      return 'Alpha matte saved as alpha-matte.png';

      // Alternatively, return the binary content
      // return response.data;
    } else {
      throw new Error(`API request failed with status code ${response.status}: ${response.statusText}`);
    }
  } catch (error) {
    throw new Error(`An error occurred while making the API request: ${error.message}`);
  }
}

// Example usage
const apiKey = 'YOUR_API_KEY';
const filePath = 'input-image.jpg'; // Replace with your image file path

getAlphaMatteFromFile(filePath, apiKey)
  .then(result => console.log(result))
  .catch(error => console.error(`An error occurred: ${error}`));

package main

import (
    "bytes"
    "fmt"
    "io"
    "mime/multipart"
    "net/http"
    "os"
)

func getAlphaMatteFromFile(filePath string, apiKey string) (string, error) {
    url := "https://api.withoutbg.com/v1.0/alpha-channel"

    // Prepare the file to be uploaded
    file, err := os.Open(filePath)
    if err != nil {
        return "", err
    }
    defer file.Close()

    // Create a new multipart writer
    body := &bytes.Buffer{}
    writer := multipart.NewWriter(body)
    part, err := writer.CreateFormFile("file", filePath)
    if err != nil {
        return "", err
    }
    _, err = io.Copy(part, file)
    if err != nil {
        return "", err
    }
    writer.Close()

    // Create a new request with the multipart body
    req, err := http.NewRequest("POST", url, body)
    if err != nil {
        return "", err
    }
    req.Header.Set("Content-Type", writer.FormDataContentType())
    req.Header.Set("X-API-Key", apiKey)

    // Perform the request
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()

    // Handle the response
    if resp.StatusCode == http.StatusOK {
        // Save the response to a file
        outFile, err := os.Create("alpha-matte.png")
        if err != nil {
            return "", err
        }
        defer outFile.Close()

        _, err = io.Copy(outFile, resp.Body)
        if err != nil {
            return "", err
        }
        return "Alpha matte saved as alpha-matte.png", nil
    } else {
        return "", fmt.Errorf("API request failed with status code %d", resp.StatusCode)
    }
}

func main() {
    apiKey := "YOUR_API_KEY"
    filePath := "input-image.jpg" // Replace with your image file path

    result, err := getAlphaMatteFromFile(filePath, apiKey)
    if err != nil {
        fmt.Println("An error occurred:", err)
    } else {
        fmt.Println(result)
    }
}

curl --request POST \
  --url https://api.withoutbg.com/v1.0/alpha-channel \
  --header 'Content-Type: multipart/form-data' \
  --header 'X-API-Key: YOUR_API_KEY' \
  --form file=@/input-image.jpg

using System;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;

public class ImageBackgroundRemoval
{
    public static async Task<string> GetAlphaMatteFromFileAsync(string filePath, string apiKey)
    {
        var url = "https://api.withoutbg.com/v1.0/alpha-channel";
        using var httpClient = new HttpClient();
        using var form = new MultipartFormDataContent();
        using var fileStream = File.OpenRead(filePath);
        using var streamContent = new StreamContent(fileStream);
        using var fileContent = new ByteArrayContent(await streamContent.ReadAsByteArrayAsync());

        form.Add(fileContent, "file", Path.GetFileName(filePath));
        httpClient.DefaultRequestHeaders.Add("X-API-Key", apiKey);

        var response = await httpClient.PostAsync(url, form);

        if (response.IsSuccessStatusCode)
        {
            var responseBytes = await response.Content.ReadAsByteArrayAsync();
            await File.WriteAllBytesAsync("alpha-matte.png", responseBytes);
            return "Alpha matte saved as alpha-matte.png";
        }
        else
        {
            throw new Exception($"API request failed with status code {response.StatusCode}: {await response.Content.ReadAsStringAsync()}");
        }
    }

    public static async Task Main(string[] args)
    {
        string apiKey = "YOUR_API_KEY";
        string filePath = "input-image.jpg"; // Replace with your image file path

        try
        {
            var result = await GetAlphaMatteFromFileAsync(filePath, apiKey);
            Console.WriteLine(result);
        }
        catch (Exception e)
        {
            Console.WriteLine($"An error occurred: {e.Message}");
        }
    }
}