Client Libraries

import Veriscopia from '@veriscopia/node';

const client = new Veriscopia({
  apiKey: process.env.VERISCOPIA_API_KEY
});

const result = await client.documents.verify({
  documentImage: imageBase64,
  documentType: 'passport',
  country: 'US',
  enhancedAI: true
});

console.log(`Status: ${result.status}, Confidence: ${result.confidence}`);

import veriscopia
import asyncio

client = veriscopia.Client(
    api_key=os.environ['VERISCOPIA_API_KEY']
)

async def verify_document():
    result = await client.documents.verify_async(
        document_image=image_base64,
        document_type='passport',
        country='US'
    )
    print(f"Status: {result.status}, AI Confidence: {result.confidence}")

asyncio.run(verify_document())

package main

import (
    "context"
    "fmt"
    "github.com/veriscopia/go"
)

func main() {
    client := veriscopia.NewClient(
        os.Getenv("VERISCOPIA_API_KEY"),
    )
    
    ctx := context.Background()
    result, err := client.Documents.Verify(ctx, &veriscopia.DocumentVerifyParams{
        DocumentImage: imageBase64,
        DocumentType:  "passport",
        Country:       "US",
    })
    
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Printf("Status: %s, Confidence: %.1f%%\n", 
        result.Status, result.Confidence*100)
}

require 'veriscopia'

client = Veriscopia::Client.new(
  api_key: ENV['VERISCOPIA_API_KEY']
)

result = client.documents.verify(
  document_image: image_base64,
  document_type: 'passport', 
  country: 'US',
  enhanced_ai: true
)

puts "Status: #{result.status}, AI Model: #{result.ai_model}"

import com.veriscopia.Client;
import com.veriscopia.models.DocumentVerification;

Client client = Client.builder()
    .apiKey(System.getenv("VERISCOPIA_API_KEY"))
    .build();

DocumentVerification result = client.documents()
    .verify(DocumentVerification.builder()
        .documentImage(imageBase64)
        .documentType("passport")
        .country("US")
        .build());

System.out.printf("Status: %s, Confidence: %.1f%%%n",
    result.getStatus(), result.getConfidence() * 100);

use veriscopia::Client;
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new(env::var("VERISCOPIA_API_KEY")?);
    
    let result = client.documents()
        .verify(&DocumentVerifyParams {
            document_image: image_base64,
            document_type: "passport".to_string(),
            country: "US".to_string(),
            enhanced_ai: true,
        })
        .await?;
    
    println!("Status: {}, Confidence: {:.1}%", 
        result.status, result.confidence * 100.0);
    Ok(())
}