Getting started overview

Integrating with Verifier involves a series of steps to enable email validation in applications. This guide outlines the process from account creation to executing a first API call. The core functionality of Verifier is to determine the validity and deliverability of email addresses, which can be applied to reduce bounce rates, prevent fraudulent sign-ups, and maintain clean mailing lists. Verifier offers both real-time API verification and bulk list processing options, catering to different operational needs.

The process typically begins with creating an account to access the Verifier dashboard. From there, an API key is generated and serves as the authentication credential for all programmatic interactions. This key is then included in API requests to the Verifier endpoint. The API itself is RESTful, accepting HTTP GET or POST requests and returning JSON responses with verification results. Developers can choose to integrate directly using cURL or leverage code examples provided in multiple programming languages to streamline the integration process.

Before making live calls, it is advisable to review the Verifier API reference documentation to understand the available endpoints, request parameters, and response structures. This preparatory step helps in designing the integration logic and handling various verification outcomes effectively. Verifier's architecture is designed for straightforward integration, aiming to provide email validation capabilities with minimal setup overhead.

Create an account and get keys

To begin using Verifier, the initial step is to create an account on the official Verifier website. This account provides access to the user dashboard, where API keys are managed and usage statistics are monitored.

  1. Navigate to Verifier.me: Open your web browser and go to the Verifier homepage.
  2. Sign Up: Locate the 'Sign Up' or 'Get Started Free' button, typically found in the top right corner or prominent on the main page. Click this button to initiate the registration process.
  3. Provide Registration Details: You will be prompted to enter an email address and create a password. Ensure the email address is valid as it may be used for account verification.
  4. Account Verification (if applicable): Some registration processes require email verification. Check your inbox for a verification email from Verifier and follow the instructions to confirm your account.
  5. Access Dashboard: Once registered and logged in, you will be directed to your Verifier dashboard. This central hub displays your usage, plan details, and most importantly, your API key.
  6. Locate API Key: Within the dashboard, there will be a section dedicated to 'API Key' or 'Developer Settings'. Your unique API key will be displayed here. This key is crucial for authenticating your API requests. For security, treat your API key like a password and avoid exposing it in client-side code or public repositories.
  7. Copy API Key: Copy the generated API key. It is a long alphanumeric string that will be included in the query parameters of your API calls.

Verifier offers 100 free verifications upon account creation, allowing users to test the service before committing to a paid plan. This free tier is sufficient for initial setup and testing of the API integration.

Your first request

After obtaining your API key, you can make your first email verification request. This example uses cURL, a command-line tool for making HTTP requests, which is universally applicable across different programming environments. Verifier's API is accessible via a simple HTTP GET request.

API Endpoint

The primary endpoint for real-time email verification is:

https://api.verifier.me/v1/verify

Request Parameters

The essential parameters for a verification request are:

  • email: The email address you want to verify.
  • key: Your unique API key obtained from your Verifier dashboard.

Example cURL Request

Replace YOUR_API_KEY with your actual API key and [email protected] with the email address you wish to verify.

curl -X GET "https://api.verifier.me/v1/[email protected]&key=YOUR_API_KEY"

Expected JSON Response

A successful response will return a JSON object containing details about the email address. The structure typically includes a status field indicating the verification result (e.g., 'valid', 'invalid', 'risky'), along with other relevant data such as whether the email is disposable, a free email, or if it has a catch-all domain.

{
    "email": "[email protected]",
    "status": "valid",
    "deliverability": "deliverable",
    "quality_score": 0.85,
    "is_disposable": false,
    "is_free": true,
    "is_catchall": false,
    "domain": "example.com",
    "reason": ""
}

The status and deliverability fields are key indicators of the email's validity. A 'valid' status combined with 'deliverable' indicates a high likelihood that the email can receive messages. For a comprehensive list of possible statuses and their meanings, refer to the Verifier API reference.

Quick Reference for First Request

Step What to do Where
1. Get API Key Log in to Verifier dashboard and copy your API key. verifier.me > Dashboard > API Key section
2. Construct URL Build the API endpoint with email and key parameters. https://api.verifier.me/v1/verify?email=YOUR_EMAIL&key=YOUR_API_KEY
3. Execute Request Use cURL or an HTTP client in your preferred language. Terminal (cURL) or application code
4. Interpret Response Parse the JSON response to check status and deliverability. Application code

Common next steps

After successfully making your first verification call, several common next steps can enhance your integration and leverage Verifier's full capabilities:

  1. Integrate into Application Logic: Embed the API call into your application's workflow. This could be during user registration, form submissions, or before sending marketing emails. For example, a common pattern is to validate emails client-side (if appropriate for the application's security model) or server-side before storing them in a database or initiating further processes.
  2. Error Handling: Implement robust error handling for API responses. The Verifier API returns standard HTTP status codes (e.g., 400 for bad requests, 401 for unauthorized) and specific error messages in the JSON response. Your application should be able to gracefully handle these scenarios, such as invalid API keys or malformed email addresses.
  3. Rate Limiting and Usage Monitoring: Be aware of any rate limits imposed by Verifier based on your plan. Monitor your API usage through your Verifier dashboard to ensure you stay within your allocated verification limits. Implement retry logic with exponential backoff for transient errors or rate limit responses, as described in common API integration patterns by sources like Google Cloud's API key best practices.
  4. Bulk Verification: If you have existing email lists that need cleaning, explore Verifier's bulk verification feature. This typically involves uploading a CSV file to the Verifier dashboard or using a dedicated bulk API endpoint (if available) to process a large number of emails efficiently.
  5. Webhooks for Asynchronous Processing: For certain use cases, especially with bulk verifications or when real-time processing is not strictly necessary, consider using webhooks. Webhooks allow Verifier to notify your application when a verification process is complete, pushing data to a specified URL. This reduces the need for constant polling and can improve system efficiency. Twilio's documentation on understanding webhooks provides a general overview of how these work.
  6. Review Advanced Features: Verifier may offer advanced features such as custom settings for verification strictness, integration with email marketing platforms, or detailed analytics. Review the Verifier documentation for these capabilities to optimize your email validation strategy.
  7. Security Best Practices: Ensure your API key is stored securely (e.g., environment variables, secret management services) and never hardcoded in your application's source code or exposed in client-side applications.

Troubleshooting the first call

Encountering issues during your first API call is common. Here's a guide to troubleshoot typical problems:

  • Incorrect API Key:
    • Symptom: HTTP 401 Unauthorized response or an error message indicating an invalid key.
    • Solution: Double-check that the API key in your request exactly matches the one in your Verifier dashboard. Ensure there are no leading or trailing spaces, and that the key is correctly passed as the key parameter.
  • Malformed Request URL or Parameters:
    • Symptom: HTTP 400 Bad Request response or an error message stating missing/invalid parameters.
    • Solution: Verify the API endpoint URL is correct (https://api.verifier.me/v1/verify). Confirm that the email and key parameters are correctly spelled and properly URL-encoded. For example, special characters in an email address might need encoding, though typically standard email formats do not require this for basic validation.
  • Network Connectivity Issues:
    • Symptom: Request timeout or connection refused.
    • Solution: Check your internet connection. If running from a server, ensure it has outbound access to api.verifier.me. Temporarily try making the cURL request from a different network or a local machine to rule out network-specific blockages.
  • Exceeded Free Tier/Rate Limits:
    • Symptom: Error message indicating usage limits or a 429 Too Many Requests HTTP status code.
    • Solution: If you are using the free tier, you may have exhausted your 100 free verifications. Check your Verifier dashboard for current usage. If on a paid plan, review your plan's rate limits and consider upgrading or implementing rate limiting in your application.
  • Firewall or Proxy Restrictions:
    • Symptom: Requests blocked or connection errors, especially in corporate environments.
    • Solution: If you are behind a corporate firewall or proxy, you may need to configure your cURL command or HTTP client to use the proxy. Consult your network administrator for proxy settings.
  • Incorrect HTTP Method:
    • Symptom: HTTP 405 Method Not Allowed response.
    • Solution: Ensure you are using the correct HTTP method (GET for verification, as per the example).
  • Review Documentation:
    • Solution: If the above steps do not resolve the issue, consult the Verifier API reference for specific error codes and troubleshooting sections.