Quickstart

dependencies: [
    .package(url: "https://github.com/Vouch-IN/vouch-sdk-ios", from: "0.1.7")
]

dependencies {
    implementation 'com.vouch:vouch-sdk:0.1.7'
}

import { VouchProvider, useValidateEmail } from '@vouch-in/react';
import { useState } from 'react';

function App() {
  return (
    <VouchProvider
      projectId="your-project-id"
      apiKey="your-client-api-key"
    >
      <SignupForm />
    </VouchProvider>
  );
}

function SignupForm() {
  const { validate, loading, data, error } = useValidateEmail();
  const [email, setEmail] = useState('');

  const handleSubmit = async (e) => {
    e.preventDefault();
    const result = await validate(email);

    if (result.recommendation === 'allow') {
      // Proceed with signup
      console.log('Email is valid!');
    }
  };

  return (
    <form onSubmit={handleSubmit}>
      <input
        type="email"
        value={email}
        onChange={(e) => setEmail(e.target.value)}
      />
      <button disabled={loading}>
        {loading ? 'Validating...' : 'Sign Up'}
      </button>

      {data && data.recommendation !== 'allow' && (
        <p>{data.message}</p>
      )}
      {error && <p>{error.message}</p>}
    </form>
  );
}

import { Vouch } from '@vouch-in/node';

// Initialize with your server key
const vouch = new Vouch(
  'your-project-id',
  'your-server-api-key'
);

// Validate an email (server-side)
const result = await vouch.validate('[email protected]', {
  ip: request.ip,
  userAgent: request.headers['user-agent']
});

// Check the recommendation
if (result.recommendation === 'allow') {
  // Create user account
  console.log('Email is valid!');
} else {
  // Use the message field for a user-friendly error
  console.log(result.message); // e.g. "Please use a permanent email address, not a temporary one."
}

// app/api/validate/route.ts
import { Vouch } from '@vouch-in/next';

const vouch = new Vouch(
  process.env.VOUCH_PROJECT_ID!,
  process.env.VOUCH_SERVER_KEY!
);

export async function POST(request: Request) {
  const { email } = await request.json();

  const result = await vouch.validate(email, {
    ip: request.headers.get('x-forwarded-for') || undefined,
    userAgent: request.headers.get('user-agent') || undefined,
  });

  if (result.recommendation !== 'allow') {
    return Response.json({ error: result.message }, { status: 400 });
  }

  return Response.json({ success: true });
}

// app/signup/page.tsx (Client)
'use client';

import { VouchProvider, useValidateEmail } from '@vouch-in/next/client';

export default function SignupPage() {
  return (
    <VouchProvider
      projectId={process.env.NEXT_PUBLIC_VOUCH_PROJECT_ID!}
      apiKey={process.env.NEXT_PUBLIC_VOUCH_CLIENT_KEY!}
    >
      <SignupForm />
    </VouchProvider>
  );
}

import VouchSDK

let vouch = Vouch(
    projectId: "your-project-id",
    apiKey: "your-client-api-key"
)

Button("Sign Up") {
      Task{
        do {
            let result = try await vouch.validate(email)

            if let data = result.data {
                switch data {
                case .validation(let validationData):
                    if validationData.recommendation == .allow {
                        // Create account
                        print("Email is valid!")
                    } else {
                        // Example: check specific signals
                        if validationData.checks["syntax"]?.pass == false {
                            print("Invalid email format")
                        } else {
                            print("Blocked: \(validationData.recommendation.rawValue)")
                        }
                    }

                case .error(let errorData):
                    print("Validation error: \(errorData.message)")
                }
            } else {
                print(result.error ?? "Email validation failed")
            }
        } catch {
            print("Validation failed: \(error.localizedDescription)")
        }
    }
}

import expert.vouch.sdk.Vouch
import kotlinx.coroutines.launch

val vouch = Vouch(
    context = applicationContext,
    projectId = "your-project-id",
    apiKey = "your-client-api-key"
)

Button(onClick = {
    scope.launch {
        try {
            val result = vouch.validate(email)

            result.data?.let { data ->
                when (data) {
                    is ValidationData.Validation -> {
                        val response = data.response

                        if (response.recommendation == "allow") {
                            // Create account
                            println("Email is valid!")
                        } else {
                            // Example: check specific signal
                            if (response.signals["syntax"]?.pass == false) {
                                println("Invalid email format")
                            } else {
                                println("Blocked: ${response.recommendation}")
                            }
                        }
                    }

                    is ValidationData.Error -> {
                        println("Validation error: ${data.response.message}")
                    }
                }
            }

        } catch (e: Exception) {
            println("Validation failed: ${e.message}")
        }
    }
}) {
    Text("Sign Up")
}