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.

API VisaPics - API de Processamento de Fotos para Desenvolvedores

Endpoints da API

Endpoints Poderosos

Tudo o que você precisa para processamento profissional de fotos

Remoção de Fundo

Remoção de fundo com IA com suporte para branco, transparente ou cores personalizadas incluindo valores hexadecimais.

$0.10/requisição ~2s

Aprimoramento Facial com IA

Aprimoramento facial com GFPGAN para melhorar qualidade, corrigir imperfeições e realçar detalhes faciais.

$0.15/requisição ~3s

Marcas d'Água Personalizadas

Adicione marcas d'água de texto ou imagem com posição, opacidade, rotação e padrões de ladrilho personalizáveis.

$0.05/requisição ~1s

Metadados EXIF

Extraia dados EXIF completos incluindo informações da câmera, coordenadas GPS e configurações de exposição.

GRÁTIS <1s

Proteção de Privacidade

Remova todos os metadados EXIF para privacidade enquanto opcionalmente preserva a orientação da imagem.

GRÁTIS <1s

Processamento de Fotos de Visto

Processamento completo de fotos de visto/passaporte com mais de 952 especificações de documentos de 172 países.

$0.20-0.50 ~5s

Descontos por Volume

Preços Pay-As-You-Go

Deposite fundos em seu saldo de API. Obtenha descontos automáticos com depósitos maiores.

Básico

$0.50

por foto

Qualquer valor de depósito

20% OFF

Iniciante

$0.40

por foto

Depósito de $50+

40% OFF

Profissional

$0.30

por foto

Depósito de $100+

60% OFF

Empresarial

$0.20

por foto

Depósito de $500+

Endpoints utilitários com preço como porcentagem da taxa de foto: Remoção BG (20%), Aprimoramento (30%), Marca d'água (10%)

Endpoints EXIF são sempre grátis

Cookbook da API

Exemplos de Código Completos

Exemplos prontos para uso em múltiplas linguagens

Remoção de Fundo

Remova o fundo e substitua por branco, transparente ou cor personalizada.

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"])
}

Aprimoramento Facial com IA

Aprimore características faciais e qualidade da foto usando 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
}

Marcas d'Água Personalizadas

Adicione marcas d'água de texto ou imagem com opções de personalização completas.

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
}

Metadados EXIF (Grátis)

Leia ou remova metadados EXIF das fotos.

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
}

Processamento Completo de Foto de Visto

Processamento completo de fotos de visto/passaporte com recorte automático, remoção de fundo e verificação de conformidade.

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
}

Comece em Minutos

Pronto para Construir?

Obtenha sua chave API grátis e comece a integrar em minutos

1

Criar Conta

Registre-se gratuitamente e acesse seu painel de desenvolvedor

2

Obter Chave API

Gere sua chave API no painel

3

Começar a Construir

Integre a API usando nossos exemplos do cookbook

Criar Conta Grátis Ver Documentação Completa

Perguntas Frequentes

Como obtenho uma chave API?

Crie uma conta grátis em visapics.org, depois vá para seu Painel de Conta > Chaves API para gerar uma nova chave. Você pode criar múltiplas chaves com nomes diferentes para diferentes aplicações.

Qual é o limite de taxa?

O limite de taxa padrão é 1000 requisições por hora por chave API. Precisa de limites maiores? Entre em contato conosco para planos empresariais com limites de taxa personalizados.

Como funciona a cobrança?

Modelo pague conforme usa. Deposite fundos em seu saldo de API, então cada requisição é deduzida do seu saldo. Depósitos maiores desbloqueiam taxas mais baixas por requisição. Endpoints EXIF são sempre grátis.

Quais formatos de imagem são suportados?

Suportamos arquivos de entrada JPEG e PNG até 10MB. A saída é JPEG por padrão, ou PNG para fundos transparentes.

Existe um ambiente sandbox/teste?

Recomendamos usar os endpoints EXIF (que são grátis) para testar sua integração. Para endpoints pagos, os custos começam em apenas $0,05 por requisição.