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 de VisaPics - API de Procesamiento de Fotos para Desarrolladores

Endpoints de API

Endpoints Potentes

Todo lo que necesitas para procesamiento profesional de fotos

Eliminación de Fondo

Eliminación de fondo impulsada por IA con soporte para blanco, transparente o colores personalizados incluyendo valores hexadecimales.

$0.10/solicitud ~2s

Mejora Facial con IA

Mejora facial impulsada por GFPGAN para mejorar la calidad, corregir imperfecciones y realzar detalles faciales.

$0.15/solicitud ~3s

Marcas de Agua Personalizadas

Añade marcas de agua de texto o imagen con posición, opacidad, rotación y patrones de mosaico personalizables.

$0.05/solicitud ~1s

Metadatos EXIF

Extrae datos EXIF completos incluyendo información de cámara, coordenadas GPS y configuración de exposición.

GRATIS <1s

Protección de Privacidad

Elimina todos los metadatos EXIF para privacidad mientras opcionalmente preservas la orientación de la imagen.

GRATIS <1s

Procesamiento de Fotos de Visa

Procesamiento completo de fotos de visa/pasaporte con más de 952 especificaciones de documentos de 172 países.

$0.20-0.50 ~5s

Descuentos por Volumen

Precios de Pago por Uso

Deposita fondos en tu saldo de API. Obtén descuentos automáticos con depósitos más altos.

Básico

$0.50

por foto

Cualquier monto de depósito

20% OFF

Inicial

$0.40

por foto

Depósito de $50+

40% OFF

Profesional

$0.30

por foto

Depósito de $100+

60% OFF

Empresarial

$0.20

por foto

Depósito de $500+

Endpoints de utilidad con precio como porcentaje de la tarifa de foto: Eliminación BG (20%), Mejora (30%), Marca de agua (10%)

Los endpoints EXIF son siempre gratis

Cookbook de API

Ejemplos de Código Completos

Ejemplos listos para usar en múltiples lenguajes

Eliminación de Fondo

Elimina el fondo y reemplázalo con blanco, transparente o color personalizado.

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

Mejora Facial con IA

Mejora las características faciales y la calidad de la 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 de Agua Personalizadas

Añade marcas de agua de texto o imagen con opciones de personalización 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
}

Metadatos EXIF (Gratis)

Lee o elimina metadatos EXIF de las 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
}

Procesamiento Completo de Fotos de Visa

Procesamiento completo de fotos de visa/pasaporte con recorte automático, eliminación de fondo y verificación de cumplimiento.

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
}

Comienza en Minutos

¿Listo para Construir?

Obtén tu clave API gratis y comienza a integrar en minutos

1

Crear Cuenta

Regístrate gratis y accede a tu panel de desarrollador

2

Obtener Clave API

Genera tu clave API desde el panel

3

Empezar a Construir

Integra la API usando nuestros ejemplos del cookbook

Crear Cuenta Gratis Ver Documentación Completa

Preguntas Frecuentes

¿Cómo obtengo una clave API?

Crea una cuenta gratis en visapics.org, luego ve a tu Panel de Cuenta > Claves API para generar una nueva clave. Puedes crear múltiples claves con diferentes nombres para diferentes aplicaciones.

¿Cuál es el límite de tasa?

El límite de tasa predeterminado es 1000 solicitudes por hora por clave API. ¿Necesitas límites más altos? Contáctanos para planes empresariales con límites de tasa personalizados.

¿Cómo funciona la facturación?

Modelo de pago por uso. Deposita fondos en tu saldo de API, luego cada solicitud se deduce de tu saldo. Depósitos más altos desbloquean tarifas más bajas por solicitud. Los endpoints EXIF son siempre gratis.

¿Qué formatos de imagen son compatibles?

Soportamos archivos de entrada JPEG y PNG de hasta 10MB. La salida es JPEG por defecto, o PNG para fondos transparentes.

¿Hay un entorno sandbox/de prueba?

Recomendamos usar los endpoints EXIF (que son gratis) para probar tu integración. Para endpoints de pago, los costos comienzan en solo $0.05 por solicitud.