IMAGE API

convert

Convert an image from one format to another. Supported formats: jpeg, jpg, png, bmp, gif, avif, webp, ico, dds, tiff, tga, heic, svg

Credits Required: 2.0

PARAMETERS

NAME	TYPE	REQUIRED	DESCRIPTION	ADDITIONAL CREDITS PER ITEM	EXAMPLE
image	string	Yes	Base64 encoded image data (max 10MB)	None	base64_encoded_image_string_here
output_format	string	Yes	Target image format (e.g. png, jpg, webp, gif, bmp, avif, tiff, ico)	None	png

RESPONSE EXAMPLE

{
    "status": "success",
    "message": "Image converted successfully",
    "data":
    {
        "image": "base64_encoded_result_image"
    }
}

CODE EXAMPLES

<?php

$Curl = curl_init();

$PostFields = 
[
  'image' => 'base64_encoded_image_string_here',
  'output_format' => 'png',
];

curl_setopt_array(
    $Curl,
    [
        CURLOPT_URL => 'https://apicentral.dev/Image/convert',
        CURLOPT_POST => true,
        CURLOPT_POSTFIELDS => http_build_query($PostFields),
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT => 30,
        CURLOPT_HTTPHEADER => 
        [
            'Authorization: Bearer YOUR_API_TOKEN_HERE',
            'Content-Type: application/x-www-form-urlencoded'
        ]
    ]
);

$Response = curl_exec($Curl);
$Data = json_decode($Response, true);

if (curl_errno($Curl))
    $Error = curl_error($Curl);
else
{
    $status = $Data['status'];
    $message = $Data['message'];
    $data = $Data['data'] ?? null;
}

curl_close($Curl); // Omit in PHP 8 and above
?>


import requests
import json

url = 'https://apicentral.dev/Image/convert'
Headers = {'Authorization': 'Bearer YOUR_API_TOKEN_HERE'}
Data = 
{
  "image": "base64_encoded_image_string_here",
  "output_format": "png"
}

try:
    Response = requests.post(url, json=Data, headers=Headers)
    ResData = Response.json()
    status = ResData.get('status')
    message = ResData.get('message')
    data = ResData.get('data')
except Exception as e:
    error = str(e)


const axios = require('axios');

const Data = 
{
  "image": "base64_encoded_image_string_here",
  "output_format": "png"
};

axios.post(
    'https://apicentral.dev/Image/convert',
    Data,
    {
        headers: {'Authorization': 'Bearer YOUR_API_TOKEN_HERE'}
    }
)
.then(Response =>
{
    const status = Response.data.status;
    const message = Response.data.message;
    const data = Response.data.data;
})
.catch(Error => { const error = Error.message; });


import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.time.Duration;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;

public class ApiExample
{
    public static void main(String[] args)
    {
        String url = "https://apicentral.dev/Image/convert";
        String JsonPayload = """
        
        {
          "image": "base64_encoded_image_string_here",
          "output_format": "png"
        }
        """;

        HttpClient Client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest Request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer YOUR_API_TOKEN_HERE")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(JsonPayload))
            .build();

        try
        {
            HttpResponse Response = Client.send(Request, HttpResponse.BodyHandlers.ofString());
            JsonObject ResData = JsonParser.parseString(Response.body()).getAsJsonObject();
            String status = ResData.get("status").getAsString();
            String message = ResData.get("message").getAsString();
            Object data = ResData.has("data") ? ResData.get("data") : null;
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
}


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

public class ApiExample
{
    public static async Task Main()
    {
        using var Client = new HttpClient();
        Client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_TOKEN_HERE");

        var json_payload = @"
        {
          "image": "base64_encoded_image_string_here",
          "output_format": "png"
        }";
        var content = new StringContent(json_payload, Encoding.UTF8, "application/json");

        var Response = await Client.PostAsync("https://apicentral.dev/Image/convert", content);
        var Result = await Response.Content.ReadAsStringAsync();
        dynamic ResData = JsonConvert.DeserializeObject(Result);
        string status = ResData.status;
        string message = ResData.message;
        object data = ResData.data;
    }
}


package main

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

func main() {
        JsonPayload := []byte(`
        {
          "image": "base64_encoded_image_string_here",
          "output_format": "png"
        }`)

        Client := &http.Client{}
        Request, _ := http.NewRequest("POST", "https://apicentral.dev/Image/convert", bytes.NewBuffer(JsonPayload))
        Request.Header.Set("Authorization", "Bearer YOUR_API_TOKEN_HERE")
        Request.Header.Set("Content-Type", "application/json")

        Response, err := Client.Do(Request)

        if err != nil {
            fmt.Println("Error:", err)
            return
        }

        defer Response.Body.Close()

        Body, _ := io.ReadAll(Response.Body)

        var ResData map[string]interface{}
        json.Unmarshal(Body, &ResData)

        status := ResData["status"]
        message := ResData["message"]
        data := ResData["data"]

        fmt.Println(status, message, data)
}


require 'net/http'
require 'uri'
require 'json'

uri = URI('https://apicentral.dev/Image/convert')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_TOKEN_HERE'
request['Content-Type'] = 'application/json'
request.body = 
{
  "image": "base64_encoded_image_string_here",
  "output_format": "png"
}.to_json

response = http.request(request)
res_data = JSON.parse(response.body)

status = res_data['status']
message = res_data['message']
data = res_data['data']


import Foundation

let url = URL(string: "https://apicentral.dev/Image/convert")!
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer YOUR_API_TOKEN_HERE", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let JsonPayload = """

    {
      "image": "base64_encoded_image_string_here",
      "output_format": "png"
    }
""".data(using: .utf8)!
request.httpBody = JsonPayload

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let error = error {
        print("Error: \(error)")
        return
    }

    guard let data = data else { return }

    if let resData = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
        let status = resData["status"] as? String
        let message = resData["message"] as? String
        let data = resData["data"]
    }
}

task.resume()


import java.net.http.HttpClient
import java.net.http.HttpRequest
import java.net.http.HttpResponse
import java.net.URI
import java.time.Duration
import com.google.gson.JsonParser

fun main() {
        val url = "https://apicentral.dev/Image/convert"
        val jsonPayload = """
        
        {
          "image": "base64_encoded_image_string_here",
          "output_format": "png"
        }
        """.trimIndent()

        val client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build()

        val request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer YOUR_API_TOKEN_HERE")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(jsonPayload))
            .build()

        try {
            val response = client.send(request, HttpResponse.BodyHandlers.ofString())
            val resData = JsonParser.parseString(response.body()).asJsonObject
            val status = resData.get("status").asString
            val message = resData.get("message").asString
            val data = if (resData.has("data")) resData.get("data") else null
        } catch (e: Exception) {
            e.printStackTrace()
        }
}


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

void main() async {
    final url = Uri.parse('https://apicentral.dev/Image/convert');
    final headers = {
        'Authorization': 'Bearer YOUR_API_TOKEN_HERE',
        'Content-Type': 'application/json'
    };

    final body = jsonEncode(
    {
      "image": "base64_encoded_image_string_here",
      "output_format": "png"
    });

    try {
        final response = await http.post(url, headers: headers, body: body);
        final resData = jsonDecode(response.body);
        final status = resData['status'];
        final message = resData['message'];
        final data = resData['data'];
    } catch (e) {
        print('Error: $e');
    }
}


use reqwest::blocking::Client;
use serde_json::Value;

fn main() -> Result<(), Box> {
        let client = Client::new();

        let json_payload = r#"
        
        {
          "image": "base64_encoded_image_string_here",
          "output_format": "png"
        }
        "#;

        let response = client
            .post("https://apicentral.dev/Image/convert")
            .header("Authorization", "Bearer YOUR_API_TOKEN_HERE")
            .header("Content-Type", "application/json")
            .body(json_payload.to_string())
            .send()?;

        let res_data: Value = serde_json::from_str(&response.text()?)?;
        let status = &res_data["status"];
        let message = &res_data["message"];
        let data = &res_data["data"];

        println!("{} {} {:?}", status, message, data);

        Ok(())
}


curl -X POST 'https://apicentral.dev/Image/convert' \
    -H 'Authorization: Bearer YOUR_API_TOKEN_HERE' \
    -H 'Content-Type: application/json' \
    -d '
    {
      "image": "base64_encoded_image_string_here",
      "output_format": "png"
    }'

compress

Compress an image with a specified quality level (1-100)

Credits Required: 2.0

PARAMETERS

NAME	TYPE	REQUIRED	DESCRIPTION	ADDITIONAL CREDITS PER ITEM	EXAMPLE
image	string	Yes	Base64 encoded image data (max 10MB)	None	base64_encoded_image_string_here
quality	int	Yes	Compression quality from 1 (lowest) to 100 (highest)	None	75

RESPONSE EXAMPLE

{
    "status": "success",
    "message": "Image compressed successfully",
    "data":
    {
        "image": "base64_encoded_result_image"
    }
}

CODE EXAMPLES

<?php

$Curl = curl_init();

$PostFields = 
[
  'image' => 'base64_encoded_image_string_here',
  'quality' => 75,
];

curl_setopt_array(
    $Curl,
    [
        CURLOPT_URL => 'https://apicentral.dev/Image/compress',
        CURLOPT_POST => true,
        CURLOPT_POSTFIELDS => http_build_query($PostFields),
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT => 30,
        CURLOPT_HTTPHEADER => 
        [
            'Authorization: Bearer YOUR_API_TOKEN_HERE',
            'Content-Type: application/x-www-form-urlencoded'
        ]
    ]
);

$Response = curl_exec($Curl);
$Data = json_decode($Response, true);

if (curl_errno($Curl))
    $Error = curl_error($Curl);
else
{
    $status = $Data['status'];
    $message = $Data['message'];
    $data = $Data['data'] ?? null;
}

curl_close($Curl); // Omit in PHP 8 and above
?>


import requests
import json

url = 'https://apicentral.dev/Image/compress'
Headers = {'Authorization': 'Bearer YOUR_API_TOKEN_HERE'}
Data = 
{
  "image": "base64_encoded_image_string_here",
  "quality": 75
}

try:
    Response = requests.post(url, json=Data, headers=Headers)
    ResData = Response.json()
    status = ResData.get('status')
    message = ResData.get('message')
    data = ResData.get('data')
except Exception as e:
    error = str(e)


const axios = require('axios');

const Data = 
{
  "image": "base64_encoded_image_string_here",
  "quality": 75
};

axios.post(
    'https://apicentral.dev/Image/compress',
    Data,
    {
        headers: {'Authorization': 'Bearer YOUR_API_TOKEN_HERE'}
    }
)
.then(Response =>
{
    const status = Response.data.status;
    const message = Response.data.message;
    const data = Response.data.data;
})
.catch(Error => { const error = Error.message; });


import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.time.Duration;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;

public class ApiExample
{
    public static void main(String[] args)
    {
        String url = "https://apicentral.dev/Image/compress";
        String JsonPayload = """
        
        {
          "image": "base64_encoded_image_string_here",
          "quality": 75
        }
        """;

        HttpClient Client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest Request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer YOUR_API_TOKEN_HERE")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(JsonPayload))
            .build();

        try
        {
            HttpResponse Response = Client.send(Request, HttpResponse.BodyHandlers.ofString());
            JsonObject ResData = JsonParser.parseString(Response.body()).getAsJsonObject();
            String status = ResData.get("status").getAsString();
            String message = ResData.get("message").getAsString();
            Object data = ResData.has("data") ? ResData.get("data") : null;
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
}


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

public class ApiExample
{
    public static async Task Main()
    {
        using var Client = new HttpClient();
        Client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_TOKEN_HERE");

        var json_payload = @"
        {
          "image": "base64_encoded_image_string_here",
          "quality": 75
        }";
        var content = new StringContent(json_payload, Encoding.UTF8, "application/json");

        var Response = await Client.PostAsync("https://apicentral.dev/Image/compress", content);
        var Result = await Response.Content.ReadAsStringAsync();
        dynamic ResData = JsonConvert.DeserializeObject(Result);
        string status = ResData.status;
        string message = ResData.message;
        object data = ResData.data;
    }
}


package main

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

func main() {
        JsonPayload := []byte(`
        {
          "image": "base64_encoded_image_string_here",
          "quality": 75
        }`)

        Client := &http.Client{}
        Request, _ := http.NewRequest("POST", "https://apicentral.dev/Image/compress", bytes.NewBuffer(JsonPayload))
        Request.Header.Set("Authorization", "Bearer YOUR_API_TOKEN_HERE")
        Request.Header.Set("Content-Type", "application/json")

        Response, err := Client.Do(Request)

        if err != nil {
            fmt.Println("Error:", err)
            return
        }

        defer Response.Body.Close()

        Body, _ := io.ReadAll(Response.Body)

        var ResData map[string]interface{}
        json.Unmarshal(Body, &ResData)

        status := ResData["status"]
        message := ResData["message"]
        data := ResData["data"]

        fmt.Println(status, message, data)
}


require 'net/http'
require 'uri'
require 'json'

uri = URI('https://apicentral.dev/Image/compress')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_TOKEN_HERE'
request['Content-Type'] = 'application/json'
request.body = 
{
  "image": "base64_encoded_image_string_here",
  "quality": 75
}.to_json

response = http.request(request)
res_data = JSON.parse(response.body)

status = res_data['status']
message = res_data['message']
data = res_data['data']


import Foundation

let url = URL(string: "https://apicentral.dev/Image/compress")!
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer YOUR_API_TOKEN_HERE", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let JsonPayload = """

    {
      "image": "base64_encoded_image_string_here",
      "quality": 75
    }
""".data(using: .utf8)!
request.httpBody = JsonPayload

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let error = error {
        print("Error: \(error)")
        return
    }

    guard let data = data else { return }

    if let resData = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
        let status = resData["status"] as? String
        let message = resData["message"] as? String
        let data = resData["data"]
    }
}

task.resume()


import java.net.http.HttpClient
import java.net.http.HttpRequest
import java.net.http.HttpResponse
import java.net.URI
import java.time.Duration
import com.google.gson.JsonParser

fun main() {
        val url = "https://apicentral.dev/Image/compress"
        val jsonPayload = """
        
        {
          "image": "base64_encoded_image_string_here",
          "quality": 75
        }
        """.trimIndent()

        val client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build()

        val request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer YOUR_API_TOKEN_HERE")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(jsonPayload))
            .build()

        try {
            val response = client.send(request, HttpResponse.BodyHandlers.ofString())
            val resData = JsonParser.parseString(response.body()).asJsonObject
            val status = resData.get("status").asString
            val message = resData.get("message").asString
            val data = if (resData.has("data")) resData.get("data") else null
        } catch (e: Exception) {
            e.printStackTrace()
        }
}


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

void main() async {
    final url = Uri.parse('https://apicentral.dev/Image/compress');
    final headers = {
        'Authorization': 'Bearer YOUR_API_TOKEN_HERE',
        'Content-Type': 'application/json'
    };

    final body = jsonEncode(
    {
      "image": "base64_encoded_image_string_here",
      "quality": 75
    });

    try {
        final response = await http.post(url, headers: headers, body: body);
        final resData = jsonDecode(response.body);
        final status = resData['status'];
        final message = resData['message'];
        final data = resData['data'];
    } catch (e) {
        print('Error: $e');
    }
}


use reqwest::blocking::Client;
use serde_json::Value;

fn main() -> Result<(), Box> {
        let client = Client::new();

        let json_payload = r#"
        
        {
          "image": "base64_encoded_image_string_here",
          "quality": 75
        }
        "#;

        let response = client
            .post("https://apicentral.dev/Image/compress")
            .header("Authorization", "Bearer YOUR_API_TOKEN_HERE")
            .header("Content-Type", "application/json")
            .body(json_payload.to_string())
            .send()?;

        let res_data: Value = serde_json::from_str(&response.text()?)?;
        let status = &res_data["status"];
        let message = &res_data["message"];
        let data = &res_data["data"];

        println!("{} {} {:?}", status, message, data);

        Ok(())
}


curl -X POST 'https://apicentral.dev/Image/compress' \
    -H 'Authorization: Bearer YOUR_API_TOKEN_HERE' \
    -H 'Content-Type: application/json' \
    -d '
    {
      "image": "base64_encoded_image_string_here",
      "quality": 75
    }'

resize

Resize an image by percentage or exact dimensions (max 8192x8192 pixels)

Credits Required: 2.0

PARAMETERS

NAME	TYPE	REQUIRED	DESCRIPTION	ADDITIONAL CREDITS PER ITEM	EXAMPLE
image	string	Yes	Base64 encoded image data (max 10MB)	None	base64_encoded_image_string_here
resize_mode	int	Yes	Resize mode: 1 = by percentage, 2 = exact dimensions	None	2
resize_percentage	int	No	Resize percentage (1-500), used when resize_mode = 1	None	50
resize_width	int	No	Target width in pixels (1-8192), used when resize_mode = 2	None	800
resize_height	int	No	Target height in pixels (1-8192), used when resize_mode = 2	None	600

RESPONSE EXAMPLE

{
    "status": "success",
    "message": "Image resized successfully",
    "data":
    {
        "image": "base64_encoded_result_image"
    }
}

CODE EXAMPLES

<?php

$Curl = curl_init();

$PostFields = 
[
  'image' => 'base64_encoded_image_string_here',
  'resize_mode' => 2,
  'resize_percentage' => 50,
  'resize_width' => 800,
  'resize_height' => 600,
];

curl_setopt_array(
    $Curl,
    [
        CURLOPT_URL => 'https://apicentral.dev/Image/resize',
        CURLOPT_POST => true,
        CURLOPT_POSTFIELDS => http_build_query($PostFields),
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT => 30,
        CURLOPT_HTTPHEADER => 
        [
            'Authorization: Bearer YOUR_API_TOKEN_HERE',
            'Content-Type: application/x-www-form-urlencoded'
        ]
    ]
);

$Response = curl_exec($Curl);
$Data = json_decode($Response, true);

if (curl_errno($Curl))
    $Error = curl_error($Curl);
else
{
    $status = $Data['status'];
    $message = $Data['message'];
    $data = $Data['data'] ?? null;
}

curl_close($Curl); // Omit in PHP 8 and above
?>


import requests
import json

url = 'https://apicentral.dev/Image/resize'
Headers = {'Authorization': 'Bearer YOUR_API_TOKEN_HERE'}
Data = 
{
  "image": "base64_encoded_image_string_here",
  "resize_mode": 2,
  "resize_percentage": 50,
  "resize_width": 800,
  "resize_height": 600
}

try:
    Response = requests.post(url, json=Data, headers=Headers)
    ResData = Response.json()
    status = ResData.get('status')
    message = ResData.get('message')
    data = ResData.get('data')
except Exception as e:
    error = str(e)


const axios = require('axios');

const Data = 
{
  "image": "base64_encoded_image_string_here",
  "resize_mode": 2,
  "resize_percentage": 50,
  "resize_width": 800,
  "resize_height": 600
};

axios.post(
    'https://apicentral.dev/Image/resize',
    Data,
    {
        headers: {'Authorization': 'Bearer YOUR_API_TOKEN_HERE'}
    }
)
.then(Response =>
{
    const status = Response.data.status;
    const message = Response.data.message;
    const data = Response.data.data;
})
.catch(Error => { const error = Error.message; });


import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.time.Duration;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;

public class ApiExample
{
    public static void main(String[] args)
    {
        String url = "https://apicentral.dev/Image/resize";
        String JsonPayload = """
        
        {
          "image": "base64_encoded_image_string_here",
          "resize_mode": 2,
          "resize_percentage": 50,
          "resize_width": 800,
          "resize_height": 600
        }
        """;

        HttpClient Client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest Request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer YOUR_API_TOKEN_HERE")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(JsonPayload))
            .build();

        try
        {
            HttpResponse Response = Client.send(Request, HttpResponse.BodyHandlers.ofString());
            JsonObject ResData = JsonParser.parseString(Response.body()).getAsJsonObject();
            String status = ResData.get("status").getAsString();
            String message = ResData.get("message").getAsString();
            Object data = ResData.has("data") ? ResData.get("data") : null;
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
}


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

public class ApiExample
{
    public static async Task Main()
    {
        using var Client = new HttpClient();
        Client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_TOKEN_HERE");

        var json_payload = @"
        {
          "image": "base64_encoded_image_string_here",
          "resize_mode": 2,
          "resize_percentage": 50,
          "resize_width": 800,
          "resize_height": 600
        }";
        var content = new StringContent(json_payload, Encoding.UTF8, "application/json");

        var Response = await Client.PostAsync("https://apicentral.dev/Image/resize", content);
        var Result = await Response.Content.ReadAsStringAsync();
        dynamic ResData = JsonConvert.DeserializeObject(Result);
        string status = ResData.status;
        string message = ResData.message;
        object data = ResData.data;
    }
}


package main

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

func main() {
        JsonPayload := []byte(`
        {
          "image": "base64_encoded_image_string_here",
          "resize_mode": 2,
          "resize_percentage": 50,
          "resize_width": 800,
          "resize_height": 600
        }`)

        Client := &http.Client{}
        Request, _ := http.NewRequest("POST", "https://apicentral.dev/Image/resize", bytes.NewBuffer(JsonPayload))
        Request.Header.Set("Authorization", "Bearer YOUR_API_TOKEN_HERE")
        Request.Header.Set("Content-Type", "application/json")

        Response, err := Client.Do(Request)

        if err != nil {
            fmt.Println("Error:", err)
            return
        }

        defer Response.Body.Close()

        Body, _ := io.ReadAll(Response.Body)

        var ResData map[string]interface{}
        json.Unmarshal(Body, &ResData)

        status := ResData["status"]
        message := ResData["message"]
        data := ResData["data"]

        fmt.Println(status, message, data)
}


require 'net/http'
require 'uri'
require 'json'

uri = URI('https://apicentral.dev/Image/resize')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_TOKEN_HERE'
request['Content-Type'] = 'application/json'
request.body = 
{
  "image": "base64_encoded_image_string_here",
  "resize_mode": 2,
  "resize_percentage": 50,
  "resize_width": 800,
  "resize_height": 600
}.to_json

response = http.request(request)
res_data = JSON.parse(response.body)

status = res_data['status']
message = res_data['message']
data = res_data['data']


import Foundation

let url = URL(string: "https://apicentral.dev/Image/resize")!
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer YOUR_API_TOKEN_HERE", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let JsonPayload = """

    {
      "image": "base64_encoded_image_string_here",
      "resize_mode": 2,
      "resize_percentage": 50,
      "resize_width": 800,
      "resize_height": 600
    }
""".data(using: .utf8)!
request.httpBody = JsonPayload

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let error = error {
        print("Error: \(error)")
        return
    }

    guard let data = data else { return }

    if let resData = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
        let status = resData["status"] as? String
        let message = resData["message"] as? String
        let data = resData["data"]
    }
}

task.resume()


import java.net.http.HttpClient
import java.net.http.HttpRequest
import java.net.http.HttpResponse
import java.net.URI
import java.time.Duration
import com.google.gson.JsonParser

fun main() {
        val url = "https://apicentral.dev/Image/resize"
        val jsonPayload = """
        
        {
          "image": "base64_encoded_image_string_here",
          "resize_mode": 2,
          "resize_percentage": 50,
          "resize_width": 800,
          "resize_height": 600
        }
        """.trimIndent()

        val client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build()

        val request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer YOUR_API_TOKEN_HERE")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(jsonPayload))
            .build()

        try {
            val response = client.send(request, HttpResponse.BodyHandlers.ofString())
            val resData = JsonParser.parseString(response.body()).asJsonObject
            val status = resData.get("status").asString
            val message = resData.get("message").asString
            val data = if (resData.has("data")) resData.get("data") else null
        } catch (e: Exception) {
            e.printStackTrace()
        }
}


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

void main() async {
    final url = Uri.parse('https://apicentral.dev/Image/resize');
    final headers = {
        'Authorization': 'Bearer YOUR_API_TOKEN_HERE',
        'Content-Type': 'application/json'
    };

    final body = jsonEncode(
    {
      "image": "base64_encoded_image_string_here",
      "resize_mode": 2,
      "resize_percentage": 50,
      "resize_width": 800,
      "resize_height": 600
    });

    try {
        final response = await http.post(url, headers: headers, body: body);
        final resData = jsonDecode(response.body);
        final status = resData['status'];
        final message = resData['message'];
        final data = resData['data'];
    } catch (e) {
        print('Error: $e');
    }
}


use reqwest::blocking::Client;
use serde_json::Value;

fn main() -> Result<(), Box> {
        let client = Client::new();

        let json_payload = r#"
        
        {
          "image": "base64_encoded_image_string_here",
          "resize_mode": 2,
          "resize_percentage": 50,
          "resize_width": 800,
          "resize_height": 600
        }
        "#;

        let response = client
            .post("https://apicentral.dev/Image/resize")
            .header("Authorization", "Bearer YOUR_API_TOKEN_HERE")
            .header("Content-Type", "application/json")
            .body(json_payload.to_string())
            .send()?;

        let res_data: Value = serde_json::from_str(&response.text()?)?;
        let status = &res_data["status"];
        let message = &res_data["message"];
        let data = &res_data["data"];

        println!("{} {} {:?}", status, message, data);

        Ok(())
}


curl -X POST 'https://apicentral.dev/Image/resize' \
    -H 'Authorization: Bearer YOUR_API_TOKEN_HERE' \
    -H 'Content-Type: application/json' \
    -d '
    {
      "image": "base64_encoded_image_string_here",
      "resize_mode": 2,
      "resize_percentage": 50,
      "resize_width": 800,
      "resize_height": 600
    }'

rotate

Rotate an image by a specified number of degrees with an optional background color

Credits Required: 2.0

PARAMETERS

NAME	TYPE	REQUIRED	DESCRIPTION	ADDITIONAL CREDITS PER ITEM	EXAMPLE
image	string	Yes	Base64 encoded image data (max 10MB)	None	base64_encoded_image_string_here
degrees	float	Yes	Rotation angle in degrees (0-360)	None	90
background_color	string	No	Background color for exposed areas after rotation (hex format, e.g. #FFFFFF). Use "none" for transparent	None	none

RESPONSE EXAMPLE

{
    "status": "success",
    "message": "Image rotated successfully",
    "data":
    {
        "image": "base64_encoded_result_image"
    }
}

CODE EXAMPLES

<?php

$Curl = curl_init();

$PostFields = 
[
  'image' => 'base64_encoded_image_string_here',
  'degrees' => 90,
  'background_color' => 'none',
];

curl_setopt_array(
    $Curl,
    [
        CURLOPT_URL => 'https://apicentral.dev/Image/rotate',
        CURLOPT_POST => true,
        CURLOPT_POSTFIELDS => http_build_query($PostFields),
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT => 30,
        CURLOPT_HTTPHEADER => 
        [
            'Authorization: Bearer YOUR_API_TOKEN_HERE',
            'Content-Type: application/x-www-form-urlencoded'
        ]
    ]
);

$Response = curl_exec($Curl);
$Data = json_decode($Response, true);

if (curl_errno($Curl))
    $Error = curl_error($Curl);
else
{
    $status = $Data['status'];
    $message = $Data['message'];
    $data = $Data['data'] ?? null;
}

curl_close($Curl); // Omit in PHP 8 and above
?>


import requests
import json

url = 'https://apicentral.dev/Image/rotate'
Headers = {'Authorization': 'Bearer YOUR_API_TOKEN_HERE'}
Data = 
{
  "image": "base64_encoded_image_string_here",
  "degrees": 90,
  "background_color": "none"
}

try:
    Response = requests.post(url, json=Data, headers=Headers)
    ResData = Response.json()
    status = ResData.get('status')
    message = ResData.get('message')
    data = ResData.get('data')
except Exception as e:
    error = str(e)


const axios = require('axios');

const Data = 
{
  "image": "base64_encoded_image_string_here",
  "degrees": 90,
  "background_color": "none"
};

axios.post(
    'https://apicentral.dev/Image/rotate',
    Data,
    {
        headers: {'Authorization': 'Bearer YOUR_API_TOKEN_HERE'}
    }
)
.then(Response =>
{
    const status = Response.data.status;
    const message = Response.data.message;
    const data = Response.data.data;
})
.catch(Error => { const error = Error.message; });


import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.time.Duration;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;

public class ApiExample
{
    public static void main(String[] args)
    {
        String url = "https://apicentral.dev/Image/rotate";
        String JsonPayload = """
        
        {
          "image": "base64_encoded_image_string_here",
          "degrees": 90,
          "background_color": "none"
        }
        """;

        HttpClient Client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest Request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer YOUR_API_TOKEN_HERE")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(JsonPayload))
            .build();

        try
        {
            HttpResponse Response = Client.send(Request, HttpResponse.BodyHandlers.ofString());
            JsonObject ResData = JsonParser.parseString(Response.body()).getAsJsonObject();
            String status = ResData.get("status").getAsString();
            String message = ResData.get("message").getAsString();
            Object data = ResData.has("data") ? ResData.get("data") : null;
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
}


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

public class ApiExample
{
    public static async Task Main()
    {
        using var Client = new HttpClient();
        Client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_TOKEN_HERE");

        var json_payload = @"
        {
          "image": "base64_encoded_image_string_here",
          "degrees": 90,
          "background_color": "none"
        }";
        var content = new StringContent(json_payload, Encoding.UTF8, "application/json");

        var Response = await Client.PostAsync("https://apicentral.dev/Image/rotate", content);
        var Result = await Response.Content.ReadAsStringAsync();
        dynamic ResData = JsonConvert.DeserializeObject(Result);
        string status = ResData.status;
        string message = ResData.message;
        object data = ResData.data;
    }
}


package main

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

func main() {
        JsonPayload := []byte(`
        {
          "image": "base64_encoded_image_string_here",
          "degrees": 90,
          "background_color": "none"
        }`)

        Client := &http.Client{}
        Request, _ := http.NewRequest("POST", "https://apicentral.dev/Image/rotate", bytes.NewBuffer(JsonPayload))
        Request.Header.Set("Authorization", "Bearer YOUR_API_TOKEN_HERE")
        Request.Header.Set("Content-Type", "application/json")

        Response, err := Client.Do(Request)

        if err != nil {
            fmt.Println("Error:", err)
            return
        }

        defer Response.Body.Close()

        Body, _ := io.ReadAll(Response.Body)

        var ResData map[string]interface{}
        json.Unmarshal(Body, &ResData)

        status := ResData["status"]
        message := ResData["message"]
        data := ResData["data"]

        fmt.Println(status, message, data)
}


require 'net/http'
require 'uri'
require 'json'

uri = URI('https://apicentral.dev/Image/rotate')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_TOKEN_HERE'
request['Content-Type'] = 'application/json'
request.body = 
{
  "image": "base64_encoded_image_string_here",
  "degrees": 90,
  "background_color": "none"
}.to_json

response = http.request(request)
res_data = JSON.parse(response.body)

status = res_data['status']
message = res_data['message']
data = res_data['data']


import Foundation

let url = URL(string: "https://apicentral.dev/Image/rotate")!
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer YOUR_API_TOKEN_HERE", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let JsonPayload = """

    {
      "image": "base64_encoded_image_string_here",
      "degrees": 90,
      "background_color": "none"
    }
""".data(using: .utf8)!
request.httpBody = JsonPayload

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let error = error {
        print("Error: \(error)")
        return
    }

    guard let data = data else { return }

    if let resData = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
        let status = resData["status"] as? String
        let message = resData["message"] as? String
        let data = resData["data"]
    }
}

task.resume()


import java.net.http.HttpClient
import java.net.http.HttpRequest
import java.net.http.HttpResponse
import java.net.URI
import java.time.Duration
import com.google.gson.JsonParser

fun main() {
        val url = "https://apicentral.dev/Image/rotate"
        val jsonPayload = """
        
        {
          "image": "base64_encoded_image_string_here",
          "degrees": 90,
          "background_color": "none"
        }
        """.trimIndent()

        val client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build()

        val request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer YOUR_API_TOKEN_HERE")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(jsonPayload))
            .build()

        try {
            val response = client.send(request, HttpResponse.BodyHandlers.ofString())
            val resData = JsonParser.parseString(response.body()).asJsonObject
            val status = resData.get("status").asString
            val message = resData.get("message").asString
            val data = if (resData.has("data")) resData.get("data") else null
        } catch (e: Exception) {
            e.printStackTrace()
        }
}


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

void main() async {
    final url = Uri.parse('https://apicentral.dev/Image/rotate');
    final headers = {
        'Authorization': 'Bearer YOUR_API_TOKEN_HERE',
        'Content-Type': 'application/json'
    };

    final body = jsonEncode(
    {
      "image": "base64_encoded_image_string_here",
      "degrees": 90,
      "background_color": "none"
    });

    try {
        final response = await http.post(url, headers: headers, body: body);
        final resData = jsonDecode(response.body);
        final status = resData['status'];
        final message = resData['message'];
        final data = resData['data'];
    } catch (e) {
        print('Error: $e');
    }
}


use reqwest::blocking::Client;
use serde_json::Value;

fn main() -> Result<(), Box> {
        let client = Client::new();

        let json_payload = r#"
        
        {
          "image": "base64_encoded_image_string_here",
          "degrees": 90,
          "background_color": "none"
        }
        "#;

        let response = client
            .post("https://apicentral.dev/Image/rotate")
            .header("Authorization", "Bearer YOUR_API_TOKEN_HERE")
            .header("Content-Type", "application/json")
            .body(json_payload.to_string())
            .send()?;

        let res_data: Value = serde_json::from_str(&response.text()?)?;
        let status = &res_data["status"];
        let message = &res_data["message"];
        let data = &res_data["data"];

        println!("{} {} {:?}", status, message, data);

        Ok(())
}


curl -X POST 'https://apicentral.dev/Image/rotate' \
    -H 'Authorization: Bearer YOUR_API_TOKEN_HERE' \
    -H 'Content-Type: application/json' \
    -d '
    {
      "image": "base64_encoded_image_string_here",
      "degrees": 90,
      "background_color": "none"
    }'

crop

Crop an image by percentage (centered) or by exact coordinates and dimensions

Credits Required: 2.0

PARAMETERS

NAME	TYPE	REQUIRED	DESCRIPTION	ADDITIONAL CREDITS PER ITEM	EXAMPLE
image	string	Yes	Base64 encoded image data (max 10MB)	None	base64_encoded_image_string_here
crop_mode	int	Yes	Crop mode: 1 = by percentage (centered), 2 = exact coordinates	None	1
crop_percentage	int	No	Crop to this percentage of the original size (1-99), used when crop_mode = 1	None	80
crop_x	int	No	Starting X coordinate in pixels, used when crop_mode = 2	None	100
crop_y	int	No	Starting Y coordinate in pixels, used when crop_mode = 2	None	100
crop_width	int	No	Crop width in pixels, used when crop_mode = 2	None	400
crop_height	int	No	Crop height in pixels, used when crop_mode = 2	None	300

RESPONSE EXAMPLE

{
    "status": "success",
    "message": "Image cropped successfully",
    "data":
    {
        "image": "base64_encoded_result_image"
    }
}

CODE EXAMPLES

<?php

$Curl = curl_init();

$PostFields = 
[
  'image' => 'base64_encoded_image_string_here',
  'crop_mode' => 1,
  'crop_percentage' => 80,
  'crop_x' => 100,
  'crop_y' => 100,
  'crop_width' => 400,
  'crop_height' => 300,
];

curl_setopt_array(
    $Curl,
    [
        CURLOPT_URL => 'https://apicentral.dev/Image/crop',
        CURLOPT_POST => true,
        CURLOPT_POSTFIELDS => http_build_query($PostFields),
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT => 30,
        CURLOPT_HTTPHEADER => 
        [
            'Authorization: Bearer YOUR_API_TOKEN_HERE',
            'Content-Type: application/x-www-form-urlencoded'
        ]
    ]
);

$Response = curl_exec($Curl);
$Data = json_decode($Response, true);

if (curl_errno($Curl))
    $Error = curl_error($Curl);
else
{
    $status = $Data['status'];
    $message = $Data['message'];
    $data = $Data['data'] ?? null;
}

curl_close($Curl); // Omit in PHP 8 and above
?>


import requests
import json

url = 'https://apicentral.dev/Image/crop'
Headers = {'Authorization': 'Bearer YOUR_API_TOKEN_HERE'}
Data = 
{
  "image": "base64_encoded_image_string_here",
  "crop_mode": 1,
  "crop_percentage": 80,
  "crop_x": 100,
  "crop_y": 100,
  "crop_width": 400,
  "crop_height": 300
}

try:
    Response = requests.post(url, json=Data, headers=Headers)
    ResData = Response.json()
    status = ResData.get('status')
    message = ResData.get('message')
    data = ResData.get('data')
except Exception as e:
    error = str(e)


const axios = require('axios');

const Data = 
{
  "image": "base64_encoded_image_string_here",
  "crop_mode": 1,
  "crop_percentage": 80,
  "crop_x": 100,
  "crop_y": 100,
  "crop_width": 400,
  "crop_height": 300
};

axios.post(
    'https://apicentral.dev/Image/crop',
    Data,
    {
        headers: {'Authorization': 'Bearer YOUR_API_TOKEN_HERE'}
    }
)
.then(Response =>
{
    const status = Response.data.status;
    const message = Response.data.message;
    const data = Response.data.data;
})
.catch(Error => { const error = Error.message; });


import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.time.Duration;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;

public class ApiExample
{
    public static void main(String[] args)
    {
        String url = "https://apicentral.dev/Image/crop";
        String JsonPayload = """
        
        {
          "image": "base64_encoded_image_string_here",
          "crop_mode": 1,
          "crop_percentage": 80,
          "crop_x": 100,
          "crop_y": 100,
          "crop_width": 400,
          "crop_height": 300
        }
        """;

        HttpClient Client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest Request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer YOUR_API_TOKEN_HERE")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(JsonPayload))
            .build();

        try
        {
            HttpResponse Response = Client.send(Request, HttpResponse.BodyHandlers.ofString());
            JsonObject ResData = JsonParser.parseString(Response.body()).getAsJsonObject();
            String status = ResData.get("status").getAsString();
            String message = ResData.get("message").getAsString();
            Object data = ResData.has("data") ? ResData.get("data") : null;
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
}


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

public class ApiExample
{
    public static async Task Main()
    {
        using var Client = new HttpClient();
        Client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_TOKEN_HERE");

        var json_payload = @"
        {
          "image": "base64_encoded_image_string_here",
          "crop_mode": 1,
          "crop_percentage": 80,
          "crop_x": 100,
          "crop_y": 100,
          "crop_width": 400,
          "crop_height": 300
        }";
        var content = new StringContent(json_payload, Encoding.UTF8, "application/json");

        var Response = await Client.PostAsync("https://apicentral.dev/Image/crop", content);
        var Result = await Response.Content.ReadAsStringAsync();
        dynamic ResData = JsonConvert.DeserializeObject(Result);
        string status = ResData.status;
        string message = ResData.message;
        object data = ResData.data;
    }
}


package main

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

func main() {
        JsonPayload := []byte(`
        {
          "image": "base64_encoded_image_string_here",
          "crop_mode": 1,
          "crop_percentage": 80,
          "crop_x": 100,
          "crop_y": 100,
          "crop_width": 400,
          "crop_height": 300
        }`)

        Client := &http.Client{}
        Request, _ := http.NewRequest("POST", "https://apicentral.dev/Image/crop", bytes.NewBuffer(JsonPayload))
        Request.Header.Set("Authorization", "Bearer YOUR_API_TOKEN_HERE")
        Request.Header.Set("Content-Type", "application/json")

        Response, err := Client.Do(Request)

        if err != nil {
            fmt.Println("Error:", err)
            return
        }

        defer Response.Body.Close()

        Body, _ := io.ReadAll(Response.Body)

        var ResData map[string]interface{}
        json.Unmarshal(Body, &ResData)

        status := ResData["status"]
        message := ResData["message"]
        data := ResData["data"]

        fmt.Println(status, message, data)
}


require 'net/http'
require 'uri'
require 'json'

uri = URI('https://apicentral.dev/Image/crop')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_TOKEN_HERE'
request['Content-Type'] = 'application/json'
request.body = 
{
  "image": "base64_encoded_image_string_here",
  "crop_mode": 1,
  "crop_percentage": 80,
  "crop_x": 100,
  "crop_y": 100,
  "crop_width": 400,
  "crop_height": 300
}.to_json

response = http.request(request)
res_data = JSON.parse(response.body)

status = res_data['status']
message = res_data['message']
data = res_data['data']


import Foundation

let url = URL(string: "https://apicentral.dev/Image/crop")!
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer YOUR_API_TOKEN_HERE", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let JsonPayload = """

    {
      "image": "base64_encoded_image_string_here",
      "crop_mode": 1,
      "crop_percentage": 80,
      "crop_x": 100,
      "crop_y": 100,
      "crop_width": 400,
      "crop_height": 300
    }
""".data(using: .utf8)!
request.httpBody = JsonPayload

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let error = error {
        print("Error: \(error)")
        return
    }

    guard let data = data else { return }

    if let resData = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
        let status = resData["status"] as? String
        let message = resData["message"] as? String
        let data = resData["data"]
    }
}

task.resume()


import java.net.http.HttpClient
import java.net.http.HttpRequest
import java.net.http.HttpResponse
import java.net.URI
import java.time.Duration
import com.google.gson.JsonParser

fun main() {
        val url = "https://apicentral.dev/Image/crop"
        val jsonPayload = """
        
        {
          "image": "base64_encoded_image_string_here",
          "crop_mode": 1,
          "crop_percentage": 80,
          "crop_x": 100,
          "crop_y": 100,
          "crop_width": 400,
          "crop_height": 300
        }
        """.trimIndent()

        val client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build()

        val request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer YOUR_API_TOKEN_HERE")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(jsonPayload))
            .build()

        try {
            val response = client.send(request, HttpResponse.BodyHandlers.ofString())
            val resData = JsonParser.parseString(response.body()).asJsonObject
            val status = resData.get("status").asString
            val message = resData.get("message").asString
            val data = if (resData.has("data")) resData.get("data") else null
        } catch (e: Exception) {
            e.printStackTrace()
        }
}


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

void main() async {
    final url = Uri.parse('https://apicentral.dev/Image/crop');
    final headers = {
        'Authorization': 'Bearer YOUR_API_TOKEN_HERE',
        'Content-Type': 'application/json'
    };

    final body = jsonEncode(
    {
      "image": "base64_encoded_image_string_here",
      "crop_mode": 1,
      "crop_percentage": 80,
      "crop_x": 100,
      "crop_y": 100,
      "crop_width": 400,
      "crop_height": 300
    });

    try {
        final response = await http.post(url, headers: headers, body: body);
        final resData = jsonDecode(response.body);
        final status = resData['status'];
        final message = resData['message'];
        final data = resData['data'];
    } catch (e) {
        print('Error: $e');
    }
}


use reqwest::blocking::Client;
use serde_json::Value;

fn main() -> Result<(), Box> {
        let client = Client::new();

        let json_payload = r#"
        
        {
          "image": "base64_encoded_image_string_here",
          "crop_mode": 1,
          "crop_percentage": 80,
          "crop_x": 100,
          "crop_y": 100,
          "crop_width": 400,
          "crop_height": 300
        }
        "#;

        let response = client
            .post("https://apicentral.dev/Image/crop")
            .header("Authorization", "Bearer YOUR_API_TOKEN_HERE")
            .header("Content-Type", "application/json")
            .body(json_payload.to_string())
            .send()?;

        let res_data: Value = serde_json::from_str(&response.text()?)?;
        let status = &res_data["status"];
        let message = &res_data["message"];
        let data = &res_data["data"];

        println!("{} {} {:?}", status, message, data);

        Ok(())
}


curl -X POST 'https://apicentral.dev/Image/crop' \
    -H 'Authorization: Bearer YOUR_API_TOKEN_HERE' \
    -H 'Content-Type: application/json' \
    -d '
    {
      "image": "base64_encoded_image_string_here",
      "crop_mode": 1,
      "crop_percentage": 80,
      "crop_x": 100,
      "crop_y": 100,
      "crop_width": 400,
      "crop_height": 300
    }'

flip

Flip an image horizontally, vertically, or both

Credits Required: 2.0

PARAMETERS

NAME	TYPE	REQUIRED	DESCRIPTION	ADDITIONAL CREDITS PER ITEM	EXAMPLE
image	string	Yes	Base64 encoded image data (max 10MB)	None	base64_encoded_image_string_here
flip_mode	int	Yes	Flip mode: 1 = horizontal, 2 = vertical, 3 = both	None	1

RESPONSE EXAMPLE

{
    "status": "success",
    "message": "Image flipped successfully",
    "data":
    {
        "image": "base64_encoded_result_image"
    }
}

CODE EXAMPLES

<?php

$Curl = curl_init();

$PostFields = 
[
  'image' => 'base64_encoded_image_string_here',
  'flip_mode' => 1,
];

curl_setopt_array(
    $Curl,
    [
        CURLOPT_URL => 'https://apicentral.dev/Image/flip',
        CURLOPT_POST => true,
        CURLOPT_POSTFIELDS => http_build_query($PostFields),
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT => 30,
        CURLOPT_HTTPHEADER => 
        [
            'Authorization: Bearer YOUR_API_TOKEN_HERE',
            'Content-Type: application/x-www-form-urlencoded'
        ]
    ]
);

$Response = curl_exec($Curl);
$Data = json_decode($Response, true);

if (curl_errno($Curl))
    $Error = curl_error($Curl);
else
{
    $status = $Data['status'];
    $message = $Data['message'];
    $data = $Data['data'] ?? null;
}

curl_close($Curl); // Omit in PHP 8 and above
?>


import requests
import json

url = 'https://apicentral.dev/Image/flip'
Headers = {'Authorization': 'Bearer YOUR_API_TOKEN_HERE'}
Data = 
{
  "image": "base64_encoded_image_string_here",
  "flip_mode": 1
}

try:
    Response = requests.post(url, json=Data, headers=Headers)
    ResData = Response.json()
    status = ResData.get('status')
    message = ResData.get('message')
    data = ResData.get('data')
except Exception as e:
    error = str(e)


const axios = require('axios');

const Data = 
{
  "image": "base64_encoded_image_string_here",
  "flip_mode": 1
};

axios.post(
    'https://apicentral.dev/Image/flip',
    Data,
    {
        headers: {'Authorization': 'Bearer YOUR_API_TOKEN_HERE'}
    }
)
.then(Response =>
{
    const status = Response.data.status;
    const message = Response.data.message;
    const data = Response.data.data;
})
.catch(Error => { const error = Error.message; });


import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.time.Duration;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;

public class ApiExample
{
    public static void main(String[] args)
    {
        String url = "https://apicentral.dev/Image/flip";
        String JsonPayload = """
        
        {
          "image": "base64_encoded_image_string_here",
          "flip_mode": 1
        }
        """;

        HttpClient Client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest Request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer YOUR_API_TOKEN_HERE")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(JsonPayload))
            .build();

        try
        {
            HttpResponse Response = Client.send(Request, HttpResponse.BodyHandlers.ofString());
            JsonObject ResData = JsonParser.parseString(Response.body()).getAsJsonObject();
            String status = ResData.get("status").getAsString();
            String message = ResData.get("message").getAsString();
            Object data = ResData.has("data") ? ResData.get("data") : null;
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
}


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

public class ApiExample
{
    public static async Task Main()
    {
        using var Client = new HttpClient();
        Client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_TOKEN_HERE");

        var json_payload = @"
        {
          "image": "base64_encoded_image_string_here",
          "flip_mode": 1
        }";
        var content = new StringContent(json_payload, Encoding.UTF8, "application/json");

        var Response = await Client.PostAsync("https://apicentral.dev/Image/flip", content);
        var Result = await Response.Content.ReadAsStringAsync();
        dynamic ResData = JsonConvert.DeserializeObject(Result);
        string status = ResData.status;
        string message = ResData.message;
        object data = ResData.data;
    }
}


package main

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

func main() {
        JsonPayload := []byte(`
        {
          "image": "base64_encoded_image_string_here",
          "flip_mode": 1
        }`)

        Client := &http.Client{}
        Request, _ := http.NewRequest("POST", "https://apicentral.dev/Image/flip", bytes.NewBuffer(JsonPayload))
        Request.Header.Set("Authorization", "Bearer YOUR_API_TOKEN_HERE")
        Request.Header.Set("Content-Type", "application/json")

        Response, err := Client.Do(Request)

        if err != nil {
            fmt.Println("Error:", err)
            return
        }

        defer Response.Body.Close()

        Body, _ := io.ReadAll(Response.Body)

        var ResData map[string]interface{}
        json.Unmarshal(Body, &ResData)

        status := ResData["status"]
        message := ResData["message"]
        data := ResData["data"]

        fmt.Println(status, message, data)
}


require 'net/http'
require 'uri'
require 'json'

uri = URI('https://apicentral.dev/Image/flip')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_TOKEN_HERE'
request['Content-Type'] = 'application/json'
request.body = 
{
  "image": "base64_encoded_image_string_here",
  "flip_mode": 1
}.to_json

response = http.request(request)
res_data = JSON.parse(response.body)

status = res_data['status']
message = res_data['message']
data = res_data['data']


import Foundation

let url = URL(string: "https://apicentral.dev/Image/flip")!
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer YOUR_API_TOKEN_HERE", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let JsonPayload = """

    {
      "image": "base64_encoded_image_string_here",
      "flip_mode": 1
    }
""".data(using: .utf8)!
request.httpBody = JsonPayload

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let error = error {
        print("Error: \(error)")
        return
    }

    guard let data = data else { return }

    if let resData = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
        let status = resData["status"] as? String
        let message = resData["message"] as? String
        let data = resData["data"]
    }
}

task.resume()


import java.net.http.HttpClient
import java.net.http.HttpRequest
import java.net.http.HttpResponse
import java.net.URI
import java.time.Duration
import com.google.gson.JsonParser

fun main() {
        val url = "https://apicentral.dev/Image/flip"
        val jsonPayload = """
        
        {
          "image": "base64_encoded_image_string_here",
          "flip_mode": 1
        }
        """.trimIndent()

        val client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build()

        val request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer YOUR_API_TOKEN_HERE")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(jsonPayload))
            .build()

        try {
            val response = client.send(request, HttpResponse.BodyHandlers.ofString())
            val resData = JsonParser.parseString(response.body()).asJsonObject
            val status = resData.get("status").asString
            val message = resData.get("message").asString
            val data = if (resData.has("data")) resData.get("data") else null
        } catch (e: Exception) {
            e.printStackTrace()
        }
}


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

void main() async {
    final url = Uri.parse('https://apicentral.dev/Image/flip');
    final headers = {
        'Authorization': 'Bearer YOUR_API_TOKEN_HERE',
        'Content-Type': 'application/json'
    };

    final body = jsonEncode(
    {
      "image": "base64_encoded_image_string_here",
      "flip_mode": 1
    });

    try {
        final response = await http.post(url, headers: headers, body: body);
        final resData = jsonDecode(response.body);
        final status = resData['status'];
        final message = resData['message'];
        final data = resData['data'];
    } catch (e) {
        print('Error: $e');
    }
}


use reqwest::blocking::Client;
use serde_json::Value;

fn main() -> Result<(), Box> {
        let client = Client::new();

        let json_payload = r#"
        
        {
          "image": "base64_encoded_image_string_here",
          "flip_mode": 1
        }
        "#;

        let response = client
            .post("https://apicentral.dev/Image/flip")
            .header("Authorization", "Bearer YOUR_API_TOKEN_HERE")
            .header("Content-Type", "application/json")
            .body(json_payload.to_string())
            .send()?;

        let res_data: Value = serde_json::from_str(&response.text()?)?;
        let status = &res_data["status"];
        let message = &res_data["message"];
        let data = &res_data["data"];

        println!("{} {} {:?}", status, message, data);

        Ok(())
}


curl -X POST 'https://apicentral.dev/Image/flip' \
    -H 'Authorization: Bearer YOUR_API_TOKEN_HERE' \
    -H 'Content-Type: application/json' \
    -d '
    {
      "image": "base64_encoded_image_string_here",
      "flip_mode": 1
    }'

border

Add a border around an image with specified width, height, and color

Credits Required: 2.0

PARAMETERS

NAME	TYPE	REQUIRED	DESCRIPTION	ADDITIONAL CREDITS PER ITEM	EXAMPLE
image	string	Yes	Base64 encoded image data (max 10MB)	None	base64_encoded_image_string_here
border_width	int	Yes	Border width in pixels (1-500)	None	10
border_height	int	Yes	Border height in pixels (1-500)	None	10
border_color	string	Yes	Border color in hex format (e.g. #000000)	None	#000000

RESPONSE EXAMPLE

{
    "status": "success",
    "message": "Border added successfully",
    "data":
    {
        "image": "base64_encoded_result_image"
    }
}

CODE EXAMPLES

<?php

$Curl = curl_init();

$PostFields = 
[
  'image' => 'base64_encoded_image_string_here',
  'border_width' => 10,
  'border_height' => 10,
  'border_color' => '#000000',
];

curl_setopt_array(
    $Curl,
    [
        CURLOPT_URL => 'https://apicentral.dev/Image/border',
        CURLOPT_POST => true,
        CURLOPT_POSTFIELDS => http_build_query($PostFields),
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT => 30,
        CURLOPT_HTTPHEADER => 
        [
            'Authorization: Bearer YOUR_API_TOKEN_HERE',
            'Content-Type: application/x-www-form-urlencoded'
        ]
    ]
);

$Response = curl_exec($Curl);
$Data = json_decode($Response, true);

if (curl_errno($Curl))
    $Error = curl_error($Curl);
else
{
    $status = $Data['status'];
    $message = $Data['message'];
    $data = $Data['data'] ?? null;
}

curl_close($Curl); // Omit in PHP 8 and above
?>


import requests
import json

url = 'https://apicentral.dev/Image/border'
Headers = {'Authorization': 'Bearer YOUR_API_TOKEN_HERE'}
Data = 
{
  "image": "base64_encoded_image_string_here",
  "border_width": 10,
  "border_height": 10,
  "border_color": "#000000"
}

try:
    Response = requests.post(url, json=Data, headers=Headers)
    ResData = Response.json()
    status = ResData.get('status')
    message = ResData.get('message')
    data = ResData.get('data')
except Exception as e:
    error = str(e)


const axios = require('axios');

const Data = 
{
  "image": "base64_encoded_image_string_here",
  "border_width": 10,
  "border_height": 10,
  "border_color": "#000000"
};

axios.post(
    'https://apicentral.dev/Image/border',
    Data,
    {
        headers: {'Authorization': 'Bearer YOUR_API_TOKEN_HERE'}
    }
)
.then(Response =>
{
    const status = Response.data.status;
    const message = Response.data.message;
    const data = Response.data.data;
})
.catch(Error => { const error = Error.message; });


import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.time.Duration;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;

public class ApiExample
{
    public static void main(String[] args)
    {
        String url = "https://apicentral.dev/Image/border";
        String JsonPayload = """
        
        {
          "image": "base64_encoded_image_string_here",
          "border_width": 10,
          "border_height": 10,
          "border_color": "#000000"
        }
        """;

        HttpClient Client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest Request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer YOUR_API_TOKEN_HERE")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(JsonPayload))
            .build();

        try
        {
            HttpResponse Response = Client.send(Request, HttpResponse.BodyHandlers.ofString());
            JsonObject ResData = JsonParser.parseString(Response.body()).getAsJsonObject();
            String status = ResData.get("status").getAsString();
            String message = ResData.get("message").getAsString();
            Object data = ResData.has("data") ? ResData.get("data") : null;
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
}


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

public class ApiExample
{
    public static async Task Main()
    {
        using var Client = new HttpClient();
        Client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_TOKEN_HERE");

        var json_payload = @"
        {
          "image": "base64_encoded_image_string_here",
          "border_width": 10,
          "border_height": 10,
          "border_color": "#000000"
        }";
        var content = new StringContent(json_payload, Encoding.UTF8, "application/json");

        var Response = await Client.PostAsync("https://apicentral.dev/Image/border", content);
        var Result = await Response.Content.ReadAsStringAsync();
        dynamic ResData = JsonConvert.DeserializeObject(Result);
        string status = ResData.status;
        string message = ResData.message;
        object data = ResData.data;
    }
}


package main

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

func main() {
        JsonPayload := []byte(`
        {
          "image": "base64_encoded_image_string_here",
          "border_width": 10,
          "border_height": 10,
          "border_color": "#000000"
        }`)

        Client := &http.Client{}
        Request, _ := http.NewRequest("POST", "https://apicentral.dev/Image/border", bytes.NewBuffer(JsonPayload))
        Request.Header.Set("Authorization", "Bearer YOUR_API_TOKEN_HERE")
        Request.Header.Set("Content-Type", "application/json")

        Response, err := Client.Do(Request)

        if err != nil {
            fmt.Println("Error:", err)
            return
        }

        defer Response.Body.Close()

        Body, _ := io.ReadAll(Response.Body)

        var ResData map[string]interface{}
        json.Unmarshal(Body, &ResData)

        status := ResData["status"]
        message := ResData["message"]
        data := ResData["data"]

        fmt.Println(status, message, data)
}


require 'net/http'
require 'uri'
require 'json'

uri = URI('https://apicentral.dev/Image/border')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_TOKEN_HERE'
request['Content-Type'] = 'application/json'
request.body = 
{
  "image": "base64_encoded_image_string_here",
  "border_width": 10,
  "border_height": 10,
  "border_color": "#000000"
}.to_json

response = http.request(request)
res_data = JSON.parse(response.body)

status = res_data['status']
message = res_data['message']
data = res_data['data']


import Foundation

let url = URL(string: "https://apicentral.dev/Image/border")!
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer YOUR_API_TOKEN_HERE", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let JsonPayload = """

    {
      "image": "base64_encoded_image_string_here",
      "border_width": 10,
      "border_height": 10,
      "border_color": "#000000"
    }
""".data(using: .utf8)!
request.httpBody = JsonPayload

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let error = error {
        print("Error: \(error)")
        return
    }

    guard let data = data else { return }

    if let resData = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
        let status = resData["status"] as? String
        let message = resData["message"] as? String
        let data = resData["data"]
    }
}

task.resume()


import java.net.http.HttpClient
import java.net.http.HttpRequest
import java.net.http.HttpResponse
import java.net.URI
import java.time.Duration
import com.google.gson.JsonParser

fun main() {
        val url = "https://apicentral.dev/Image/border"
        val jsonPayload = """
        
        {
          "image": "base64_encoded_image_string_here",
          "border_width": 10,
          "border_height": 10,
          "border_color": "#000000"
        }
        """.trimIndent()

        val client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build()

        val request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer YOUR_API_TOKEN_HERE")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(jsonPayload))
            .build()

        try {
            val response = client.send(request, HttpResponse.BodyHandlers.ofString())
            val resData = JsonParser.parseString(response.body()).asJsonObject
            val status = resData.get("status").asString
            val message = resData.get("message").asString
            val data = if (resData.has("data")) resData.get("data") else null
        } catch (e: Exception) {
            e.printStackTrace()
        }
}


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

void main() async {
    final url = Uri.parse('https://apicentral.dev/Image/border');
    final headers = {
        'Authorization': 'Bearer YOUR_API_TOKEN_HERE',
        'Content-Type': 'application/json'
    };

    final body = jsonEncode(
    {
      "image": "base64_encoded_image_string_here",
      "border_width": 10,
      "border_height": 10,
      "border_color": "#000000"
    });

    try {
        final response = await http.post(url, headers: headers, body: body);
        final resData = jsonDecode(response.body);
        final status = resData['status'];
        final message = resData['message'];
        final data = resData['data'];
    } catch (e) {
        print('Error: $e');
    }
}


use reqwest::blocking::Client;
use serde_json::Value;

fn main() -> Result<(), Box> {
        let client = Client::new();

        let json_payload = r#"
        
        {
          "image": "base64_encoded_image_string_here",
          "border_width": 10,
          "border_height": 10,
          "border_color": "#000000"
        }
        "#;

        let response = client
            .post("https://apicentral.dev/Image/border")
            .header("Authorization", "Bearer YOUR_API_TOKEN_HERE")
            .header("Content-Type", "application/json")
            .body(json_payload.to_string())
            .send()?;

        let res_data: Value = serde_json::from_str(&response.text()?)?;
        let status = &res_data["status"];
        let message = &res_data["message"];
        let data = &res_data["data"];

        println!("{} {} {:?}", status, message, data);

        Ok(())
}


curl -X POST 'https://apicentral.dev/Image/border' \
    -H 'Authorization: Bearer YOUR_API_TOKEN_HERE' \
    -H 'Content-Type: application/json' \
    -d '
    {
      "image": "base64_encoded_image_string_here",
      "border_width": 10,
      "border_height": 10,
      "border_color": "#000000"
    }'

combine

Combine multiple images into a single image horizontally, vertically, or in a grid layout

Credits Required: 1.0

PARAMETERS

NAME	TYPE	REQUIRED	DESCRIPTION	ADDITIONAL CREDITS PER ITEM	EXAMPLE
Images	array	Yes	Array of base64 encoded image strings (min 2, max 100 images, each max 10MB, total max 100MB)	1	[ "base64_encoded_image_1_here", "base64_encoded_image_2_here", "base64_encoded_image_3_here" ]
combine_mode	int	Yes	Combine mode: 1 = horizontal, 2 = vertical, 3 = grid	None	1

RESPONSE EXAMPLE

{
    "status": "success",
    "message": "Images combined successfully",
    "data":
    {
        "image": "base64_encoded_result_image"
    }
}

CODE EXAMPLES

<?php

$Curl = curl_init();

$PostFields = 
[
  'Images' => 
  [
    '0' => 'base64_encoded_image_1_here',
    '1' => 'base64_encoded_image_2_here',
    '2' => 'base64_encoded_image_3_here',
  ],
  'combine_mode' => 1,
];

curl_setopt_array(
    $Curl,
    [
        CURLOPT_URL => 'https://apicentral.dev/Image/combine',
        CURLOPT_POST => true,
        CURLOPT_POSTFIELDS => http_build_query($PostFields),
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT => 30,
        CURLOPT_HTTPHEADER => 
        [
            'Authorization: Bearer YOUR_API_TOKEN_HERE',
            'Content-Type: application/x-www-form-urlencoded'
        ]
    ]
);

$Response = curl_exec($Curl);
$Data = json_decode($Response, true);

if (curl_errno($Curl))
    $Error = curl_error($Curl);
else
{
    $status = $Data['status'];
    $message = $Data['message'];
    $data = $Data['data'] ?? null;
}

curl_close($Curl); // Omit in PHP 8 and above
?>


import requests
import json

url = 'https://apicentral.dev/Image/combine'
Headers = {'Authorization': 'Bearer YOUR_API_TOKEN_HERE'}
Data = 
{
  "Images": 
  {
    "0": "base64_encoded_image_1_here",
    "1": "base64_encoded_image_2_here",
    "2": "base64_encoded_image_3_here"
  },
  "combine_mode": 1
}

try:
    Response = requests.post(url, json=Data, headers=Headers)
    ResData = Response.json()
    status = ResData.get('status')
    message = ResData.get('message')
    data = ResData.get('data')
except Exception as e:
    error = str(e)


const axios = require('axios');

const Data = 
{
  "Images": 
  {
    "0": "base64_encoded_image_1_here",
    "1": "base64_encoded_image_2_here",
    "2": "base64_encoded_image_3_here"
  },
  "combine_mode": 1
};

axios.post(
    'https://apicentral.dev/Image/combine',
    Data,
    {
        headers: {'Authorization': 'Bearer YOUR_API_TOKEN_HERE'}
    }
)
.then(Response =>
{
    const status = Response.data.status;
    const message = Response.data.message;
    const data = Response.data.data;
})
.catch(Error => { const error = Error.message; });


import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.time.Duration;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;

public class ApiExample
{
    public static void main(String[] args)
    {
        String url = "https://apicentral.dev/Image/combine";
        String JsonPayload = """
        
        {
          "Images": 
          {
            "0": "base64_encoded_image_1_here",
            "1": "base64_encoded_image_2_here",
            "2": "base64_encoded_image_3_here"
          },
          "combine_mode": 1
        }
        """;

        HttpClient Client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest Request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer YOUR_API_TOKEN_HERE")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(JsonPayload))
            .build();

        try
        {
            HttpResponse Response = Client.send(Request, HttpResponse.BodyHandlers.ofString());
            JsonObject ResData = JsonParser.parseString(Response.body()).getAsJsonObject();
            String status = ResData.get("status").getAsString();
            String message = ResData.get("message").getAsString();
            Object data = ResData.has("data") ? ResData.get("data") : null;
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
}


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

public class ApiExample
{
    public static async Task Main()
    {
        using var Client = new HttpClient();
        Client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_TOKEN_HERE");

        var json_payload = @"
        {
          "Images": 
          {
            "0": "base64_encoded_image_1_here",
            "1": "base64_encoded_image_2_here",
            "2": "base64_encoded_image_3_here"
          },
          "combine_mode": 1
        }";
        var content = new StringContent(json_payload, Encoding.UTF8, "application/json");

        var Response = await Client.PostAsync("https://apicentral.dev/Image/combine", content);
        var Result = await Response.Content.ReadAsStringAsync();
        dynamic ResData = JsonConvert.DeserializeObject(Result);
        string status = ResData.status;
        string message = ResData.message;
        object data = ResData.data;
    }
}


package main

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

func main() {
        JsonPayload := []byte(`
        {
          "Images": 
          {
            "0": "base64_encoded_image_1_here",
            "1": "base64_encoded_image_2_here",
            "2": "base64_encoded_image_3_here"
          },
          "combine_mode": 1
        }`)

        Client := &http.Client{}
        Request, _ := http.NewRequest("POST", "https://apicentral.dev/Image/combine", bytes.NewBuffer(JsonPayload))
        Request.Header.Set("Authorization", "Bearer YOUR_API_TOKEN_HERE")
        Request.Header.Set("Content-Type", "application/json")

        Response, err := Client.Do(Request)

        if err != nil {
            fmt.Println("Error:", err)
            return
        }

        defer Response.Body.Close()

        Body, _ := io.ReadAll(Response.Body)

        var ResData map[string]interface{}
        json.Unmarshal(Body, &ResData)

        status := ResData["status"]
        message := ResData["message"]
        data := ResData["data"]

        fmt.Println(status, message, data)
}


require 'net/http'
require 'uri'
require 'json'

uri = URI('https://apicentral.dev/Image/combine')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_TOKEN_HERE'
request['Content-Type'] = 'application/json'
request.body = 
{
  "Images": 
  {
    "0": "base64_encoded_image_1_here",
    "1": "base64_encoded_image_2_here",
    "2": "base64_encoded_image_3_here"
  },
  "combine_mode": 1
}.to_json

response = http.request(request)
res_data = JSON.parse(response.body)

status = res_data['status']
message = res_data['message']
data = res_data['data']


import Foundation

let url = URL(string: "https://apicentral.dev/Image/combine")!
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer YOUR_API_TOKEN_HERE", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let JsonPayload = """

    {
      "Images": 
      {
        "0": "base64_encoded_image_1_here",
        "1": "base64_encoded_image_2_here",
        "2": "base64_encoded_image_3_here"
      },
      "combine_mode": 1
    }
""".data(using: .utf8)!
request.httpBody = JsonPayload

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let error = error {
        print("Error: \(error)")
        return
    }

    guard let data = data else { return }

    if let resData = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
        let status = resData["status"] as? String
        let message = resData["message"] as? String
        let data = resData["data"]
    }
}

task.resume()


import java.net.http.HttpClient
import java.net.http.HttpRequest
import java.net.http.HttpResponse
import java.net.URI
import java.time.Duration
import com.google.gson.JsonParser

fun main() {
        val url = "https://apicentral.dev/Image/combine"
        val jsonPayload = """
        
        {
          "Images": 
          {
            "0": "base64_encoded_image_1_here",
            "1": "base64_encoded_image_2_here",
            "2": "base64_encoded_image_3_here"
          },
          "combine_mode": 1
        }
        """.trimIndent()

        val client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build()

        val request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer YOUR_API_TOKEN_HERE")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(jsonPayload))
            .build()

        try {
            val response = client.send(request, HttpResponse.BodyHandlers.ofString())
            val resData = JsonParser.parseString(response.body()).asJsonObject
            val status = resData.get("status").asString
            val message = resData.get("message").asString
            val data = if (resData.has("data")) resData.get("data") else null
        } catch (e: Exception) {
            e.printStackTrace()
        }
}


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

void main() async {
    final url = Uri.parse('https://apicentral.dev/Image/combine');
    final headers = {
        'Authorization': 'Bearer YOUR_API_TOKEN_HERE',
        'Content-Type': 'application/json'
    };

    final body = jsonEncode(
    {
      "Images": 
      {
        "0": "base64_encoded_image_1_here",
        "1": "base64_encoded_image_2_here",
        "2": "base64_encoded_image_3_here"
      },
      "combine_mode": 1
    });

    try {
        final response = await http.post(url, headers: headers, body: body);
        final resData = jsonDecode(response.body);
        final status = resData['status'];
        final message = resData['message'];
        final data = resData['data'];
    } catch (e) {
        print('Error: $e');
    }
}


use reqwest::blocking::Client;
use serde_json::Value;

fn main() -> Result<(), Box> {
        let client = Client::new();

        let json_payload = r#"
        
        {
          "Images": 
          {
            "0": "base64_encoded_image_1_here",
            "1": "base64_encoded_image_2_here",
            "2": "base64_encoded_image_3_here"
          },
          "combine_mode": 1
        }
        "#;

        let response = client
            .post("https://apicentral.dev/Image/combine")
            .header("Authorization", "Bearer YOUR_API_TOKEN_HERE")
            .header("Content-Type", "application/json")
            .body(json_payload.to_string())
            .send()?;

        let res_data: Value = serde_json::from_str(&response.text()?)?;
        let status = &res_data["status"];
        let message = &res_data["message"];
        let data = &res_data["data"];

        println!("{} {} {:?}", status, message, data);

        Ok(())
}


curl -X POST 'https://apicentral.dev/Image/combine' \
    -H 'Authorization: Bearer YOUR_API_TOKEN_HERE' \
    -H 'Content-Type: application/json' \
    -d '
    {
      "Images": 
      {
        "0": "base64_encoded_image_1_here",
        "1": "base64_encoded_image_2_here",
        "2": "base64_encoded_image_3_here"
      },
      "combine_mode": 1
    }'

specialEffects

Apply one or more special effects to an image: oil paint, polaroid, swirl, wave, negate, charcoal, sepia, vignette, enhance saturation, enhance contrast

Credits Required: 1.0

PARAMETERS

NAME	TYPE	REQUIRED	DESCRIPTION	ADDITIONAL CREDITS PER ITEM	EXAMPLE
image	string	Yes	Base64 encoded image data (max 10MB)	None	base64_encoded_image_string_here
oil_paint	int	No	Apply oil paint effect (0 = no, 1 = yes)	1	0
polaroid	int	No	Apply polaroid effect (0 = no, 1 = yes)	1	0
polaroid_angle	float	No	Polaroid rotation angle in degrees (used when polaroid = 1)	None	5
swirl	int	No	Apply swirl effect (0 = no, 1 = yes)	1	0
swirl_amount	float	No	Swirl intensity in degrees (used when swirl = 1)	None	60
wave	int	No	Apply wave effect (0 = no, 1 = yes)	1	0
wave_amplitude	float	No	Wave amplitude in pixels (used when wave = 1)	None	10
wave_length	float	No	Wave length in pixels (used when wave = 1)	None	50
negate	int	No	Apply negate/invert effect (0 = no, 1 = yes)	1	0
charcoal	int	No	Apply charcoal sketch effect (0 = no, 1 = yes)	1	0
sepia	int	No	Apply sepia tone effect (0 = no, 1 = yes)	1	0
vignette	int	No	Apply vignette effect (0 = no, 1 = yes)	1	0
enhance_saturation	int	No	Enhance color saturation (0 = no, 1 = yes)	1	0
enhance_contrast	int	No	Enhance contrast / normalize (0 = no, 1 = yes)	1	0

RESPONSE EXAMPLE

{
    "status": "success",
    "message": "Special effects applied successfully",
    "data":
    {
        "image": "base64_encoded_result_image"
    }
}

CODE EXAMPLES

<?php

$Curl = curl_init();

$PostFields = 
[
  'image' => 'base64_encoded_image_string_here',
  'oil_paint' => 0,
  'polaroid' => 0,
  'polaroid_angle' => 5,
  'swirl' => 0,
  'swirl_amount' => 60,
  'wave' => 0,
  'wave_amplitude' => 10,
  'wave_length' => 50,
  'negate' => 0,
  'charcoal' => 0,
  'sepia' => 0,
  'vignette' => 0,
  'enhance_saturation' => 0,
  'enhance_contrast' => 0,
];

curl_setopt_array(
    $Curl,
    [
        CURLOPT_URL => 'https://apicentral.dev/Image/specialEffects',
        CURLOPT_POST => true,
        CURLOPT_POSTFIELDS => http_build_query($PostFields),
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT => 30,
        CURLOPT_HTTPHEADER => 
        [
            'Authorization: Bearer YOUR_API_TOKEN_HERE',
            'Content-Type: application/x-www-form-urlencoded'
        ]
    ]
);

$Response = curl_exec($Curl);
$Data = json_decode($Response, true);

if (curl_errno($Curl))
    $Error = curl_error($Curl);
else
{
    $status = $Data['status'];
    $message = $Data['message'];
    $data = $Data['data'] ?? null;
}

curl_close($Curl); // Omit in PHP 8 and above
?>


import requests
import json

url = 'https://apicentral.dev/Image/specialEffects'
Headers = {'Authorization': 'Bearer YOUR_API_TOKEN_HERE'}
Data = 
{
  "image": "base64_encoded_image_string_here",
  "oil_paint": 0,
  "polaroid": 0,
  "polaroid_angle": 5,
  "swirl": 0,
  "swirl_amount": 60,
  "wave": 0,
  "wave_amplitude": 10,
  "wave_length": 50,
  "negate": 0,
  "charcoal": 0,
  "sepia": 0,
  "vignette": 0,
  "enhance_saturation": 0,
  "enhance_contrast": 0
}

try:
    Response = requests.post(url, json=Data, headers=Headers)
    ResData = Response.json()
    status = ResData.get('status')
    message = ResData.get('message')
    data = ResData.get('data')
except Exception as e:
    error = str(e)


const axios = require('axios');

const Data = 
{
  "image": "base64_encoded_image_string_here",
  "oil_paint": 0,
  "polaroid": 0,
  "polaroid_angle": 5,
  "swirl": 0,
  "swirl_amount": 60,
  "wave": 0,
  "wave_amplitude": 10,
  "wave_length": 50,
  "negate": 0,
  "charcoal": 0,
  "sepia": 0,
  "vignette": 0,
  "enhance_saturation": 0,
  "enhance_contrast": 0
};

axios.post(
    'https://apicentral.dev/Image/specialEffects',
    Data,
    {
        headers: {'Authorization': 'Bearer YOUR_API_TOKEN_HERE'}
    }
)
.then(Response =>
{
    const status = Response.data.status;
    const message = Response.data.message;
    const data = Response.data.data;
})
.catch(Error => { const error = Error.message; });


import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.time.Duration;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;

public class ApiExample
{
    public static void main(String[] args)
    {
        String url = "https://apicentral.dev/Image/specialEffects";
        String JsonPayload = """
        
        {
          "image": "base64_encoded_image_string_here",
          "oil_paint": 0,
          "polaroid": 0,
          "polaroid_angle": 5,
          "swirl": 0,
          "swirl_amount": 60,
          "wave": 0,
          "wave_amplitude": 10,
          "wave_length": 50,
          "negate": 0,
          "charcoal": 0,
          "sepia": 0,
          "vignette": 0,
          "enhance_saturation": 0,
          "enhance_contrast": 0
        }
        """;

        HttpClient Client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest Request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer YOUR_API_TOKEN_HERE")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(JsonPayload))
            .build();

        try
        {
            HttpResponse Response = Client.send(Request, HttpResponse.BodyHandlers.ofString());
            JsonObject ResData = JsonParser.parseString(Response.body()).getAsJsonObject();
            String status = ResData.get("status").getAsString();
            String message = ResData.get("message").getAsString();
            Object data = ResData.has("data") ? ResData.get("data") : null;
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
}


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

public class ApiExample
{
    public static async Task Main()
    {
        using var Client = new HttpClient();
        Client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_TOKEN_HERE");

        var json_payload = @"
        {
          "image": "base64_encoded_image_string_here",
          "oil_paint": 0,
          "polaroid": 0,
          "polaroid_angle": 5,
          "swirl": 0,
          "swirl_amount": 60,
          "wave": 0,
          "wave_amplitude": 10,
          "wave_length": 50,
          "negate": 0,
          "charcoal": 0,
          "sepia": 0,
          "vignette": 0,
          "enhance_saturation": 0,
          "enhance_contrast": 0
        }";
        var content = new StringContent(json_payload, Encoding.UTF8, "application/json");

        var Response = await Client.PostAsync("https://apicentral.dev/Image/specialEffects", content);
        var Result = await Response.Content.ReadAsStringAsync();
        dynamic ResData = JsonConvert.DeserializeObject(Result);
        string status = ResData.status;
        string message = ResData.message;
        object data = ResData.data;
    }
}


package main

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

func main() {
        JsonPayload := []byte(`
        {
          "image": "base64_encoded_image_string_here",
          "oil_paint": 0,
          "polaroid": 0,
          "polaroid_angle": 5,
          "swirl": 0,
          "swirl_amount": 60,
          "wave": 0,
          "wave_amplitude": 10,
          "wave_length": 50,
          "negate": 0,
          "charcoal": 0,
          "sepia": 0,
          "vignette": 0,
          "enhance_saturation": 0,
          "enhance_contrast": 0
        }`)

        Client := &http.Client{}
        Request, _ := http.NewRequest("POST", "https://apicentral.dev/Image/specialEffects", bytes.NewBuffer(JsonPayload))
        Request.Header.Set("Authorization", "Bearer YOUR_API_TOKEN_HERE")
        Request.Header.Set("Content-Type", "application/json")

        Response, err := Client.Do(Request)

        if err != nil {
            fmt.Println("Error:", err)
            return
        }

        defer Response.Body.Close()

        Body, _ := io.ReadAll(Response.Body)

        var ResData map[string]interface{}
        json.Unmarshal(Body, &ResData)

        status := ResData["status"]
        message := ResData["message"]
        data := ResData["data"]

        fmt.Println(status, message, data)
}


require 'net/http'
require 'uri'
require 'json'

uri = URI('https://apicentral.dev/Image/specialEffects')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_TOKEN_HERE'
request['Content-Type'] = 'application/json'
request.body = 
{
  "image": "base64_encoded_image_string_here",
  "oil_paint": 0,
  "polaroid": 0,
  "polaroid_angle": 5,
  "swirl": 0,
  "swirl_amount": 60,
  "wave": 0,
  "wave_amplitude": 10,
  "wave_length": 50,
  "negate": 0,
  "charcoal": 0,
  "sepia": 0,
  "vignette": 0,
  "enhance_saturation": 0,
  "enhance_contrast": 0
}.to_json

response = http.request(request)
res_data = JSON.parse(response.body)

status = res_data['status']
message = res_data['message']
data = res_data['data']


import Foundation

let url = URL(string: "https://apicentral.dev/Image/specialEffects")!
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer YOUR_API_TOKEN_HERE", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let JsonPayload = """

    {
      "image": "base64_encoded_image_string_here",
      "oil_paint": 0,
      "polaroid": 0,
      "polaroid_angle": 5,
      "swirl": 0,
      "swirl_amount": 60,
      "wave": 0,
      "wave_amplitude": 10,
      "wave_length": 50,
      "negate": 0,
      "charcoal": 0,
      "sepia": 0,
      "vignette": 0,
      "enhance_saturation": 0,
      "enhance_contrast": 0
    }
""".data(using: .utf8)!
request.httpBody = JsonPayload

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let error = error {
        print("Error: \(error)")
        return
    }

    guard let data = data else { return }

    if let resData = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
        let status = resData["status"] as? String
        let message = resData["message"] as? String
        let data = resData["data"]
    }
}

task.resume()


import java.net.http.HttpClient
import java.net.http.HttpRequest
import java.net.http.HttpResponse
import java.net.URI
import java.time.Duration
import com.google.gson.JsonParser

fun main() {
        val url = "https://apicentral.dev/Image/specialEffects"
        val jsonPayload = """
        
        {
          "image": "base64_encoded_image_string_here",
          "oil_paint": 0,
          "polaroid": 0,
          "polaroid_angle": 5,
          "swirl": 0,
          "swirl_amount": 60,
          "wave": 0,
          "wave_amplitude": 10,
          "wave_length": 50,
          "negate": 0,
          "charcoal": 0,
          "sepia": 0,
          "vignette": 0,
          "enhance_saturation": 0,
          "enhance_contrast": 0
        }
        """.trimIndent()

        val client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build()

        val request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer YOUR_API_TOKEN_HERE")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(jsonPayload))
            .build()

        try {
            val response = client.send(request, HttpResponse.BodyHandlers.ofString())
            val resData = JsonParser.parseString(response.body()).asJsonObject
            val status = resData.get("status").asString
            val message = resData.get("message").asString
            val data = if (resData.has("data")) resData.get("data") else null
        } catch (e: Exception) {
            e.printStackTrace()
        }
}


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

void main() async {
    final url = Uri.parse('https://apicentral.dev/Image/specialEffects');
    final headers = {
        'Authorization': 'Bearer YOUR_API_TOKEN_HERE',
        'Content-Type': 'application/json'
    };

    final body = jsonEncode(
    {
      "image": "base64_encoded_image_string_here",
      "oil_paint": 0,
      "polaroid": 0,
      "polaroid_angle": 5,
      "swirl": 0,
      "swirl_amount": 60,
      "wave": 0,
      "wave_amplitude": 10,
      "wave_length": 50,
      "negate": 0,
      "charcoal": 0,
      "sepia": 0,
      "vignette": 0,
      "enhance_saturation": 0,
      "enhance_contrast": 0
    });

    try {
        final response = await http.post(url, headers: headers, body: body);
        final resData = jsonDecode(response.body);
        final status = resData['status'];
        final message = resData['message'];
        final data = resData['data'];
    } catch (e) {
        print('Error: $e');
    }
}


use reqwest::blocking::Client;
use serde_json::Value;

fn main() -> Result<(), Box> {
        let client = Client::new();

        let json_payload = r#"
        
        {
          "image": "base64_encoded_image_string_here",
          "oil_paint": 0,
          "polaroid": 0,
          "polaroid_angle": 5,
          "swirl": 0,
          "swirl_amount": 60,
          "wave": 0,
          "wave_amplitude": 10,
          "wave_length": 50,
          "negate": 0,
          "charcoal": 0,
          "sepia": 0,
          "vignette": 0,
          "enhance_saturation": 0,
          "enhance_contrast": 0
        }
        "#;

        let response = client
            .post("https://apicentral.dev/Image/specialEffects")
            .header("Authorization", "Bearer YOUR_API_TOKEN_HERE")
            .header("Content-Type", "application/json")
            .body(json_payload.to_string())
            .send()?;

        let res_data: Value = serde_json::from_str(&response.text()?)?;
        let status = &res_data["status"];
        let message = &res_data["message"];
        let data = &res_data["data"];

        println!("{} {} {:?}", status, message, data);

        Ok(())
}


curl -X POST 'https://apicentral.dev/Image/specialEffects' \
    -H 'Authorization: Bearer YOUR_API_TOKEN_HERE' \
    -H 'Content-Type: application/json' \
    -d '
    {
      "image": "base64_encoded_image_string_here",
      "oil_paint": 0,
      "polaroid": 0,
      "polaroid_angle": 5,
      "swirl": 0,
      "swirl_amount": 60,
      "wave": 0,
      "wave_amplitude": 10,
      "wave_length": 50,
      "negate": 0,
      "charcoal": 0,
      "sepia": 0,
      "vignette": 0,
      "enhance_saturation": 0,
      "enhance_contrast": 0
    }'

multiTool

Apply multiple image operations in a single request: convert, compress, resize, rotate, crop, flip, border, and special effects. Each enabled operation costs 1 additional credit

Credits Required: 1.0

PARAMETERS

NAME	TYPE	REQUIRED	DESCRIPTION	ADDITIONAL CREDITS PER ITEM	EXAMPLE
image	string	Yes	Base64 encoded image data (max 10MB)	None	base64_encoded_image_string_here
output_format	string	No	Target image format (e.g. png, jpg, webp). Leave empty to keep original format	1	png
quality	int	No	Compression quality from 1 to 100 (0 or empty to skip compression)	1	85
resize_mode	int	No	Resize mode: 0 = skip, 1 = by percentage, 2 = exact dimensions	1	0
resize_percentage	int	No	Resize percentage (1-500), used when resize_mode = 1	None	50
resize_width	int	No	Target width in pixels (1-8192), used when resize_mode = 2	None	800
resize_height	int	No	Target height in pixels (1-8192), used when resize_mode = 2	None	600
rotate	float	No	Rotation angle in degrees (0 to skip)	1	0
rotate_background_color	string	No	Background color for rotation (hex format or "none" for transparent)	None	none
crop_mode	int	No	Crop mode: 0 = skip, 1 = by percentage, 2 = exact coordinates	1	0
crop_percentage	int	No	Crop to this percentage of the original size (1-99), used when crop_mode = 1	None	80
crop_x	int	No	Starting X coordinate in pixels, used when crop_mode = 2	None	0
crop_y	int	No	Starting Y coordinate in pixels, used when crop_mode = 2	None	0
crop_width	int	No	Crop width in pixels, used when crop_mode = 2	None	400
crop_height	int	No	Crop height in pixels, used when crop_mode = 2	None	300
flip_mode	int	No	Flip mode: 0 = skip, 1 = horizontal, 2 = vertical, 3 = both	1	0
border_width	int	No	Border width in pixels (0 to skip)	1	0
border_height	int	No	Border height in pixels (0 to skip)	None	0
border_color	string	No	Border color in hex format (e.g. #000000)	None	#000000
oil_paint	int	No	Apply oil paint effect (0 = no, 1 = yes)	1	0
polaroid	int	No	Apply polaroid effect (0 = no, 1 = yes)	1	0
polaroid_angle	float	No	Polaroid rotation angle in degrees	None	5
swirl	int	No	Apply swirl effect (0 = no, 1 = yes)	1	0
swirl_amount	float	No	Swirl intensity in degrees	None	60
wave	int	No	Apply wave effect (0 = no, 1 = yes)	1	0
wave_amplitude	float	No	Wave amplitude in pixels	None	10
wave_length	float	No	Wave length in pixels	None	50
negate	int	No	Apply negate/invert effect (0 = no, 1 = yes)	1	0
charcoal	int	No	Apply charcoal sketch effect (0 = no, 1 = yes)	1	0
sepia	int	No	Apply sepia tone effect (0 = no, 1 = yes)	1	0
vignette	int	No	Apply vignette effect (0 = no, 1 = yes)	1	0
enhance_saturation	int	No	Enhance color saturation (0 = no, 1 = yes)	1	0
enhance_contrast	int	No	Enhance contrast / normalize (0 = no, 1 = yes)	1	0

RESPONSE EXAMPLE

{
    "status": "success",
    "message": "Image processed successfully (4 operations applied)",
    "data":
    {
        "image": "base64_encoded_result_image"
    }
}

ADDITIONAL INFO

Base cost is 1.0 credits.
- Each operation (convert, compress, resize, rotate, crop, flip, border): +1.0 credit
- Special effects: +1.0 per effect enabled
- Total cost = 1.0 + (1.0 * operations count) + (1.0 * effects count)
Operations are applied in this order: convert, rotate, crop, flip, border, resize, special effects, compress.
At least one operation must be enabled.

CODE EXAMPLES

<?php

$Curl = curl_init();

$PostFields = 
[
  'image' => 'base64_encoded_image_string_here',
  'output_format' => 'png',
  'quality' => 85,
  'resize_mode' => 0,
  'resize_percentage' => 50,
  'resize_width' => 800,
  'resize_height' => 600,
  'rotate' => 0,
  'rotate_background_color' => 'none',
  'crop_mode' => 0,
  'crop_percentage' => 80,
  'crop_x' => 0,
  'crop_y' => 0,
  'crop_width' => 400,
  'crop_height' => 300,
  'flip_mode' => 0,
  'border_width' => 0,
  'border_height' => 0,
  'border_color' => '#000000',
  'oil_paint' => 0,
  'polaroid' => 0,
  'polaroid_angle' => 5,
  'swirl' => 0,
  'swirl_amount' => 60,
  'wave' => 0,
  'wave_amplitude' => 10,
  'wave_length' => 50,
  'negate' => 0,
  'charcoal' => 0,
  'sepia' => 0,
  'vignette' => 0,
  'enhance_saturation' => 0,
  'enhance_contrast' => 0,
];

curl_setopt_array(
    $Curl,
    [
        CURLOPT_URL => 'https://apicentral.dev/Image/multiTool',
        CURLOPT_POST => true,
        CURLOPT_POSTFIELDS => http_build_query($PostFields),
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT => 30,
        CURLOPT_HTTPHEADER => 
        [
            'Authorization: Bearer YOUR_API_TOKEN_HERE',
            'Content-Type: application/x-www-form-urlencoded'
        ]
    ]
);

$Response = curl_exec($Curl);
$Data = json_decode($Response, true);

if (curl_errno($Curl))
    $Error = curl_error($Curl);
else
{
    $status = $Data['status'];
    $message = $Data['message'];
    $data = $Data['data'] ?? null;
}

curl_close($Curl); // Omit in PHP 8 and above
?>


import requests
import json

url = 'https://apicentral.dev/Image/multiTool'
Headers = {'Authorization': 'Bearer YOUR_API_TOKEN_HERE'}
Data = 
{
  "image": "base64_encoded_image_string_here",
  "output_format": "png",
  "quality": 85,
  "resize_mode": 0,
  "resize_percentage": 50,
  "resize_width": 800,
  "resize_height": 600,
  "rotate": 0,
  "rotate_background_color": "none",
  "crop_mode": 0,
  "crop_percentage": 80,
  "crop_x": 0,
  "crop_y": 0,
  "crop_width": 400,
  "crop_height": 300,
  "flip_mode": 0,
  "border_width": 0,
  "border_height": 0,
  "border_color": "#000000",
  "oil_paint": 0,
  "polaroid": 0,
  "polaroid_angle": 5,
  "swirl": 0,
  "swirl_amount": 60,
  "wave": 0,
  "wave_amplitude": 10,
  "wave_length": 50,
  "negate": 0,
  "charcoal": 0,
  "sepia": 0,
  "vignette": 0,
  "enhance_saturation": 0,
  "enhance_contrast": 0
}

try:
    Response = requests.post(url, json=Data, headers=Headers)
    ResData = Response.json()
    status = ResData.get('status')
    message = ResData.get('message')
    data = ResData.get('data')
except Exception as e:
    error = str(e)


const axios = require('axios');

const Data = 
{
  "image": "base64_encoded_image_string_here",
  "output_format": "png",
  "quality": 85,
  "resize_mode": 0,
  "resize_percentage": 50,
  "resize_width": 800,
  "resize_height": 600,
  "rotate": 0,
  "rotate_background_color": "none",
  "crop_mode": 0,
  "crop_percentage": 80,
  "crop_x": 0,
  "crop_y": 0,
  "crop_width": 400,
  "crop_height": 300,
  "flip_mode": 0,
  "border_width": 0,
  "border_height": 0,
  "border_color": "#000000",
  "oil_paint": 0,
  "polaroid": 0,
  "polaroid_angle": 5,
  "swirl": 0,
  "swirl_amount": 60,
  "wave": 0,
  "wave_amplitude": 10,
  "wave_length": 50,
  "negate": 0,
  "charcoal": 0,
  "sepia": 0,
  "vignette": 0,
  "enhance_saturation": 0,
  "enhance_contrast": 0
};

axios.post(
    'https://apicentral.dev/Image/multiTool',
    Data,
    {
        headers: {'Authorization': 'Bearer YOUR_API_TOKEN_HERE'}
    }
)
.then(Response =>
{
    const status = Response.data.status;
    const message = Response.data.message;
    const data = Response.data.data;
})
.catch(Error => { const error = Error.message; });


import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.time.Duration;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;

public class ApiExample
{
    public static void main(String[] args)
    {
        String url = "https://apicentral.dev/Image/multiTool";
        String JsonPayload = """
        
        {
          "image": "base64_encoded_image_string_here",
          "output_format": "png",
          "quality": 85,
          "resize_mode": 0,
          "resize_percentage": 50,
          "resize_width": 800,
          "resize_height": 600,
          "rotate": 0,
          "rotate_background_color": "none",
          "crop_mode": 0,
          "crop_percentage": 80,
          "crop_x": 0,
          "crop_y": 0,
          "crop_width": 400,
          "crop_height": 300,
          "flip_mode": 0,
          "border_width": 0,
          "border_height": 0,
          "border_color": "#000000",
          "oil_paint": 0,
          "polaroid": 0,
          "polaroid_angle": 5,
          "swirl": 0,
          "swirl_amount": 60,
          "wave": 0,
          "wave_amplitude": 10,
          "wave_length": 50,
          "negate": 0,
          "charcoal": 0,
          "sepia": 0,
          "vignette": 0,
          "enhance_saturation": 0,
          "enhance_contrast": 0
        }
        """;

        HttpClient Client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

        HttpRequest Request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer YOUR_API_TOKEN_HERE")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(JsonPayload))
            .build();

        try
        {
            HttpResponse Response = Client.send(Request, HttpResponse.BodyHandlers.ofString());
            JsonObject ResData = JsonParser.parseString(Response.body()).getAsJsonObject();
            String status = ResData.get("status").getAsString();
            String message = ResData.get("message").getAsString();
            Object data = ResData.has("data") ? ResData.get("data") : null;
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
}


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

public class ApiExample
{
    public static async Task Main()
    {
        using var Client = new HttpClient();
        Client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_TOKEN_HERE");

        var json_payload = @"
        {
          "image": "base64_encoded_image_string_here",
          "output_format": "png",
          "quality": 85,
          "resize_mode": 0,
          "resize_percentage": 50,
          "resize_width": 800,
          "resize_height": 600,
          "rotate": 0,
          "rotate_background_color": "none",
          "crop_mode": 0,
          "crop_percentage": 80,
          "crop_x": 0,
          "crop_y": 0,
          "crop_width": 400,
          "crop_height": 300,
          "flip_mode": 0,
          "border_width": 0,
          "border_height": 0,
          "border_color": "#000000",
          "oil_paint": 0,
          "polaroid": 0,
          "polaroid_angle": 5,
          "swirl": 0,
          "swirl_amount": 60,
          "wave": 0,
          "wave_amplitude": 10,
          "wave_length": 50,
          "negate": 0,
          "charcoal": 0,
          "sepia": 0,
          "vignette": 0,
          "enhance_saturation": 0,
          "enhance_contrast": 0
        }";
        var content = new StringContent(json_payload, Encoding.UTF8, "application/json");

        var Response = await Client.PostAsync("https://apicentral.dev/Image/multiTool", content);
        var Result = await Response.Content.ReadAsStringAsync();
        dynamic ResData = JsonConvert.DeserializeObject(Result);
        string status = ResData.status;
        string message = ResData.message;
        object data = ResData.data;
    }
}


package main

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

func main() {
        JsonPayload := []byte(`
        {
          "image": "base64_encoded_image_string_here",
          "output_format": "png",
          "quality": 85,
          "resize_mode": 0,
          "resize_percentage": 50,
          "resize_width": 800,
          "resize_height": 600,
          "rotate": 0,
          "rotate_background_color": "none",
          "crop_mode": 0,
          "crop_percentage": 80,
          "crop_x": 0,
          "crop_y": 0,
          "crop_width": 400,
          "crop_height": 300,
          "flip_mode": 0,
          "border_width": 0,
          "border_height": 0,
          "border_color": "#000000",
          "oil_paint": 0,
          "polaroid": 0,
          "polaroid_angle": 5,
          "swirl": 0,
          "swirl_amount": 60,
          "wave": 0,
          "wave_amplitude": 10,
          "wave_length": 50,
          "negate": 0,
          "charcoal": 0,
          "sepia": 0,
          "vignette": 0,
          "enhance_saturation": 0,
          "enhance_contrast": 0
        }`)

        Client := &http.Client{}
        Request, _ := http.NewRequest("POST", "https://apicentral.dev/Image/multiTool", bytes.NewBuffer(JsonPayload))
        Request.Header.Set("Authorization", "Bearer YOUR_API_TOKEN_HERE")
        Request.Header.Set("Content-Type", "application/json")

        Response, err := Client.Do(Request)

        if err != nil {
            fmt.Println("Error:", err)
            return
        }

        defer Response.Body.Close()

        Body, _ := io.ReadAll(Response.Body)

        var ResData map[string]interface{}
        json.Unmarshal(Body, &ResData)

        status := ResData["status"]
        message := ResData["message"]
        data := ResData["data"]

        fmt.Println(status, message, data)
}


require 'net/http'
require 'uri'
require 'json'

uri = URI('https://apicentral.dev/Image/multiTool')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_TOKEN_HERE'
request['Content-Type'] = 'application/json'
request.body = 
{
  "image": "base64_encoded_image_string_here",
  "output_format": "png",
  "quality": 85,
  "resize_mode": 0,
  "resize_percentage": 50,
  "resize_width": 800,
  "resize_height": 600,
  "rotate": 0,
  "rotate_background_color": "none",
  "crop_mode": 0,
  "crop_percentage": 80,
  "crop_x": 0,
  "crop_y": 0,
  "crop_width": 400,
  "crop_height": 300,
  "flip_mode": 0,
  "border_width": 0,
  "border_height": 0,
  "border_color": "#000000",
  "oil_paint": 0,
  "polaroid": 0,
  "polaroid_angle": 5,
  "swirl": 0,
  "swirl_amount": 60,
  "wave": 0,
  "wave_amplitude": 10,
  "wave_length": 50,
  "negate": 0,
  "charcoal": 0,
  "sepia": 0,
  "vignette": 0,
  "enhance_saturation": 0,
  "enhance_contrast": 0
}.to_json

response = http.request(request)
res_data = JSON.parse(response.body)

status = res_data['status']
message = res_data['message']
data = res_data['data']


import Foundation

let url = URL(string: "https://apicentral.dev/Image/multiTool")!
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer YOUR_API_TOKEN_HERE", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let JsonPayload = """

    {
      "image": "base64_encoded_image_string_here",
      "output_format": "png",
      "quality": 85,
      "resize_mode": 0,
      "resize_percentage": 50,
      "resize_width": 800,
      "resize_height": 600,
      "rotate": 0,
      "rotate_background_color": "none",
      "crop_mode": 0,
      "crop_percentage": 80,
      "crop_x": 0,
      "crop_y": 0,
      "crop_width": 400,
      "crop_height": 300,
      "flip_mode": 0,
      "border_width": 0,
      "border_height": 0,
      "border_color": "#000000",
      "oil_paint": 0,
      "polaroid": 0,
      "polaroid_angle": 5,
      "swirl": 0,
      "swirl_amount": 60,
      "wave": 0,
      "wave_amplitude": 10,
      "wave_length": 50,
      "negate": 0,
      "charcoal": 0,
      "sepia": 0,
      "vignette": 0,
      "enhance_saturation": 0,
      "enhance_contrast": 0
    }
""".data(using: .utf8)!
request.httpBody = JsonPayload

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let error = error {
        print("Error: \(error)")
        return
    }

    guard let data = data else { return }

    if let resData = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
        let status = resData["status"] as? String
        let message = resData["message"] as? String
        let data = resData["data"]
    }
}

task.resume()


import java.net.http.HttpClient
import java.net.http.HttpRequest
import java.net.http.HttpResponse
import java.net.URI
import java.time.Duration
import com.google.gson.JsonParser

fun main() {
        val url = "https://apicentral.dev/Image/multiTool"
        val jsonPayload = """
        
        {
          "image": "base64_encoded_image_string_here",
          "output_format": "png",
          "quality": 85,
          "resize_mode": 0,
          "resize_percentage": 50,
          "resize_width": 800,
          "resize_height": 600,
          "rotate": 0,
          "rotate_background_color": "none",
          "crop_mode": 0,
          "crop_percentage": 80,
          "crop_x": 0,
          "crop_y": 0,
          "crop_width": 400,
          "crop_height": 300,
          "flip_mode": 0,
          "border_width": 0,
          "border_height": 0,
          "border_color": "#000000",
          "oil_paint": 0,
          "polaroid": 0,
          "polaroid_angle": 5,
          "swirl": 0,
          "swirl_amount": 60,
          "wave": 0,
          "wave_amplitude": 10,
          "wave_length": 50,
          "negate": 0,
          "charcoal": 0,
          "sepia": 0,
          "vignette": 0,
          "enhance_saturation": 0,
          "enhance_contrast": 0
        }
        """.trimIndent()

        val client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build()

        val request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer YOUR_API_TOKEN_HERE")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(jsonPayload))
            .build()

        try {
            val response = client.send(request, HttpResponse.BodyHandlers.ofString())
            val resData = JsonParser.parseString(response.body()).asJsonObject
            val status = resData.get("status").asString
            val message = resData.get("message").asString
            val data = if (resData.has("data")) resData.get("data") else null
        } catch (e: Exception) {
            e.printStackTrace()
        }
}


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

void main() async {
    final url = Uri.parse('https://apicentral.dev/Image/multiTool');
    final headers = {
        'Authorization': 'Bearer YOUR_API_TOKEN_HERE',
        'Content-Type': 'application/json'
    };

    final body = jsonEncode(
    {
      "image": "base64_encoded_image_string_here",
      "output_format": "png",
      "quality": 85,
      "resize_mode": 0,
      "resize_percentage": 50,
      "resize_width": 800,
      "resize_height": 600,
      "rotate": 0,
      "rotate_background_color": "none",
      "crop_mode": 0,
      "crop_percentage": 80,
      "crop_x": 0,
      "crop_y": 0,
      "crop_width": 400,
      "crop_height": 300,
      "flip_mode": 0,
      "border_width": 0,
      "border_height": 0,
      "border_color": "#000000",
      "oil_paint": 0,
      "polaroid": 0,
      "polaroid_angle": 5,
      "swirl": 0,
      "swirl_amount": 60,
      "wave": 0,
      "wave_amplitude": 10,
      "wave_length": 50,
      "negate": 0,
      "charcoal": 0,
      "sepia": 0,
      "vignette": 0,
      "enhance_saturation": 0,
      "enhance_contrast": 0
    });

    try {
        final response = await http.post(url, headers: headers, body: body);
        final resData = jsonDecode(response.body);
        final status = resData['status'];
        final message = resData['message'];
        final data = resData['data'];
    } catch (e) {
        print('Error: $e');
    }
}


use reqwest::blocking::Client;
use serde_json::Value;

fn main() -> Result<(), Box> {
        let client = Client::new();

        let json_payload = r#"
        
        {
          "image": "base64_encoded_image_string_here",
          "output_format": "png",
          "quality": 85,
          "resize_mode": 0,
          "resize_percentage": 50,
          "resize_width": 800,
          "resize_height": 600,
          "rotate": 0,
          "rotate_background_color": "none",
          "crop_mode": 0,
          "crop_percentage": 80,
          "crop_x": 0,
          "crop_y": 0,
          "crop_width": 400,
          "crop_height": 300,
          "flip_mode": 0,
          "border_width": 0,
          "border_height": 0,
          "border_color": "#000000",
          "oil_paint": 0,
          "polaroid": 0,
          "polaroid_angle": 5,
          "swirl": 0,
          "swirl_amount": 60,
          "wave": 0,
          "wave_amplitude": 10,
          "wave_length": 50,
          "negate": 0,
          "charcoal": 0,
          "sepia": 0,
          "vignette": 0,
          "enhance_saturation": 0,
          "enhance_contrast": 0
        }
        "#;

        let response = client
            .post("https://apicentral.dev/Image/multiTool")
            .header("Authorization", "Bearer YOUR_API_TOKEN_HERE")
            .header("Content-Type", "application/json")
            .body(json_payload.to_string())
            .send()?;

        let res_data: Value = serde_json::from_str(&response.text()?)?;
        let status = &res_data["status"];
        let message = &res_data["message"];
        let data = &res_data["data"];

        println!("{} {} {:?}", status, message, data);

        Ok(())
}


curl -X POST 'https://apicentral.dev/Image/multiTool' \
    -H 'Authorization: Bearer YOUR_API_TOKEN_HERE' \
    -H 'Content-Type: application/json' \
    -d '
    {
      "image": "base64_encoded_image_string_here",
      "output_format": "png",
      "quality": 85,
      "resize_mode": 0,
      "resize_percentage": 50,
      "resize_width": 800,
      "resize_height": 600,
      "rotate": 0,
      "rotate_background_color": "none",
      "crop_mode": 0,
      "crop_percentage": 80,
      "crop_x": 0,
      "crop_y": 0,
      "crop_width": 400,
      "crop_height": 300,
      "flip_mode": 0,
      "border_width": 0,
      "border_height": 0,
      "border_color": "#000000",
      "oil_paint": 0,
      "polaroid": 0,
      "polaroid_angle": 5,
      "swirl": 0,
      "swirl_amount": 60,
      "wave": 0,
      "wave_amplitude": 10,
      "wave_length": 50,
      "negate": 0,
      "charcoal": 0,
      "sepia": 0,
      "vignette": 0,
      "enhance_saturation": 0,
      "enhance_contrast": 0
    }'

APICENTRAL.DEV

IMAGE API

convert

PARAMETERS

RESPONSE EXAMPLE

CODE EXAMPLES

compress

PARAMETERS

RESPONSE EXAMPLE

CODE EXAMPLES

resize

PARAMETERS

RESPONSE EXAMPLE

CODE EXAMPLES

rotate

PARAMETERS

RESPONSE EXAMPLE

CODE EXAMPLES

crop

PARAMETERS

RESPONSE EXAMPLE

CODE EXAMPLES

flip

PARAMETERS

RESPONSE EXAMPLE

CODE EXAMPLES

border

PARAMETERS

RESPONSE EXAMPLE

CODE EXAMPLES

combine

PARAMETERS

RESPONSE EXAMPLE

CODE EXAMPLES

specialEffects

PARAMETERS

RESPONSE EXAMPLE

CODE EXAMPLES

multiTool

PARAMETERS

RESPONSE EXAMPLE

ADDITIONAL INFO

CODE EXAMPLES