VisaPics is a professional online service that creates compliant passport and visa photos for 952+ document types from 172 countries. We use AI technology to automatically remove backgrounds, detect faces, and ensure compliance with official government requirements.

How many countries and document types does VisaPics support?

VisaPics supports 952+ document types (passports, visas, IDs, etc.) from 172 countries worldwide. Each specification is verified against official government sources to ensure 100% compliance.

How much does VisaPics cost?

Single photo costs $3.99 USD. We also offer discounted bundles: 5 photos for $14.99 ($2.99/photo), 10 photos for $24.99 ($2.49/photo), and 25 photos for $49.99 ($1.99/photo). Credits are valid for 1 year.

What do I get when I purchase a photo?

Each purchase includes a high-resolution digital photo compliant with official requirements, and a printable version optimized for professional printing. Both formats are instantly downloadable.

Are the photos guaranteed to be accepted?

Yes. All our specifications are sourced from official government websites and verified for 100% compliance. We guarantee that photos meet all technical requirements including size, background, face position, and measurements.

VisaPics - Professional Passport Photos for 172 Countries

API Endpoints

Powerful Endpoints

Everything you need for professional photo processing

Background Removal

AI-powered background removal with support for white, transparent, or custom colors including hex values.

$0.10/request ~2s

AI Face Enhancement

GFPGAN-powered face enhancement to improve quality, fix blemishes, and enhance facial details.

$0.15/request ~3s

Custom Watermarks

Add text or image watermarks with customizable position, opacity, rotation, and tile patterns.

$0.05/request ~1s

EXIF Metadata

Extract complete EXIF data including camera info, GPS coordinates, and exposure settings.

FREE <1s

Privacy Protection

Strip all EXIF metadata for privacy while optionally preserving image orientation.

FREE <1s

Visa Photo Processing

Complete visa/passport photo processing with 952+ document specifications from 172 countries.

$0.20-0.50 ~5s

Volume Discounts

Simple Pay-As-You-Go Pricing

Deposit funds to your API balance. Get automatic discounts with higher deposits.

Base

$0.50

per photo

Any deposit amount

20% OFF

Starter

$0.40

per photo

$50+ deposit

40% OFF

Professional

$0.30

per photo

$100+ deposit

60% OFF

Enterprise

$0.20

per photo

$500+ deposit

Utility endpoints priced as percentage of photo rate: BG Removal (20%), Enhancement (30%), Watermark (10%)

EXIF endpoints are always free

API Cookbook

Complete Code Examples

Ready-to-use examples in multiple languages

Background Removal

Remove background and replace with white, transparent, or custom color.

POST /api/v1/photo/remove-background

# White background
curl -X POST "https://visapics.org/api/v1/photo/remove-background" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "photo=@portrait.jpg" \
  -F "background_color=white"

# Transparent background (PNG output)
curl -X POST "https://visapics.org/api/v1/photo/remove-background" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "photo=@portrait.jpg" \
  -F "background_color=transparent"

# Custom hex color
curl -X POST "https://visapics.org/api/v1/photo/remove-background" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "photo=@portrait.jpg" \
  -F "background_color=#87CEEB"

Python

import requests

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://visapics.org/api/v1"

def remove_background(image_path, background_color="white"):
    """Remove background from an image."""
    with open(image_path, "rb") as f:
        response = requests.post(
            f"{BASE_URL}/photo/remove-background",
            headers={"Authorization": f"Bearer {API_KEY}"},
            files={"photo": f},
            data={"background_color": background_color}
        )

    if response.json()["success"]:
        photo_url = response.json()["data"]["photo_url"]
        # Download the processed image
        result = requests.get(f"https://visapics.org{photo_url}")
        with open("output.jpg", "wb") as out:
            out.write(result.content)
        return response.json()["data"]
    else:
        raise Exception(response.json()["error"]["message"])

# Usage
result = remove_background("portrait.jpg", "transparent")
print(f"Charged: ${result['billing']['charged_usd']}")

JavaScript (Node.js)

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

const API_KEY = 'YOUR_API_KEY';
const BASE_URL = 'https://visapics.org/api/v1';

async function removeBackground(imagePath, backgroundColor = 'white') {
    const form = new FormData();
    form.append('photo', fs.createReadStream(imagePath));
    form.append('background_color', backgroundColor);

    const response = await axios.post(
        `${BASE_URL}/photo/remove-background`,
        form,
        {
            headers: {
                'Authorization': `Bearer ${API_KEY}`,
                ...form.getHeaders()
            }
        }
    );

    if (response.data.success) {
        // Download the result
        const photoUrl = response.data.data.photo_url;
        const result = await axios.get(`https://visapics.org${photoUrl}`, {
            responseType: 'arraybuffer'
        });
        fs.writeFileSync('output.jpg', result.data);
        return response.data.data;
    }
    throw new Error(response.data.error.message);
}

// Usage
removeBackground('portrait.jpg', '#87CEEB')
    .then(data => console.log(`Charged: $${data.billing.charged_usd}`));

PHP

<?php
$apiKey = 'YOUR_API_KEY';
$baseUrl = 'https://visapics.org/api/v1';

function removeBackground($imagePath, $backgroundColor = 'white') {
    global $apiKey, $baseUrl;

    $curl = curl_init();
    $cfile = new CURLFile($imagePath);

    curl_setopt_array($curl, [
        CURLOPT_URL => "$baseUrl/photo/remove-background",
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_POST => true,
        CURLOPT_POSTFIELDS => [
            'photo' => $cfile,
            'background_color' => $backgroundColor
        ],
        CURLOPT_HTTPHEADER => [
            "Authorization: Bearer $apiKey"
        ]
    ]);

    $response = curl_exec($curl);
    curl_close($curl);

    $data = json_decode($response, true);

    if ($data['success']) {
        // Download result
        $photoUrl = $data['data']['photo_url'];
        $result = file_get_contents("https://visapics.org$photoUrl");
        file_put_contents('output.jpg', $result);
        return $data['data'];
    }
    throw new Exception($data['error']['message']);
}

// Usage
$result = removeBackground('portrait.jpg', 'transparent');
echo "Charged: $" . $result['billing']['charged_usd'];

Go

package main

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

const (
    apiKey  = "YOUR_API_KEY"
    baseURL = "https://visapics.org/api/v1"
)

func removeBackground(imagePath, backgroundColor string) (map[string]interface{}, error) {
    file, _ := os.Open(imagePath)
    defer file.Close()

    body := &bytes.Buffer{}
    writer := multipart.NewWriter(body)
    part, _ := writer.CreateFormFile("photo", imagePath)
    io.Copy(part, file)
    writer.WriteField("background_color", backgroundColor)
    writer.Close()

    req, _ := http.NewRequest("POST", baseURL+"/photo/remove-background", body)
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", writer.FormDataContentType())

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    return result["data"].(map[string]interface{}), nil
}

func main() {
    result, _ := removeBackground("portrait.jpg", "white")
    println("Charged: $", result["billing"].(map[string]interface{})["charged_usd"])
}

AI Face Enhancement

Enhance facial features and improve photo quality using GFPGAN.

POST /api/v1/photo/enhance

curl -X POST "https://visapics.org/api/v1/photo/enhance" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "photo=@portrait.jpg" \
  -F "output_format=url"

Python

def enhance_face(image_path):
    """Enhance facial features in an image."""
    with open(image_path, "rb") as f:
        response = requests.post(
            f"{BASE_URL}/photo/enhance",
            headers={"Authorization": f"Bearer {API_KEY}"},
            files={"photo": f}
        )
    return response.json()["data"]

# Usage
result = enhance_face("portrait.jpg")
print(f"Enhanced: {result['photo_url']}")

JavaScript

async function enhanceFace(imagePath) {
    const form = new FormData();
    form.append('photo', fs.createReadStream(imagePath));

    const response = await axios.post(
        `${BASE_URL}/photo/enhance`,
        form,
        { headers: { 'Authorization': `Bearer ${API_KEY}`, ...form.getHeaders() } }
    );
    return response.data.data;
}

// Usage
const result = await enhanceFace('portrait.jpg');
console.log(`Enhanced: ${result.photo_url}`);

PHP

function enhanceFace($imagePath) {
    global $apiKey, $baseUrl;
    $curl = curl_init();
    curl_setopt_array($curl, [
        CURLOPT_URL => "$baseUrl/photo/enhance",
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_POST => true,
        CURLOPT_POSTFIELDS => ['photo' => new CURLFile($imagePath)],
        CURLOPT_HTTPHEADER => ["Authorization: Bearer $apiKey"]
    ]);
    $response = curl_exec($curl);
    curl_close($curl);
    return json_decode($response, true)['data'];
}

Go

func enhanceFace(imagePath string) (map[string]interface{}, error) {
    file, _ := os.Open(imagePath)
    defer file.Close()
    body := &bytes.Buffer{}
    writer := multipart.NewWriter(body)
    part, _ := writer.CreateFormFile("photo", imagePath)
    io.Copy(part, file)
    writer.Close()
    req, _ := http.NewRequest("POST", baseURL+"/photo/enhance", body)
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", writer.FormDataContentType())
    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()
    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    return result["data"].(map[string]interface{}), nil
}

Custom Watermarks

Add text or image watermarks with full customization options.

POST /api/v1/photo/watermark

# Text watermark in corner
curl -X POST "https://visapics.org/api/v1/photo/watermark" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "photo=@image.jpg" \
  -F "watermark_type=text" \
  -F "text=© MyCompany 2025" \
  -F "position=bottom-right" \
  -F "font_size=24" \
  -F "color=#FFFFFF" \
  -F "opacity=0.7"

# Tile watermark pattern
curl -X POST "https://visapics.org/api/v1/photo/watermark" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "photo=@image.jpg" \
  -F "watermark_type=text" \
  -F "text=SAMPLE" \
  -F "position=tile" \
  -F "opacity=0.3"

# Image watermark (logo)
curl -X POST "https://visapics.org/api/v1/photo/watermark" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "photo=@image.jpg" \
  -F "watermark_type=image" \
  -F "watermark_image=@logo.png" \
  -F "position=bottom-right" \
  -F "opacity=0.5"

Python

def add_watermark(image_path, text, position="bottom-right",
                  font_size=24, color="#FFFFFF", opacity=0.5):
    """Add text watermark to an image."""
    with open(image_path, "rb") as f:
        response = requests.post(
            f"{BASE_URL}/photo/watermark",
            headers={"Authorization": f"Bearer {API_KEY}"},
            files={"photo": f},
            data={
                "watermark_type": "text",
                "text": text,
                "position": position,
                "font_size": font_size,
                "color": color,
                "opacity": opacity
            }
        )
    return response.json()["data"]

# Text watermark
result = add_watermark("image.jpg", "© 2025", opacity=0.7)

# Tile watermark
result = add_watermark("image.jpg", "CONFIDENTIAL", position="tile", opacity=0.2)

JavaScript

async function addWatermark(imagePath, options = {}) {
    const form = new FormData();
    form.append('photo', fs.createReadStream(imagePath));
    form.append('watermark_type', options.type || 'text');
    form.append('text', options.text || '');
    form.append('position', options.position || 'bottom-right');
    form.append('font_size', options.fontSize || 24);
    form.append('color', options.color || '#FFFFFF');
    form.append('opacity', options.opacity || 0.5);

    const response = await axios.post(
        `${BASE_URL}/photo/watermark`, form,
        { headers: { 'Authorization': `Bearer ${API_KEY}`, ...form.getHeaders() } }
    );
    return response.data.data;
}

// Usage
const result = await addWatermark('image.jpg', {
    text: '© MyCompany',
    position: 'bottom-right',
    opacity: 0.7
});

PHP

function addWatermark($imagePath, $text, $options = []) {
    global $apiKey, $baseUrl;
    $defaults = ['position' => 'bottom-right', 'opacity' => 0.5, 'font_size' => 24];
    $options = array_merge($defaults, $options);

    $curl = curl_init();
    curl_setopt_array($curl, [
        CURLOPT_URL => "$baseUrl/photo/watermark",
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_POST => true,
        CURLOPT_POSTFIELDS => [
            'photo' => new CURLFile($imagePath),
            'watermark_type' => 'text',
            'text' => $text,
            'position' => $options['position'],
            'opacity' => $options['opacity'],
            'font_size' => $options['font_size']
        ],
        CURLOPT_HTTPHEADER => ["Authorization: Bearer $apiKey"]
    ]);
    $response = curl_exec($curl);
    curl_close($curl);
    return json_decode($response, true)['data'];
}

Go

func addWatermark(imagePath, text, position string, opacity float64) (map[string]interface{}, error) {
    file, _ := os.Open(imagePath)
    defer file.Close()
    body := &bytes.Buffer{}
    writer := multipart.NewWriter(body)
    part, _ := writer.CreateFormFile("photo", imagePath)
    io.Copy(part, file)
    writer.WriteField("watermark_type", "text")
    writer.WriteField("text", text)
    writer.WriteField("position", position)
    writer.WriteField("opacity", fmt.Sprintf("%f", opacity))
    writer.Close()
    req, _ := http.NewRequest("POST", baseURL+"/photo/watermark", body)
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", writer.FormDataContentType())
    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()
    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    return result["data"].(map[string]interface{}), nil
}

EXIF Metadata (Free)

Read or remove EXIF metadata from photos.

EXIF Endpoints

# Read EXIF data
curl -X POST "https://visapics.org/api/v1/photo/exif" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "photo=@image.jpg"

# Remove EXIF data (strip metadata for privacy)
curl -X POST "https://visapics.org/api/v1/photo/exif/remove" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "photo=@image.jpg" \
  -F "keep_orientation=true"

Python

def read_exif(image_path):
    """Read EXIF metadata from image."""
    with open(image_path, "rb") as f:
        response = requests.post(
            f"{BASE_URL}/photo/exif",
            headers={"Authorization": f"Bearer {API_KEY}"},
            files={"photo": f}
        )
    return response.json()["data"]["exif"]

def strip_exif(image_path, keep_orientation=True):
    """Remove EXIF metadata for privacy."""
    with open(image_path, "rb") as f:
        response = requests.post(
            f"{BASE_URL}/photo/exif/remove",
            headers={"Authorization": f"Bearer {API_KEY}"},
            files={"photo": f},
            data={"keep_orientation": keep_orientation}
        )
    return response.json()["data"]

# Usage
exif = read_exif("photo.jpg")
print(f"Camera: {exif['basic']['make']} {exif['basic']['model']}")

cleaned = strip_exif("photo.jpg")
print(f"EXIF removed: {cleaned['exif_removed']}")

JavaScript

async function readExif(imagePath) {
    const form = new FormData();
    form.append('photo', fs.createReadStream(imagePath));
    const response = await axios.post(`${BASE_URL}/photo/exif`, form, {
        headers: { 'Authorization': `Bearer ${API_KEY}`, ...form.getHeaders() }
    });
    return response.data.data.exif;
}

async function stripExif(imagePath, keepOrientation = true) {
    const form = new FormData();
    form.append('photo', fs.createReadStream(imagePath));
    form.append('keep_orientation', keepOrientation);
    const response = await axios.post(`${BASE_URL}/photo/exif/remove`, form, {
        headers: { 'Authorization': `Bearer ${API_KEY}`, ...form.getHeaders() }
    });
    return response.data.data;
}

// Usage
const exif = await readExif('photo.jpg');
console.log(`Camera: ${exif.basic.make} ${exif.basic.model}`);

PHP

function readExif($imagePath) {
    global $apiKey, $baseUrl;
    $curl = curl_init();
    curl_setopt_array($curl, [
        CURLOPT_URL => "$baseUrl/photo/exif",
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_POST => true,
        CURLOPT_POSTFIELDS => ['photo' => new CURLFile($imagePath)],
        CURLOPT_HTTPHEADER => ["Authorization: Bearer $apiKey"]
    ]);
    $response = curl_exec($curl);
    curl_close($curl);
    return json_decode($response, true)['data']['exif'];
}

function stripExif($imagePath, $keepOrientation = true) {
    global $apiKey, $baseUrl;
    $curl = curl_init();
    curl_setopt_array($curl, [
        CURLOPT_URL => "$baseUrl/photo/exif/remove",
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_POST => true,
        CURLOPT_POSTFIELDS => [
            'photo' => new CURLFile($imagePath),
            'keep_orientation' => $keepOrientation ? 'true' : 'false'
        ],
        CURLOPT_HTTPHEADER => ["Authorization: Bearer $apiKey"]
    ]);
    $response = curl_exec($curl);
    curl_close($curl);
    return json_decode($response, true)['data'];
}

Go

func readExif(imagePath string) (map[string]interface{}, error) {
    file, _ := os.Open(imagePath)
    defer file.Close()
    body := &bytes.Buffer{}
    writer := multipart.NewWriter(body)
    part, _ := writer.CreateFormFile("photo", imagePath)
    io.Copy(part, file)
    writer.Close()
    req, _ := http.NewRequest("POST", baseURL+"/photo/exif", body)
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", writer.FormDataContentType())
    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()
    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    data := result["data"].(map[string]interface{})
    return data["exif"].(map[string]interface{}), nil
}

Full Visa Photo Processing

Complete visa/passport photo processing with automatic cropping, background removal, and compliance checking.

POST /api/v1/photo/process

# US Passport Photo
curl -X POST "https://visapics.org/api/v1/photo/process" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "photo=@selfie.jpg" \
  -F "country_code=US" \
  -F "document_type=Passport" \
  -F "remove_background=true" \
  -F "enhance_photo=true"

# UK Passport (Digital Code)
curl -X POST "https://visapics.org/api/v1/photo/process" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "photo=@selfie.jpg" \
  -F "country_code=GB" \
  -F "document_type=Passport"

# Schengen Visa
curl -X POST "https://visapics.org/api/v1/photo/process" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "photo=@selfie.jpg" \
  -F "country_code=EU" \
  -F "document_type=Schengen Visa"

Python

def process_visa_photo(image_path, country_code, document_type,
                       remove_background=True, enhance_photo=True):
    """Process a photo for visa/passport requirements."""
    with open(image_path, "rb") as f:
        response = requests.post(
            f"{BASE_URL}/photo/process",
            headers={"Authorization": f"Bearer {API_KEY}"},
            files={"photo": f},
            data={
                "country_code": country_code,
                "document_type": document_type,
                "remove_background": remove_background,
                "enhance_photo": enhance_photo
            }
        )

    data = response.json()["data"]

    # Download results
    digital_url = data["digital_photo_url"]
    printable_url = data["printable_photo_url"]

    return {
        "compliance": data["compliance"],
        "digital_url": f"https://visapics.org{digital_url}",
        "printable_url": f"https://visapics.org{printable_url}",
        "specification": data["specification"]
    }

# Usage
result = process_visa_photo("selfie.jpg", "US", "Passport")
print(f"Photo size: {result['specification']['photo_size']}")
print(f"Compliant: {result['compliance']['overall_success']}")

JavaScript

async function processVisaPhoto(imagePath, countryCode, documentType, options = {}) {
    const form = new FormData();
    form.append('photo', fs.createReadStream(imagePath));
    form.append('country_code', countryCode);
    form.append('document_type', documentType);
    form.append('remove_background', options.removeBackground !== false);
    form.append('enhance_photo', options.enhancePhoto !== false);

    const response = await axios.post(`${BASE_URL}/photo/process`, form, {
        headers: { 'Authorization': `Bearer ${API_KEY}`, ...form.getHeaders() }
    });

    const data = response.data.data;
    return {
        compliance: data.compliance,
        digitalUrl: `https://visapics.org${data.digital_photo_url}`,
        printableUrl: `https://visapics.org${data.printable_photo_url}`,
        specification: data.specification
    };
}

// Usage
const result = await processVisaPhoto('selfie.jpg', 'US', 'Passport');
console.log(`Compliant: ${result.compliance.overall_success}`);

PHP

function processVisaPhoto($imagePath, $countryCode, $documentType, $options = []) {
    global $apiKey, $baseUrl;
    $curl = curl_init();
    curl_setopt_array($curl, [
        CURLOPT_URL => "$baseUrl/photo/process",
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_POST => true,
        CURLOPT_POSTFIELDS => [
            'photo' => new CURLFile($imagePath),
            'country_code' => $countryCode,
            'document_type' => $documentType,
            'remove_background' => $options['remove_background'] ?? 'true',
            'enhance_photo' => $options['enhance_photo'] ?? 'true'
        ],
        CURLOPT_HTTPHEADER => ["Authorization: Bearer $apiKey"]
    ]);
    $response = curl_exec($curl);
    curl_close($curl);
    $data = json_decode($response, true)['data'];
    return [
        'compliance' => $data['compliance'],
        'digital_url' => "https://visapics.org" . $data['digital_photo_url'],
        'printable_url' => "https://visapics.org" . $data['printable_photo_url']
    ];
}

Go

func processVisaPhoto(imagePath, countryCode, documentType string) (map[string]interface{}, error) {
    file, _ := os.Open(imagePath)
    defer file.Close()
    body := &bytes.Buffer{}
    writer := multipart.NewWriter(body)
    part, _ := writer.CreateFormFile("photo", imagePath)
    io.Copy(part, file)
    writer.WriteField("country_code", countryCode)
    writer.WriteField("document_type", documentType)
    writer.WriteField("remove_background", "true")
    writer.WriteField("enhance_photo", "true")
    writer.Close()
    req, _ := http.NewRequest("POST", baseURL+"/photo/process", body)
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", writer.FormDataContentType())
    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()
    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    return result["data"].(map[string]interface{}), nil
}

Get Started in Minutes

Ready to Build?

Get your free API key and start integrating in minutes

1

Create Account

Sign up for free and access your developer dashboard

2

Get API Key

Generate your API key from the dashboard

3

Start Building

Integrate the API using our cookbook examples

Create Free Account View Full Documentation

Frequently Asked Questions

How do I get an API key?

Create a free account at visapics.org, then go to your Account Dashboard > API Keys to generate a new key. You can create multiple keys with different names for different applications.

What's the rate limit?

Default rate limit is 1000 requests per hour per API key. Need higher limits? Contact us for enterprise plans with custom rate limits.

How does billing work?

Pay-as-you-go model. Deposit funds to your API balance, then each request deducts from your balance. Higher deposits unlock lower per-request rates. EXIF endpoints are always free.

What image formats are supported?

We support JPEG and PNG input files up to 10MB. Output is JPEG by default, or PNG for transparent backgrounds.

Is there a sandbox/test environment?

We recommend using the EXIF endpoints (which are free) to test your integration. For paid endpoints, costs start at just $0.05 per request.

Photo Processing API for Developers

Powerful Endpoints

Background Removal

AI Face Enhancement

Custom Watermarks

EXIF Metadata

Privacy Protection

Visa Photo Processing

Simple Pay-As-You-Go Pricing

Base

Starter

Professional

Enterprise

Complete Code Examples

Background Removal

AI Face Enhancement

Custom Watermarks

EXIF Metadata (Free)

Full Visa Photo Processing

Ready to Build?

Create Account

Get API Key

Start Building

Frequently Asked Questions