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 Traitement Photo pour Développeurs

Points de Terminaison API

Points de Terminaison Puissants

Tout ce dont vous avez besoin pour le traitement photo professionnel

Suppression d'Arrière-plan

Suppression d'arrière-plan alimentée par IA avec support pour blanc, transparent ou couleurs personnalisées incluant les valeurs hexadécimales.

$0.10/requête ~2s

Amélioration Faciale IA

Amélioration faciale alimentée par GFPGAN pour améliorer la qualité, corriger les imperfections et rehausser les détails du visage.

$0.15/requête ~3s

Filigranes Personnalisés

Ajoutez des filigranes texte ou image avec position, opacité, rotation et motifs de tuiles personnalisables.

$0.05/requête ~1s

Métadonnées EXIF

Extrayez les données EXIF complètes incluant les informations de l'appareil photo, les coordonnées GPS et les paramètres d'exposition.

GRATUIT <1s

Protection de la Vie Privée

Supprimez toutes les métadonnées EXIF pour la confidentialité tout en préservant optionnellement l'orientation de l'image.

GRATUIT <1s

Traitement de Photos Visa

Traitement complet de photos visa/passeport avec plus de 952 spécifications de documents de 172 pays.

$0.20-0.50 ~5s

Remises sur Volume

Tarification à la Consommation

Déposez des fonds sur votre solde API. Obtenez des remises automatiques avec des dépôts plus élevés.

Base

$0.50

par photo

Tout montant de dépôt

20% OFF

Débutant

$0.40

par photo

Dépôt de 50$+

40% OFF

Professionnel

$0.30

par photo

Dépôt de 100$+

60% OFF

Entreprise

$0.20

par photo

Dépôt de 500$+

Points de terminaison utilitaires tarifés en pourcentage du tarif photo: Suppression BG (20%), Amélioration (30%), Filigrane (10%)

Les points de terminaison EXIF sont toujours gratuits

Cookbook API

Exemples de Code Complets

Exemples prêts à l'emploi dans plusieurs langages

Suppression d'Arrière-plan

Supprimez l'arrière-plan et remplacez-le par du blanc, transparent ou une couleur personnalisée.

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

Amélioration Faciale IA

Améliorez les traits du visage et la qualité de la photo avec 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
}

Filigranes Personnalisés

Ajoutez des filigranes texte ou image avec des options de personnalisation complètes.

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
}

Métadonnées EXIF (Gratuit)

Lisez ou supprimez les métadonnées EXIF des 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
}

Traitement Complet de Photos Visa

Traitement complet de photos visa/passeport avec recadrage automatique, suppression d'arrière-plan et vérification de conformité.

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
}

Commencez en Minutes

Prêt à Construire?

Obtenez votre clé API gratuite et commencez à intégrer en minutes

1

Créer un Compte

Inscrivez-vous gratuitement et accédez à votre tableau de bord développeur

2

Obtenir une Clé API

Générez votre clé API depuis le tableau de bord

3

Commencer à Construire

Intégrez l'API en utilisant nos exemples du cookbook

Créer un Compte Gratuit Voir la Documentation Complète

Questions Fréquemment Posées

Comment obtenir une clé API?

Créez un compte gratuit sur visapics.org, puis allez dans votre Tableau de Bord > Clés API pour générer une nouvelle clé. Vous pouvez créer plusieurs clés avec des noms différents pour différentes applications.

Quelle est la limite de taux?

La limite de taux par défaut est de 1000 requêtes par heure par clé API. Besoin de limites plus élevées? Contactez-nous pour des plans entreprise avec des limites de taux personnalisées.

Comment fonctionne la facturation?

Modèle de paiement à l'usage. Déposez des fonds sur votre solde API, puis chaque requête est déduite de votre solde. Des dépôts plus élevés débloquent des tarifs plus bas par requête. Les points de terminaison EXIF sont toujours gratuits.

Quels formats d'image sont supportés?

Nous supportons les fichiers d'entrée JPEG et PNG jusqu'à 10MB. La sortie est JPEG par défaut, ou PNG pour les arrière-plans transparents.

Y a-t-il un environnement sandbox/test?

Nous recommandons d'utiliser les points de terminaison EXIF (qui sont gratuits) pour tester votre intégration. Pour les points de terminaison payants, les coûts commencent à seulement 0,05$ par requête.