// Example posting a text URL:
(async function() {
    const resp = await fetch('https://api.deepai.org/api/text2img', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
            'api-key': 'YOUR_API_KEY'
        },
        body: JSON.stringify({
            text: "YOUR_TEXT_HERE",
        })
    });
    
    const data = await resp.json();
    console.log(data);
})()


// Example posting file picker input text (Browser only):
document.getElementById('yourFileInputId').addEventListener('change', async function() {
       const formData = new FormData();
       formData.append('text', 'YOUR_TEXT_HERE');

       const resp = await fetch('https://api.deepai.org/api/text2img', {
           method: 'POST',
           headers: {
               'api-key': 'YOUR_API_KEY'
           },
           body: formData
       });

       const data = await resp.json();
       console.log(data);
});

// Example posting a local text file (Node.js only):
const fs = require('fs');
(async function() {
       const formData = new FormData();
       formData.append('text', 'YOUR_TEXT_HERE');

       const resp = await fetch('https://api.deepai.org/api/text2img', {
           method: 'POST',
           headers: {
               'api-key': 'YOUR_API_KEY'
           },
           body: formData
       });

       const data = await resp.json();
       console.log(data);
});

// Example directly sending a text string:
(async function() {
    const resp = await fetch('https://api.deepai.org/api/text2img', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
            'api-key': 'YOUR_API_KEY'
        },
        body: JSON.stringify({
            text: "YOUR_TEXT_HERE",
        })
    });
    
    const data = await resp.json();
    console.log(data);
})()

# Example posting a text URL:

import requests
r = requests.post(
    "https://api.deepai.org/api/text2img",
    data={
        'text': 'YOUR_TEXT_HERE',
    },
    headers={'api-key': 'YOUR_API_KEY'}
)
print(r.json())


# Example posting a local text file:

import requests
r = requests.post(
    "https://api.deepai.org/api/text2img",
    data={
        'text': 'YOUR_TEXT_HERE',
    },
    headers={'api-key': 'YOUR_API_KEY'}
)
print(r.json())


# Example directly sending a text string:

import requests
r = requests.post(
    "https://api.deepai.org/api/text2img",
    data={
        'text': 'YOUR_TEXT_HERE',
    },
    headers={'api-key': 'YOUR_API_KEY'}
)
print(r.json())

# Example posting a text URL:

require 'rest_client'
r = RestClient::Request.execute(method: :post, url: 'https://api.deepai.org/api/text2img', timeout: 600,
    headers: {'api-key' => 'YOUR_API_KEY'},
    payload: {
        'text' => 'YOUR_TEXT_HERE',
    }
)
puts r


# Example posting a local text file:

require 'rest_client'
r = RestClient::Request.execute(method: :post, url: 'https://api.deepai.org/api/text2img', timeout: 600,
    headers: {'api-key' => 'YOUR_API_KEY'},
    payload: {
        'text' => 'YOUR_TEXT_HERE',
    }
)
puts r


# Example directly sending a text string:

require 'rest_client'
r = RestClient::Request.execute(method: :post, url: 'https://api.deepai.org/api/text2img', timeout: 600,
    headers: {'api-key' => 'YOUR_API_KEY'},
    payload: {
        'text' => 'YOUR_TEXT_HERE',
    }
)
puts r

// Example posting a text URL:
<?php
require 'vendor/autoload.php'; // Ensure you have Guzzle installed (composer require guzzlehttp/guzzle)

use GuzzleHttp\Client;
use GuzzleHttp\Psr7\Utils;

$client = new Client();
$headers = [
    'api-key' => 'YOUR_API_KEY'
];
$options = [
    'multipart' => [
        [
            'name'     => 'text',
            'contents' => 'YOUR_TEXT_HERE'
        ],
    ]
];
$request = new GuzzleHttp\Psr7\Request('POST', 'https://api.deepai.org/api/text2img', $headers);
try {
    $res = $client->sendAsync($request, $options)->wait();
    echo $res->getBody();
} catch (Exception $e) {
    echo 'Error: ' . $e->getMessage();
}
?>


// Example posting a local text file:
<?php
require 'vendor/autoload.php'; // Ensure you have Guzzle installed (composer require guzzlehttp/guzzle)

use GuzzleHttp\Client;
use GuzzleHttp\Psr7\Utils;

$client = new Client();
$headers = [
    'api-key' => 'YOUR_API_KEY'
];
$options = [
    'multipart' => [
        [
            'name'     => 'text',
            'contents' => 'YOUR_TEXT_HERE'
        ],
    ]
];
$request = new GuzzleHttp\Psr7\Request('POST', 'https://api.deepai.org/api/text2img', $headers);
try {
    $res = $client->sendAsync($request, $options)->wait();
    echo $res->getBody();
} catch (Exception $e) {
    echo 'Error: ' . $e->getMessage();
}
?>


// Example directly sending a text string:
<?php
require 'vendor/autoload.php'; // Ensure you have Guzzle installed (composer require guzzlehttp/guzzle)

use GuzzleHttp\Client;
use GuzzleHttp\Psr7\Utils;

$client = new Client();
$headers = [
    'api-key' => 'YOUR_API_KEY'
];
$options = [
    'multipart' => [
        [
            'name'     => 'text',
            'contents' => 'YOUR_TEXT_HERE'
        ],
    ]
];
$request = new GuzzleHttp\Psr7\Request('POST', 'https://api.deepai.org/api/text2img', $headers);
try {
    $res = $client->sendAsync($request, $options)->wait();
    echo $res->getBody();
} catch (Exception $e) {
    echo 'Error: ' . $e->getMessage();
}
?>

// Example posting a text URL:
package main

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

func main() {
    url := "https://api.deepai.org/api/text2img"
    payload := map[string]string{
        "text": "YOUR_TEXT_HERE",
    }
    jsonData, _ := json.Marshal(payload)

    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("api-key", "YOUR_API_KEY")

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

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}


// Example posting a local text file:
package main

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

func main() {
    url := "https://api.deepai.org/api/text2img"

    var b bytes.Buffer
    w := multipart.NewWriter(&b)

    w.WriteField("text", "YOUR_TEXT_HERE")

    if err := w.Close(); err != nil {
        panic(err)
    }

    req, _ := http.NewRequest("POST", url, &b)
    req.Header.Set("Content-Type", w.FormDataContentType())
    req.Header.Set("api-key", "YOUR_API_KEY")

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

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}


// Example directly sending a text string:
package main

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

func main() {
    url := "https://api.deepai.org/api/text2img"
    payload := map[string]string{
        "text": "YOUR_TEXT_HERE",
    }
    jsonData, _ := json.Marshal(payload)

    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("api-key", "YOUR_API_KEY")

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

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

// Example posting a text URL:
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();

        String json = "{" +
            "\"text\": \"YOUR_TEXT_HERE\"" +
            "}";

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.deepai.org/api/text2img"))
            .header("Content-Type", "application/json")
            .header("api-key", "YOUR_API_KEY")
            .POST(HttpRequest.BodyPublishers.ofString(json))
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}


// Example posting a local text file:
// Add to build.gradle: implementation 'com.squareup.okhttp3:okhttp:4.12.0'
import okhttp3.*;
import java.io.File;
import java.io.IOException;

public class Main {
    public static void main(String[] args) throws IOException {
        OkHttpClient client = new OkHttpClient();

        RequestBody requestBody = new MultipartBody.Builder()
            .setType(MultipartBody.FORM)
            .addFormDataPart("text", "YOUR_TEXT_HERE")
            .build();

        Request request = new Request.Builder()
            .url("https://api.deepai.org/api/text2img")
            .addHeader("api-key", "YOUR_API_KEY")
            .post(requestBody)
            .build();

        try (Response response = client.newCall(request).execute()) {
            System.out.println(response.body().string());
        }
    }
}


// Example directly sending a text string:
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();

        String json = "{" +
            "\"text\": \"YOUR_TEXT_HERE\"" +
            "}";

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.deepai.org/api/text2img"))
            .header("Content-Type", "application/json")
            .header("api-key", "YOUR_API_KEY")
            .POST(HttpRequest.BodyPublishers.ofString(json))
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

// Example posting a text URL:
using System;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        using var client = new HttpClient();
        client.DefaultRequestHeaders.Add("api-key", "YOUR_API_KEY");

        var payload = new
        {
            text = "YOUR_TEXT_HERE",
        };

        var json = JsonSerializer.Serialize(payload);
        var content = new StringContent(json, Encoding.UTF8, "application/json");

        var response = await client.PostAsync("https://api.deepai.org/api/text2img", content);
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}


// Example posting a local text file:
using System;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        using var client = new HttpClient();
        client.DefaultRequestHeaders.Add("api-key", "YOUR_API_KEY");

        using var form = new MultipartFormDataContent();

        form.Add(new StringContent("YOUR_TEXT_HERE"), "text");

        var response = await client.PostAsync("https://api.deepai.org/api/text2img", form);
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}


// Example directly sending a text string:
using System;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        using var client = new HttpClient();
        client.DefaultRequestHeaders.Add("api-key", "YOUR_API_KEY");

        var payload = new
        {
            text = "YOUR_TEXT_HERE",
        };

        var json = JsonSerializer.Serialize(payload);
        var content = new StringContent(json, Encoding.UTF8, "application/json");

        var response = await client.PostAsync("https://api.deepai.org/api/text2img", content);
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}

// Example posting a text URL:
import Foundation

let url = URL(string: "https://api.deepai.org/api/text2img")!
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.setValue("YOUR_API_KEY", forHTTPHeaderField: "api-key")

let payload: [String: Any] = [
    "text": "YOUR_TEXT_HERE",
]

request.httpBody = try? JSONSerialization.data(withJSONObject: payload)

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        print(String(data: data, encoding: .utf8) ?? "")
    }
}
task.resume()

// Keep the program running for async request
RunLoop.main.run()


// Example posting a local text file:
import Foundation

let url = URL(string: "https://api.deepai.org/api/text2img")!
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("YOUR_API_KEY", forHTTPHeaderField: "api-key")

let boundary = UUID().uuidString
request.setValue("multipart/form-data; boundary=\(boundary)", forHTTPHeaderField: "Content-Type")

var body = Data()

body.append("--\(boundary)\r\n".data(using: .utf8)!)
body.append("Content-Disposition: form-data; name=\"text\"\r\n\r\n".data(using: .utf8)!)
body.append("YOUR_TEXT_HERE".data(using: .utf8)!)
body.append("\r\n".data(using: .utf8)!)

body.append("--\(boundary)--\r\n".data(using: .utf8)!)
request.httpBody = body

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        print(String(data: data, encoding: .utf8) ?? "")
    }
}
task.resume()

RunLoop.main.run()


// Example directly sending a text string:
import Foundation

let url = URL(string: "https://api.deepai.org/api/text2img")!
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.setValue("YOUR_API_KEY", forHTTPHeaderField: "api-key")

let payload: [String: Any] = [
    "text": "YOUR_TEXT_HERE",
]

request.httpBody = try? JSONSerialization.data(withJSONObject: payload)

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        print(String(data: data, encoding: .utf8) ?? "")
    }
}
task.resume()

RunLoop.main.run()

// Example posting a text URL:
import java.net.URI
import java.net.http.HttpClient
import java.net.http.HttpRequest
import java.net.http.HttpResponse

fun main() {
    val client = HttpClient.newHttpClient()

    val json = """{
        "text": "YOUR_TEXT_HERE"
    }"""

    val request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.deepai.org/api/text2img"))
        .header("Content-Type", "application/json")
        .header("api-key", "YOUR_API_KEY")
        .POST(HttpRequest.BodyPublishers.ofString(json))
        .build()

    val response = client.send(request, HttpResponse.BodyHandlers.ofString())
    println(response.body())
}


// Example posting a local text file:
// Add to build.gradle.kts: implementation("com.squareup.okhttp3:okhttp:4.12.0")
import okhttp3.*
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.RequestBody.Companion.asRequestBody
import java.io.File

fun main() {
    val client = OkHttpClient()

    val requestBody = MultipartBody.Builder()
        .setType(MultipartBody.FORM)
        .addFormDataPart("text", "YOUR_TEXT_HERE")
        .build()

    val request = Request.Builder()
        .url("https://api.deepai.org/api/text2img")
        .addHeader("api-key", "YOUR_API_KEY")
        .post(requestBody)
        .build()

    client.newCall(request).execute().use { response ->
        println(response.body?.string())
    }
}


// Example directly sending a text string:
import java.net.URI
import java.net.http.HttpClient
import java.net.http.HttpRequest
import java.net.http.HttpResponse

fun main() {
    val client = HttpClient.newHttpClient()

    val json = """{
        "text": "YOUR_TEXT_HERE"
    }"""

    val request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.deepai.org/api/text2img"))
        .header("Content-Type", "application/json")
        .header("api-key", "YOUR_API_KEY")
        .POST(HttpRequest.BodyPublishers.ofString(json))
        .build()

    val response = client.send(request, HttpResponse.BodyHandlers.ofString())
    println(response.body())
}

// Example posting a text URL:
// Add to Cargo.toml: reqwest = { version = "0.11", features = ["json", "multipart"] }
// tokio = { version = "1", features = ["full"] }
// serde_json = "1"

use reqwest::header::HeaderMap;
use std::collections::HashMap;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();

    let mut headers = HeaderMap::new();
    headers.insert("api-key", "YOUR_API_KEY".parse()?);

    let mut payload = HashMap::new();
    payload.insert("text", "YOUR_TEXT_HERE");

    let response = client
        .post("https://api.deepai.org/api/text2img")
        .headers(headers)
        .json(&payload)
        .send()
        .await?;

    println!("{}", response.text().await?);
    Ok(())
}


// Example posting a local text file:
// Add to Cargo.toml: reqwest = { version = "0.11", features = ["json", "multipart"] }
// tokio = { version = "1", features = ["full"] }

use reqwest::multipart;
use std::fs;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();

    let form = multipart::Form::new()
        .text("text", "YOUR_TEXT_HERE");

    let response = client
        .post("https://api.deepai.org/api/text2img")
        .header("api-key", "YOUR_API_KEY")
        .multipart(form)
        .send()
        .await?;

    println!("{}", response.text().await?);
    Ok(())
}


// Example directly sending a text string:
// Add to Cargo.toml: reqwest = { version = "0.11", features = ["json", "multipart"] }
// tokio = { version = "1", features = ["full"] }
// serde_json = "1"

use reqwest::header::HeaderMap;
use std::collections::HashMap;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();

    let mut headers = HeaderMap::new();
    headers.insert("api-key", "YOUR_API_KEY".parse()?);

    let mut payload = HashMap::new();
    payload.insert("text", "YOUR_TEXT_HERE");

    let response = client
        .post("https://api.deepai.org/api/text2img")
        .headers(headers)
        .json(&payload)
        .send()
        .await?;

    println!("{}", response.text().await?);
    Ok(())
}

// Example posting a text URL:
interface ApiResponse {
    // Define your response type here
    [key: string]: unknown;
}

async function callApi(): Promise<ApiResponse> {
    const response = await fetch('https://api.deepai.org/api/text2img', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
            'api-key': 'YOUR_API_KEY'
        },
        body: JSON.stringify({
            text: 'YOUR_TEXT_HERE',
        })
    });

    const data: ApiResponse = await response.json();
    console.log(data);
    return data;
}

callApi();


// Example posting a local text file (Node.js with form-data package):
// npm install form-data
import * as fs from 'fs';
import FormData from 'form-data';

interface ApiResponse {
    [key: string]: unknown;
}

async function uploadFile(): Promise<ApiResponse> {
    const formData = new FormData();
    formData.append('text', 'YOUR_TEXT_HERE');

    const response = await fetch('https://api.deepai.org/api/text2img', {
        method: 'POST',
        headers: {
            ...formData.getHeaders(),
            'api-key': 'YOUR_API_KEY'
        },
        body: formData as unknown as BodyInit
    });

    const data: ApiResponse = await response.json();
    console.log(data);
    return data;
}

uploadFile();


// Example directly sending a text string:
interface ApiResponse {
    [key: string]: unknown;
}

async function callApi(): Promise<ApiResponse> {
    const response = await fetch('https://api.deepai.org/api/text2img', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
            'api-key': 'YOUR_API_KEY'
        },
        body: JSON.stringify({
            text: 'YOUR_TEXT_HERE',
        })
    });

    const data: ApiResponse = await response.json();
    console.log(data);
    return data;
}

callApi();

// Example posting a text URL:
// Add to pubspec.yaml: http: ^1.1.0

import 'dart:convert';
import 'package:http/http.dart' as http;

Future<void> main() async {
  final response = await http.post(
    Uri.parse('https://api.deepai.org/api/text2img'),
    headers: {
      'Content-Type': 'application/json',
      'api-key': 'YOUR_API_KEY',
    },
    body: jsonEncode({
      'text': 'YOUR_TEXT_HERE',
    }),
  );

  print(response.body);
}


// Example posting a local text file:
// Add to pubspec.yaml: http: ^1.1.0

import 'dart:io';
import 'package:http/http.dart' as http;

Future<void> main() async {
  var request = http.MultipartRequest(
    'POST',
    Uri.parse('https://api.deepai.org/api/text2img'),
  );

  request.headers['api-key'] = 'YOUR_API_KEY';

  request.fields['text'] = 'YOUR_TEXT_HERE';

  var response = await request.send();
  var responseBody = await response.stream.bytesToString();
  print(responseBody);
}


// Example directly sending a text string:
// Add to pubspec.yaml: http: ^1.1.0

import 'dart:convert';
import 'package:http/http.dart' as http;

Future<void> main() async {
  final response = await http.post(
    Uri.parse('https://api.deepai.org/api/text2img'),
    headers: {
      'Content-Type': 'application/json',
      'api-key': 'YOUR_API_KEY',
    },
    body: jsonEncode({
      'text': 'YOUR_TEXT_HERE',
    }),
  );

  print(response.body);
}

# Example posting a text URL:

$r = Invoke-WebRequest `
    -Uri https://api.deepai.org/api/text2img `
    -Method Post `
    -Form @{
         text='YOUR_TEXT_HERE' 
    } `
    -Headers @{
        'api-key'='YOUR_API_KEY' 
    } 
$r.Content

# Example posting a local text file:

$r = Invoke-WebRequest `
    -Uri https://api.deepai.org/api/text2img `
    -Method Post `
    -Form @{
         text='YOUR_TEXT_HERE' 
    } `
    -Headers @{
        'api-key'='YOUR_API_KEY' 
    } 
$r.Content

# Example directly sending a text string:

$r = Invoke-WebRequest `
    -Uri https://api.deepai.org/api/text2img `
    -Method Post `
    -Form @{
         text='YOUR_TEXT_HERE' 
    } `
    -Headers @{
        'api-key'='YOUR_API_KEY' 
    } 
$r.Content

// Example posting a image URL:
(async function() {
    const resp = await fetch('https://api.deepai.org/api/background-remover', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
            'api-key': 'YOUR_API_KEY'
        },
        body: JSON.stringify({
            image: "YOUR_IMAGE_URL",
        })
    });
    
    const data = await resp.json();
    console.log(data);
})()


// Example posting file picker input image (Browser only):
document.getElementById('yourFileInputId').addEventListener('change', async function() {
       const formData = new FormData();
       formData.append('image', this.files[0]);

       const resp = await fetch('https://api.deepai.org/api/background-remover', {
           method: 'POST',
           headers: {
               'api-key': 'YOUR_API_KEY'
           },
           body: formData
       });

       const data = await resp.json();
       console.log(data);
});

// Example posting a local image file (Node.js only):
const fs = require('fs');
(async function() {
       const formData = new FormData();
       const jpgFileStream = fs.createReadStream("/path/to/your/file.jpg");
       formData.append('image', jpgFileStream);

       const resp = await fetch('https://api.deepai.org/api/background-remover', {
           method: 'POST',
           headers: {
               'api-key': 'YOUR_API_KEY'
           },
           body: formData
       });

       const data = await resp.json();
       console.log(data);
});

# Example posting a image URL:

import requests
r = requests.post(
    "https://api.deepai.org/api/background-remover",
    data={
        'image': 'YOUR_IMAGE_URL',
    },
    headers={'api-key': 'YOUR_API_KEY'}
)
print(r.json())


# Example posting a local image file:

import requests
r = requests.post(
    "https://api.deepai.org/api/background-remover",
    files={
        'image': open('/path/to/your/file.jpg', 'rb'),
    },
    headers={'api-key': 'YOUR_API_KEY'}
)
print(r.json())

# Example posting a image URL:

require 'rest_client'
r = RestClient::Request.execute(method: :post, url: 'https://api.deepai.org/api/background-remover', timeout: 600,
    headers: {'api-key' => 'YOUR_API_KEY'},
    payload: {
        'image' => 'YOUR_IMAGE_URL',
    }
)
puts r


# Example posting a local image file:

require 'rest_client'
r = RestClient::Request.execute(method: :post, url: 'https://api.deepai.org/api/background-remover', timeout: 600,
    headers: {'api-key' => 'YOUR_API_KEY'},
    payload: {
        'image' => File.new('/path/to/your/file.jpg'),
    }
)
puts r

// Example posting a image URL:
<?php
require 'vendor/autoload.php'; // Ensure you have Guzzle installed (composer require guzzlehttp/guzzle)

use GuzzleHttp\Client;
use GuzzleHttp\Psr7\Utils;

$client = new Client();
$headers = [
    'api-key' => 'YOUR_API_KEY'
];
$options = [
    'multipart' => [
        [
            'name'     => 'image',
            'contents' => 'YOUR_IMAGE_URL'
        ],
    ]
];
$request = new GuzzleHttp\Psr7\Request('POST', 'https://api.deepai.org/api/background-remover', $headers);
try {
    $res = $client->sendAsync($request, $options)->wait();
    echo $res->getBody();
} catch (Exception $e) {
    echo 'Error: ' . $e->getMessage();
}
?>


// Example posting a local image file:
<?php
require 'vendor/autoload.php'; // Ensure you have Guzzle installed (composer require guzzlehttp/guzzle)

use GuzzleHttp\Client;
use GuzzleHttp\Psr7\Utils;

$client = new Client();
$headers = [
    'api-key' => 'YOUR_API_KEY'
];
$options = [
    'multipart' => [
        [
            'name'     => 'image',
            'contents' => Utils::tryFopen('/path/to/your/file.jpg', 'r')
        ],
    ]
];
$request = new GuzzleHttp\Psr7\Request('POST', 'https://api.deepai.org/api/background-remover', $headers);
try {
    $res = $client->sendAsync($request, $options)->wait();
    echo $res->getBody();
} catch (Exception $e) {
    echo 'Error: ' . $e->getMessage();
}
?>

// Example posting a image URL:
package main

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

func main() {
    url := "https://api.deepai.org/api/background-remover"
    payload := map[string]string{
        "image": "YOUR_IMAGE_URL",
    }
    jsonData, _ := json.Marshal(payload)

    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("api-key", "YOUR_API_KEY")

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

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}


// Example posting a local image file:
package main

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

func main() {
    url := "https://api.deepai.org/api/background-remover"

    var b bytes.Buffer
    w := multipart.NewWriter(&b)

    imageFile, _ := os.Open("/path/to/your/file.jpg")
    defer imageFile.Close()
    imageWriter, _ := w.CreateFormFile("image", "file.jpg")
    io.Copy(imageWriter, imageFile)

    if err := w.Close(); err != nil {
        panic(err)
    }

    req, _ := http.NewRequest("POST", url, &b)
    req.Header.Set("Content-Type", w.FormDataContentType())
    req.Header.Set("api-key", "YOUR_API_KEY")

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

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

// Example posting a image URL:
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();

        String json = "{" +
            "\"image\": \"YOUR_IMAGE_URL\"" +
            "}";

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.deepai.org/api/background-remover"))
            .header("Content-Type", "application/json")
            .header("api-key", "YOUR_API_KEY")
            .POST(HttpRequest.BodyPublishers.ofString(json))
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}


// Example posting a local image file:
// Add to build.gradle: implementation 'com.squareup.okhttp3:okhttp:4.12.0'
import okhttp3.*;
import java.io.File;
import java.io.IOException;

public class Main {
    public static void main(String[] args) throws IOException {
        OkHttpClient client = new OkHttpClient();

        RequestBody requestBody = new MultipartBody.Builder()
            .setType(MultipartBody.FORM)
            .addFormDataPart("image", "file.jpg", RequestBody.create(new File("/path/to/your/file.jpg"), MediaType.parse("application/octet-stream")))
            .build();

        Request request = new Request.Builder()
            .url("https://api.deepai.org/api/background-remover")
            .addHeader("api-key", "YOUR_API_KEY")
            .post(requestBody)
            .build();

        try (Response response = client.newCall(request).execute()) {
            System.out.println(response.body().string());
        }
    }
}

// Example posting a image URL:
using System;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        using var client = new HttpClient();
        client.DefaultRequestHeaders.Add("api-key", "YOUR_API_KEY");

        var payload = new
        {
            image = "YOUR_IMAGE_URL",
        };

        var json = JsonSerializer.Serialize(payload);
        var content = new StringContent(json, Encoding.UTF8, "application/json");

        var response = await client.PostAsync("https://api.deepai.org/api/background-remover", content);
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}


// Example posting a local image file:
using System;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        using var client = new HttpClient();
        client.DefaultRequestHeaders.Add("api-key", "YOUR_API_KEY");

        using var form = new MultipartFormDataContent();

        var imageStream = File.OpenRead("/path/to/your/file.jpg");
        form.Add(new StreamContent(imageStream), "image", "file.jpg");

        var response = await client.PostAsync("https://api.deepai.org/api/background-remover", form);
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}

// Example posting a image URL:
import Foundation

let url = URL(string: "https://api.deepai.org/api/background-remover")!
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.setValue("YOUR_API_KEY", forHTTPHeaderField: "api-key")

let payload: [String: Any] = [
    "image": "YOUR_IMAGE_URL",
]

request.httpBody = try? JSONSerialization.data(withJSONObject: payload)

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        print(String(data: data, encoding: .utf8) ?? "")
    }
}
task.resume()

// Keep the program running for async request
RunLoop.main.run()


// Example posting a local image file:
import Foundation

let url = URL(string: "https://api.deepai.org/api/background-remover")!
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("YOUR_API_KEY", forHTTPHeaderField: "api-key")

let boundary = UUID().uuidString
request.setValue("multipart/form-data; boundary=\(boundary)", forHTTPHeaderField: "Content-Type")

var body = Data()

let imageData = try! Data(contentsOf: URL(fileURLWithPath: "/path/to/your/file.jpg"))
body.append("--\(boundary)\r\n".data(using: .utf8)!)
body.append("Content-Disposition: form-data; name=\"image\"; filename=\"file.jpg\"\r\n".data(using: .utf8)!)
body.append("Content-Type: application/octet-stream\r\n\r\n".data(using: .utf8)!)
body.append(imageData)
body.append("\r\n".data(using: .utf8)!)

body.append("--\(boundary)--\r\n".data(using: .utf8)!)
request.httpBody = body

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        print(String(data: data, encoding: .utf8) ?? "")
    }
}
task.resume()

RunLoop.main.run()

// Example posting a image URL:
import java.net.URI
import java.net.http.HttpClient
import java.net.http.HttpRequest
import java.net.http.HttpResponse

fun main() {
    val client = HttpClient.newHttpClient()

    val json = """{
        "image": "YOUR_IMAGE_URL"
    }"""

    val request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.deepai.org/api/background-remover"))
        .header("Content-Type", "application/json")
        .header("api-key", "YOUR_API_KEY")
        .POST(HttpRequest.BodyPublishers.ofString(json))
        .build()

    val response = client.send(request, HttpResponse.BodyHandlers.ofString())
    println(response.body())
}


// Example posting a local image file:
// Add to build.gradle.kts: implementation("com.squareup.okhttp3:okhttp:4.12.0")
import okhttp3.*
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.RequestBody.Companion.asRequestBody
import java.io.File

fun main() {
    val client = OkHttpClient()

    val requestBody = MultipartBody.Builder()
        .setType(MultipartBody.FORM)
        .addFormDataPart("image", "file.jpg", File("/path/to/your/file.jpg").asRequestBody("application/octet-stream".toMediaType()))
        .build()

    val request = Request.Builder()
        .url("https://api.deepai.org/api/background-remover")
        .addHeader("api-key", "YOUR_API_KEY")
        .post(requestBody)
        .build()

    client.newCall(request).execute().use { response ->
        println(response.body?.string())
    }
}

// Example posting a image URL:
// Add to Cargo.toml: reqwest = { version = "0.11", features = ["json", "multipart"] }
// tokio = { version = "1", features = ["full"] }
// serde_json = "1"

use reqwest::header::HeaderMap;
use std::collections::HashMap;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();

    let mut headers = HeaderMap::new();
    headers.insert("api-key", "YOUR_API_KEY".parse()?);

    let mut payload = HashMap::new();
    payload.insert("image", "YOUR_IMAGE_URL");

    let response = client
        .post("https://api.deepai.org/api/background-remover")
        .headers(headers)
        .json(&payload)
        .send()
        .await?;

    println!("{}", response.text().await?);
    Ok(())
}


// Example posting a local image file:
// Add to Cargo.toml: reqwest = { version = "0.11", features = ["json", "multipart"] }
// tokio = { version = "1", features = ["full"] }

use reqwest::multipart;
use std::fs;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();

    let form = multipart::Form::new()
        .file("image", "/path/to/your/file.jpg")?;

    let response = client
        .post("https://api.deepai.org/api/background-remover")
        .header("api-key", "YOUR_API_KEY")
        .multipart(form)
        .send()
        .await?;

    println!("{}", response.text().await?);
    Ok(())
}