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 API - डेवलपर्स के लिए फ़ोटो प्रोसेसिंग API

API एंडपॉइंट्स

शक्तिशाली एंडपॉइंट्स

पेशेवर फ़ोटो प्रोसेसिंग के लिए आवश्यक सब कुछ

पृष्ठभूमि हटाना

सफेद, पारदर्शी या कस्टम रंगों सहित हेक्स मानों के समर्थन के साथ AI-संचालित पृष्ठभूमि हटाना।

$0.10/अनुरोध ~2s

AI चेहरा संवर्धन

गुणवत्ता सुधारने, दोष ठीक करने और चेहरे के विवरण बढ़ाने के लिए GFPGAN-संचालित चेहरा संवर्धन।

$0.15/अनुरोध ~3s

कस्टम वॉटरमार्क

अनुकूलन योग्य स्थिति, अपारदर्शिता, रोटेशन और टाइल पैटर्न के साथ टेक्स्ट या इमेज वॉटरमार्क जोड़ें।

$0.05/अनुरोध ~1s

EXIF मेटाडेटा

कैमरा जानकारी, GPS निर्देशांक और एक्सपोज़र सेटिंग्स सहित पूर्ण EXIF डेटा निकालें।

मुफ्त <1s

गोपनीयता सुरक्षा

गोपनीयता के लिए सभी EXIF मेटाडेटा हटाएं जबकि वैकल्पिक रूप से छवि अभिविन्यास को संरक्षित करें।

मुफ्त <1s

वीज़ा फ़ोटो प्रोसेसिंग

172 देशों से 952+ दस्तावेज़ विनिर्देशों के साथ पूर्ण वीज़ा/पासपोर्ट फ़ोटो प्रोसेसिंग।

$0.20-0.50 ~5s

वॉल्यूम छूट

पे-एज़-यू-गो मूल्य निर्धारण

अपने API बैलेंस में धनराशि जमा करें। उच्च जमा राशि के साथ स्वचालित छूट प्राप्त करें।

बेसिक

$0.50

प्रति फोटो

कोई भी जमा राशि

20% OFF

स्टार्टर

$0.40

प्रति फोटो

$50+ जमा

40% OFF

प्रोफेशनल

$0.30

प्रति फोटो

$100+ जमा

60% OFF

एंटरप्राइज़

$0.20

प्रति फोटो

$500+ जमा

यूटिलिटी एंडपॉइंट्स फ़ोटो दर के प्रतिशत के रूप में मूल्यांकित: BG हटाना (20%), संवर्धन (30%), वॉटरमार्क (10%)

EXIF एंडपॉइंट्स हमेशा मुफ्त हैं

API कुकबुक

पूर्ण कोड उदाहरण

कई भाषाओं में उपयोग के लिए तैयार उदाहरण

पृष्ठभूमि हटाना

पृष्ठभूमि हटाएं और सफेद, पारदर्शी या कस्टम रंग से बदलें।

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 चेहरा संवर्धन

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
}

कस्टम वॉटरमार्क

पूर्ण अनुकूलन विकल्पों के साथ टेक्स्ट या इमेज वॉटरमार्क जोड़ें।

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 मेटाडेटा (मुफ्त)

फ़ोटो से EXIF मेटाडेटा पढ़ें या हटाएं।

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
}

पूर्ण वीज़ा फ़ोटो प्रोसेसिंग

स्वचालित क्रॉपिंग, पृष्ठभूमि हटाने और अनुपालन जांच के साथ पूर्ण वीज़ा/पासपोर्ट फ़ोटो प्रोसेसिंग।

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
}

मिनटों में शुरू करें

बनाने के लिए तैयार?

अपनी मुफ्त API कुंजी प्राप्त करें और मिनटों में एकीकरण शुरू करें

1

खाता बनाएं

मुफ्त में साइन अप करें और अपने डेवलपर डैशबोर्ड तक पहुंचें

2

API कुंजी प्राप्त करें

डैशबोर्ड से अपनी API कुंजी जनरेट करें

3

बनाना शुरू करें

हमारे कुकबुक उदाहरणों का उपयोग करके API को एकीकृत करें

मुफ्त खाता बनाएं पूर्ण दस्तावेज़ीकरण देखें

अक्सर पूछे जाने वाले प्रश्न

मैं API कुंजी कैसे प्राप्त करूं?

visapics.org पर एक मुफ्त खाता बनाएं, फिर अपने खाता डैशबोर्ड > API कुंजी पर जाएं और एक नई कुंजी जनरेट करें। आप विभिन्न एप्लिकेशन के लिए अलग-अलग नामों के साथ कई कुंजी बना सकते हैं।

दर सीमा क्या है?

डिफ़ॉल्ट दर सीमा प्रति API कुंजी प्रति घंटे 1000 अनुरोध है। उच्च सीमाओं की आवश्यकता है? कस्टम दर सीमाओं के साथ एंटरप्राइज़ योजनाओं के लिए हमसे संपर्क करें।

बिलिंग कैसे काम करती है?

उपयोग-अनुसार-भुगतान मॉडल। अपने API बैलेंस में धनराशि जमा करें, फिर प्रत्येक अनुरोध आपके बैलेंस से कटता है। उच्च जमा राशि कम प्रति-अनुरोध दरें अनलॉक करती है। EXIF एंडपॉइंट्स हमेशा मुफ्त हैं।

कौन से छवि प्रारूप समर्थित हैं?

हम 10MB तक की JPEG और PNG इनपुट फ़ाइलों का समर्थन करते हैं। आउटपुट डिफ़ॉल्ट रूप से JPEG है, या पारदर्शी पृष्ठभूमि के लिए PNG।

क्या कोई सैंडबॉक्स/टेस्ट वातावरण है?

हम अपने एकीकरण का परीक्षण करने के लिए EXIF एंडपॉइंट्स (जो मुफ्त हैं) का उपयोग करने की सलाह देते हैं। भुगतान एंडपॉइंट्स के लिए, लागत केवल $0.05 प्रति अनुरोध से शुरू होती है।

फ़ोटो प्रोसेसिंग API डेवलपर्स के लिए

शक्तिशाली एंडपॉइंट्स

पृष्ठभूमि हटाना

AI चेहरा संवर्धन

कस्टम वॉटरमार्क

EXIF मेटाडेटा

गोपनीयता सुरक्षा

वीज़ा फ़ोटो प्रोसेसिंग

पे-एज़-यू-गो मूल्य निर्धारण

बेसिक

स्टार्टर

प्रोफेशनल

एंटरप्राइज़

पूर्ण कोड उदाहरण

पृष्ठभूमि हटाना

AI चेहरा संवर्धन

कस्टम वॉटरमार्क

EXIF मेटाडेटा (मुफ्त)

पूर्ण वीज़ा फ़ोटो प्रोसेसिंग

बनाने के लिए तैयार?

खाता बनाएं

API कुंजी प्राप्त करें

बनाना शुरू करें

अक्सर पूछे जाने वाले प्रश्न