Official SDKs

import { Proof } from '@proof/sdk';

const proof = new Proof('pk_live_your_key');

// Create a phone verification
const verification = await proof.verifications.create({
  type: 'phone',
  channel: 'whatsapp',
  identifier: '+37069199199',
});

console.log(verification.challenge.deep_link);
// "https://wa.me/...?text=X7K2M9"

// Poll until verified (or timeout)
const result = await proof.verifications.waitForCompletion(verification.id);
console.log(result.proof.token);
// "eyJhbGciOiJSUzI1NiI..."

import asyncio
from proof_sdk import Proof

async def main():
    async with Proof("pk_live_your_key") as proof:
        # Create a phone verification
        verification = await proof.verifications.create(
            type="phone",
            channel="telegram",
            identifier="+37069199199",
        )

        print(verification["challenge"]["deep_link"])

        # Poll until verified
        result = await proof.verifications.wait_for_completion(verification["id"])
        print(result["proof"]["token"])

asyncio.run(main())

use Proof\Proof;

$proof = new Proof('pk_live_your_key');

// Create a phone verification
$verification = $proof->verifications->create([
    'type' => 'phone',
    'channel' => 'sms',
    'identifier' => '+37069199199',
]);

echo $verification['challenge']['code'];

// Poll until verified
$result = $proof->verifications->waitForCompletion($verification['id']);
echo $result['proof']['token'];

package main

import (
    "context"
    "fmt"
    proof "github.com/ProofHoldings/sdk-go"
)

func main() {
    client, _ := proof.NewClient("pk_live_your_key")

    // Create a phone verification
    verification, _ := client.Verifications.Create(context.Background(), map[string]any{
        "type":       "phone",
        "channel":    "whatsapp",
        "identifier": "+37069199199",
    })

    fmt.Println(verification["challenge"].(map[string]any)["deep_link"])

    // Poll until verified
    result, _ := client.Verifications.WaitForCompletion(
        context.Background(),
        verification["id"].(string),
        nil,
    )
    fmt.Println(result["proof"].(map[string]any)["token"])
}

// JavaScript — full test flow
const proof = new Proof('pk_test_your_key');

const verification = await proof.verifications.create({
  type: 'phone',
  channel: 'whatsapp',
  identifier: '+37069199199',
});

// Auto-complete without waiting for user action
const result = await proof.verifications.testVerify(verification.id);
console.log(result.proof_token); // Valid JWT, same as production

# Python — full test flow
async with Proof("pk_test_your_key") as proof:
    verification = await proof.verifications.create(
        type="phone", channel="telegram", identifier="+37069199199",
    )
    result = await proof.verifications.test_verify(verification["id"])
    print(result["proof_token"])

const verification = await proof.verifications.create({
  type: 'email',
  channel: 'email',
  identifier: '[email protected]',
  external_user_id: 'usr_123',
  callback_url: 'https://yourapp.com/webhook',
});

verification = await proof.verifications.create(
    type="email",
    channel="email",
    identifier="[email protected]",
    external_user_id="usr_123",
    callback_url="https://yourapp.com/webhook",
)

$verification = $proof->verifications->create([
    'type' => 'email',
    'channel' => 'email',
    'identifier' => '[email protected]',
    'external_user_id' => 'usr_123',
    'callback_url' => 'https://yourapp.com/webhook',
]);

verification, err := client.Verifications.Create(ctx, map[string]any{
    "type":              "email",
    "channel":           "email",
    "identifier":        "[email protected]",
    "external_user_id":  "usr_123",
    "callback_url":      "https://yourapp.com/webhook",
})

const result = await proof.verifications.waitForCompletion('ver_123', {
  interval: 1000,    // 1 second
  timeout: 30000,    // 30 seconds
});

result = await proof.verifications.wait_for_completion(
    "ver_123",
    interval=1.0,   # 1 second
    timeout=30.0,    # 30 seconds
)

$result = $proof->verifications->waitForCompletion(
    'ver_123',
    interval: 1.0,   // 1 second
    timeout: 30.0,    // 30 seconds
);

result, err := client.Verifications.WaitForCompletion(ctx, "ver_123", &proof.WaitOptions{
    Interval: 1 * time.Second,
    Timeout:  30 * time.Second,
})

import { ValidationError, NotFoundError } from '@proof/sdk';

try {
  await proof.verifications.retrieve('invalid_id');
} catch (err) {
  if (err instanceof NotFoundError) {
    console.log('Not found:', err.message);
  } else if (err instanceof ValidationError) {
    console.log('Validation:', err.details);
  }
}

from proof_sdk.errors import NotFoundError, ValidationError

try:
    await proof.verifications.retrieve("invalid_id")
except NotFoundError as e:
    print(f"Not found: {e.message}")
except ValidationError as e:
    print(f"Validation: {e.details}")

use Proof\Exceptions\NotFoundException;
use Proof\Exceptions\ValidationException;

try {
    $proof->verifications->retrieve('invalid_id');
} catch (NotFoundException $e) {
    echo "Not found: " . $e->getMessage();
} catch (ValidationException $e) {
    echo "Validation: " . print_r($e->details, true);
}

import "errors"

result, err := client.Verifications.Retrieve(ctx, "invalid_id")
if err != nil {
    var nfErr *proof.NotFoundError
    var valErr *proof.ValidationError
    if errors.As(err, &nfErr) {
        fmt.Println("Not found:", nfErr.Message)
    } else if errors.As(err, &valErr) {
        fmt.Println("Validation:", valErr.Details)
    }
}

const proof = new Proof('pk_live_...', {
  maxRetries: 5,
  timeout: 60000,
});

proof = Proof(
    "pk_live_...",
    max_retries=5,
    timeout=60.0,
)

$proof = new Proof(
    'pk_live_...',
    maxRetries: 5,
    timeout: 60.0,
);

client, _ := proof.NewClient("pk_live_...",
    proof.WithMaxRetries(5),
    proof.WithTimeout(60 * time.Second),
)

// JavaScript
const result = await proof.proofs.validate('eyJhbGciOiJSUzI1NiI...');
console.log(result.valid);       // true
console.log(result.verification); // { type, channel, verified_at, ... }

# Python
result = await proof.proofs.validate("eyJhbGciOiJSUzI1NiI...")
print(result["valid"])  # True

// PHP
$result = $proof->proofs->validate('eyJhbGciOiJSUzI1NiI...');
echo $result['valid'];  // true

// Go
result, _ := client.Proofs.Validate(ctx, "eyJhbGciOiJSUzI1NiI...")
fmt.Println(result["valid"])  // true

// JavaScript
const request = await proof.verificationRequests.create({
  assets: [
    { type: 'phone', required: true },
    { type: 'email', required: true },
    { type: 'domain', required: false },
  ],
  reference_id: 'onboarding_user_123',
});

// Poll for completion
const completed = await proof.verificationRequests.waitForCompletion(request.id);

# Python
request = await proof.verification_requests.create(
    assets=[
        {"type": "phone", "required": True},
        {"type": "email", "required": True},
        {"type": "domain", "required": False},
    ],
    reference_id="onboarding_user_123",
)

completed = await proof.verification_requests.wait_for_completion(request["id"])

// List failed deliveries
const failed = await proof.webhookDeliveries.list({ status: 'failed' });

// Retry a delivery
await proof.webhookDeliveries.retry('del_123');