curl Examples for Email Verification REST API Endpoints in 2026

Why Use curl for Email Verification API Testing in 2026?

You’re ready to test an email verification API endpoint—but you don’t want to spin up a whole app just to check if it’s working. You just want to know: Can you connect? Is authentication valid? Does the response make sense?

That’s exactly what curl is built for. It’s the standard tool for poking at REST APIs directly from the command line—no IDE, no framework, no setup. If you're verifying email addresses at scale, using curl lets you test the API before you write even one line of code.

You can validate the exact format of the response, catch invalid credentials early, and confirm your endpoint URL is correct—all without deploying a single script. This isn’t just for debugging. It’s how you catch delivery issues before they hit your bulk verification pipeline.

Key takeaways

• curl enables rapid validation of email verification API endpoints without needing a full development environment.
• Using curl helps identify authentication failures, malformed requests, and unexpected responses before integrating with production code.
• Testing with curl is especially effective for debugging high-volume bulk verification workflows where consistency and error tracking matter.

How Does the Emaillistchecker.io API Verify an Email Address?

The Emaillistchecker.io API verifies emails through a multi-layered process: it checks DNS records for valid MX servers, performs a real SMTP handshake to test inbox availability, validates syntax, and analyzes domain reputation—all in real time. It returns a clear status (valid, invalid, catch-all, or risky) based on server responses, with a verified accuracy rate of 98.9% across billions of data points.

Real-Time Checks Behind the Response

When you send an email to the Emaillistchecker.io API, it doesn’t guess. It connects to the domain’s mail server using standard protocols—DNS lookups for MX records, then an SMTP handshake to see if the address is accepted. This mimics how real email providers respond.

If the server rejects the address early, it’s marked invalid. If it accepts it but doesn’t confirm delivery, it’s often a catch-all, meaning any address at that domain will receive email—even if it doesn’t exist. This is common in role-based or outdated setups.

The API also checks for syntax errors, such as missing @ symbols or invalid top-level domains. These are caught before sending any network request, saving time and reducing false positives.

What the Results Actually Mean

Each email gets classified based on what the server returns. "Valid" means the address is likely deliverable. "Invalid" means the server explicitly rejected it. "Catch-all" means the domain accepts all emails, which can hurt sender reputation. "Risky" flags addresses that might be disposable, temporary, or associated with high spam volume—common in fraud detection systems.

These statuses aren’t guesses. They’re based on real-time server behavior, tracked consistently across billions of records. This level of detail is rare in email verification, where many tools only return "valid" or "invalid" without context.

Understanding how an API works helps you trust the outcome. For example, a catch-all might appear valid in many systems, but it often leads to low inbox placement—something platforms like Spamhaus or MxToolbox also track as a red flag.

For teams running email campaigns or managing large lists, this level of precision reduces bounces, improves sender reputation, and keeps deliverability high. You can test your list at scale using real-time verification: try the API or verify a whole list in bulk.

What You Need to Start: API Key and Endpoint URL

You need an API key and the correct endpoint URL to begin using the Emaillistchecker.io REST API. Get a free key instantly from your dashboard—no credit card required. Use https://api.emaillistchecker.io/v1/verify for production requests, and https://api.emaillistchecker.io/v1/verify?test=true to test without hitting rate limits.

Get Your Free API Key

Sign in to your Emaillistchecker.io dashboard and copy your API key—no trial, no payment, no hidden steps. It’s valid immediately and never expires. You can verify up to 100 emails for free on first use, which is enough to test the flow before scaling.

API keys are tied to your account and help track usage. They’re not shared by default—keep yours secure like any authentication token. If you’re integrating with tools like Mailchimp or Klaviyo, your API key also powers those connections seamlessly.

Use the Right Endpoint URL

The production endpoint is https://api.emaillistchecker.io/v1/verify. Send your requests with your key in the header, and include the email address in the body. This is the standard structure used by most verified email services, including those tested by industry tools like MxToolbox.

For development and testing, use https://api.emaillistchecker.io/v1/verify?test=true. This endpoint returns mock results without counting against your rate limit or contacting real mail servers. It’s ideal for debugging, integration testing, and validating your code before going live.

Real email verification requires careful handling of SMTP responses, MX lookups, and sender reputation signals. The API handles all of that behind the scenes—your job is just to send a clean request with valid auth.

Want to verify hundreds of emails at once? Try our bulk verification tool: bulk verification. Need real-time checks in your app? The API integrates with any system. For finding missing emails, explore our email finder.

The email verification process relies on a combination of DNS record checks, SMTP validation, and behavioral pattern analysis—methods widely adopted across the industry and documented in RFC 5321 and RFC 5322.

curl Examples for Email Verification REST API Endpoints

You can verify an email in real time using a simple POST request with curl. Use the correct Authorization header, send the email as a JSON object in the body, and expect structured output—valid, invalid, catch-all, or risky verdicts with confidence scores. This works across your workflows, from testing to scaling bulk sends.

Step-by-Step: Sending a Verification Request

1. Use POST to send data to the verification endpoint. This method is standard for submitting new data like an email for validation, and it's required by the REST API specification defined in RFC 7231.
2. Include your API key in the Authorization header using Bearer token format. This ensures only authorized users can access the service—protection against abuse and unauthorized access.
3. Send the email in JSON format in the request body. The API expects {"email": "[email protected]"} to identify the address being validated. This structured input allows consistent parsing and error handling on the server side.
4. Receive a structured response with clear verdicts (valid, invalid, catch-all, risky), confidence scores (0–100), and metadata like domain status or role account detection. This helps you act immediately—clean lists, avoid bounces, improve deliverability.

Example Request

Here’s the exact curl command you can run today:

curl -X POST https://api.emaillistchecker.io/v1/verify \ -H 'Authorization: Bearer YOUR_API_KEY' \ -H 'Content-Type: application/json' \ -d '{"email": "[email protected]"}'

Replace YOUR_API_KEY with the one from your API dashboard. The response will be JSON, including fields like verdict, confidence, and reason. For example:

Use this process to test single emails, validate user signups, or debug deliverability issues. For larger checks, bulk verification handles thousands of emails with the same rules, same accuracy. You’re not guessing—your data is verified with real logic, not heuristics.

Understanding the API Response: Valid, Invalid, Catch-All, Risky

You’ll see four core response types when verifying emails via API: Valid (confirmed deliverable), Invalid (syntax or domain failure), Catch-all (accepts all emails, not unique), or Risky (disposable, role-based, or spam-prone). These verdicts directly impact deliverability and list health. A valid email isn’t always safe—catch-all addresses cause bounces; risky ones hurt sender reputation. Understanding these helps you filter out dead ends before sending.

What Each Verdict Means in Practice

Let’s break down what you’re actually seeing when the API returns a result.

Why You Can’t Trust "Valid" Alone

A valid result doesn’t mean engagement. Many domains use catch-all setups, especially in older or unmanaged systems. According to RFC 5321, mail servers may accept messages for non-existent addresses—this is how catch-alls work. That’s why a valid status still may not lead to delivery. The same applies to disposable emails: they pass syntax and domain checks but are useless for marketing long-term.

Our API returns these verdicts with 98.9% accuracy using SMTP checks, MX resolution, and domain reputation analysis. It's not magic—a system’s ability to detect role accounts or disposable domains depends on maintaining real-time data. You can see results in near real-time, including detailed metadata like domain risk flags or blocklist status.

How to Verify Multiple Emails with curl and Automation

You can verify multiple emails using curl by looping through a list in a shell script, sending one request per email to the EmailListChecker API. Split your list into chunks of 100 or fewer to avoid rate limits, store results in JSON files, and process them later for use in Mailchimp, SendGrid, or other tools. The HTTP 429 status code is a clear signal that you’re being throttled, so batch size matters.

Step-by-step automation with curl

1. Prepare your email list as a plain text file, one email per line, e.g., emails.txt. This keeps input clean and manageable.
2. Use a loop to iterate over each email with for email in $(cat emails.txt); do. This shell pattern is standard and reliable for scripting.
3. Split large batches into chunks of 100 emails or fewer. Many APIs, including EmailListChecker’s verification API, enforce rate limits to prevent abuse. Going over 100 per batch increases risk of 429 errors.
4. Send each request via curl with the proper headers and authentication. Include Content-Type: application/json and your API key in the header for valid requests.
5. Save responses to separate JSON files or append to a single file. Use > response_$email.json or > results.json to preserve data for debugging or downstream integration.

Processing and integration

Once you’ve collected results, you can parse the JSON output to filter valid, invalid, or risky emails. Tools like jq make parsing easy in a shell environment. Store clean, verified emails in CSV or directly push them to your CRM. The integrations page shows how EmailListChecker works with Mailchimp, HubSpot, SendGrid, and Klaviyo for automated syncs.

For large-scale use, consider writing a script that automates the chunking process and logs progress. This prevents manual errors and ensures consistent throughput. Always monitor the HTTP response codes: 200 means success, 400 indicates a malformed request, 429 means you’ve hit a limit, and 5xx signals an upstream issue.

Common HTTP Response Codes and What They Mean

You’ll get standard HTTP response codes when calling email verification APIs. A 200 means your request succeeded and includes the email’s validity verdict. A 400 means your input was malformed—like an invalid email format. A 401 means your API key is missing or wrong. A 429 means you’ve hit the rate limit; back off and retry with exponential delay. A 500 means the server had an internal issue; retry after a short delay. These codes are defined in RFC 7231 and are consistent across REST APIs, including those for email verification.

Response Code Reference

Here’s what each code means when verifying an email via a REST API:

How to Handle These in Practice

Let’s say you’re integrating email verification into a signup workflow. You send a request to the API endpoint. If you get a 200 with a valid verdict, you can proceed. A 400 means the user entered an email like test@domain. Fix it before retrying. A 401 means your API key is wrong—check your config. If you see 429 during bulk checks, you’re likely overwhelming the API. Reduce your request rate. A 500 usually isn’t your fault—just retry later. Tools like EmailListChecker’s Verification API return clear error messages and handle these responses consistently.

Best Practices for Using curl with Email Verification APIs

You should always test with the sandbox endpoint first, store API keys in environment variables, validate your JSON before sending, monitor response times (over 500ms may indicate throttling), and implement retry logic with jitter for 429 or 500 errors. These steps prevent accidental sends, reduce failures, and keep your verification pipeline stable. Let’s break them down.

Sandbox Testing and Key Management

• Before sending real data, verify your script works using the API’s sandbox endpoint RFC 7159 (JSON) defines the format you must follow. Many APIs offer a test mode—it’s free and prevents real costs or send limits.
• Never hardcode your API key in your curl command. Use environment variables instead (e.g., curl -H "Authorization: Bearer $API_KEY"). This stops credentials from leaking in logs or version control.

Error Handling and Performance

• Always check that your JSON payload is valid before sending. A malformed request will return a 400 error. Use a JSON linter or jsonlint.com to validate the structure.
• Monitor response times. If they consistently exceed 500ms, the API may be throttling your requests. This often happens with high-volume scripts without proper rate limiting.
• When you receive a 429 (rate limit) or 500 (server error), implement retry logic with exponential backoff and jitter. Jitter means randomizing the delay between retries (e.g., 1s + 0.5s random) to avoid overwhelming the server.

For teams doing regular bulk checks, consider using a dedicated API client or integrating with tools like EmailListChecker's real-time verification API. It’s designed to handle these edge cases at scale, with built-in safeguards and clear error codes. If you’re verifying a large list, the bulk verification option gives you better performance and analytics. Integrations with Mailchimp, HubSpot, and SendGrid make it easier to sync clean lists directly, reducing setup friction.

How Emaillistchecker.io Compares to Other Email Verification Tools

You don't need to guess which tool wins for email verification. Emaillistchecker.io outperforms peers like ZeroBounce, NeverBounce, and Kickbox in accuracy and transparency. While others rely on outdated heuristics or delayed systems, Emaillistchecker.io uses live SMTP checks with 98.9% accuracy and real-time API responses. It's built for developers who want reliable, actionable results—fast.

Accuracy and Real-Time Checks That Matter

ZeroBounce and NeverBounce offer similar endpoints, but their catch-all detection often falls short. A catch-all email server accepts any address, which leads to false positives if not properly vetted. Emaillistchecker.io avoids this by validating against actual mail servers using real-time SMTP, not just pattern-matching rules. This reduces false validation rates that plague tools relying on outdated databases.

Tools like Kickbox and Bouncer use proprietary heuristics—internal rules that aren’t visible to you. They might flag an email as valid based on syntax and domain behavior alone, but that doesn’t mean it’s deliverable. Emaillistchecker.io instead uses open standards—like RFC 5321 and RFC 5322—to conduct actual connection tests, providing clearer, more dependable feedback.

Speed, Integration, and Workflow Fit

Emailable and MillionVerifier are solid for bulk verification, but their response times can lag. You might wait minutes or even hours for results on a large list. Emaillistchecker.io’s API delivers real-time responses in under 2 seconds per email, which matters when you're processing thousands and need instant feedback.

Beyond speed, you need integrations that work. Unlike some tools that require manual API setup, Emaillistchecker.io offers native connections to Mailchimp, HubSpot, Klaviyo, and SendGrid. This means you can verify a list without leaving your platform. The integration layer is built directly into the product, so no extra code, no delays.

The full picture: you get high accuracy, transparency, fast results, and workflow harmony. No black boxes. No hidden delays. Just a clean, reliable email verification process. If you're building or managing campaigns, this is the difference between success and wasted effort.

See how it works: try the API, check your list with bulk verification, or test deliverability with inbox placement. All with credits that never expire.

Automate Verification with Your Marketing Stack

You can integrate Emaillistchecker.io’s real-time API directly into Mailchimp, HubSpot, or Klaviyo workflows using webhooks, validating emails at point of entry and filtering out invalid, risky, or disposable addresses before campaigns launch. This reduces bounce rates by 65%+ over time and strengthens sender reputation by avoiding delivery issues.

Seamless Integration with Your Tools

Let’s say you collect emails through a HubSpot form or a Klaviyo campaign. You don’t need to do anything extra—just connect the real-time API via webhook, and Emaillistchecker.io checks every email instantly. Invalid or risky addresses are flagged before they ever hit your list.

Mailchimp users can set up similar triggers to verify new subscribers during signups. The API responds in under 500ms, so delays are not noticeable to users. This is the same kind of automation used by top brands to maintain high deliverability.

Verify Before You Send, Validate at the Source

Use the same API to validate form submissions on landing pages. If someone types in a typo or a disposable email, the system flags it before the form is submitted. This cuts down on junk data before it enters any system.

High bounce rates hurt sender reputation, and senders with persistent bounce rates over 2% often end up on blocklists. Tools like MxToolbox and Spamhaus monitor reputation signals, and reducing bounces is one of the most effective ways to stay clean.

With Emaillistchecker.io, you get more than just accuracy—your API output includes detailed feedback: whether an email is valid, catch-all, disposable, or risk-flagged. That lets you build smart logic in your workflow.

You don’t need to manage this manually. It runs in real time, scales with your list size, and doesn’t expire. Start with 100 free verifications, then use credits as you need them—no time limits.

For teams managing large inbound lists, bulk verification via bulk verification is ideal. For developers, the API lets you embed validation anywhere in your stack.

Ultimately, sending only to verified, deliverable addresses is an industry-standard practice. The goal isn’t just cleaner lists—it’s better inbox placement and stronger long-term deliverability. You can test how your messages land with inbox placement testing, and find missing emails with email finder when you need them.

Start Free, Scale With No Expiry on Credits

You get 100 free verifications to start — no registration fee, no trial expiry. Use them to test the API, validate your first list, or evaluate deliverability before committing.

Purchased credits never expire, so you can store them for high-volume campaigns months down the line. Whether you're preparing for a seasonal send or planning a long-term outreach strategy, your credits are always ready.

There are no contracts, no hidden fees. Pay only for what you use, with instant access on demand. The system scales with your needs — no upfront costs, no wasted budget.

Keep reading

• Email Verification API & SDKs: the complete developer guide (complete guide)
• Fix Express Email Verification ECONNRESET Timeout Error in 2026
• Webhook Retry Behaviour When Your Endpoint Returns 500 in 2026
• Grafana Dashboard for Email Verification API Usage and Results in 2026
• Storing Raw JSON Verification Responses in a Variant Column

Ready to put this into practice? Emaillistchecker.io verifies emails with 98.9% accuracy — start with 100 free verifications.

Frequently asked questions

What is the best way to verify an email address using curl?

Use a POST request to the Emaillistchecker.io API endpoint with your API key in the Authorization header and the email in the JSON body. Test first with the sandbox.

How do I handle 429 errors when calling the email verification API?

Back off and retry with exponential delay. The API allows up to 100 requests per minute. Use jitter to avoid rate-limiting.

Can I verify multiple emails at once with curl?

Yes, but in chunks of 100 or fewer per request. Use a script to loop through your list and process responses batch by batch.

What does 'catch-all' mean in email verification?

A catch-all domain accepts any email address, even if it doesn’t exist. The address may validate but won’t reach a real user — a key reason for high bounce rates.

Is curl the only way to test the email verification API?

No, but it’s one of the most direct ways. You can also use tools like Postman, Insomnia, or write a script in Python, Node.js, or PHP.

How accurate is Emaillistchecker.io's email verification?

It achieves 98.9% accuracy by combining SMTP handshake, domain reputation, and real-time server feedback across billions of data points.

Do I need to pay to use the Emaillistchecker.io API?

No — you get 100 free verifications to start. Paid credits are optional and never expire, giving you flexibility to scale on demand.

What’s the difference between a 'risky' and 'invalid' email?

Invalid emails fail syntax or domain checks. Risky emails may be role-based, disposable, or high-spam — they’re not outright invalid but have poor deliverability.

How does Emaillistchecker.io integrate with Mailchimp and SendGrid?

Through native webhooks and API connectors. You can automatically clean your list before sending — reducing bounces and improving inbox placement.

Can I verify a list of emails without coding?

Yes — use the bulk verification upload feature on the Emaillistchecker.io dashboard. No API or curl required.

What’s the response time for one email verification via the API?

Typically under 500 milliseconds. Response times depend on the receiving domain's mail server and network conditions.

How do I know if a verified email is disposable?

The API flags disposable domains based on known services like Mailinator, GuerrillaMail, and other temporary email providers.