Article
Do You Need an Email Verification API or Bulk Upload? A Decision Guide
By Unlimited Verifier Team ·

Summary
Bulk upload is enough for one-time or scheduled list cleans, while an email verification API is needed when addresses must be checked before they are saved. On Unlimited Verifier, API access requires the Pro plan, which includes 100,000 API emails a month.Bulk upload is enough for a one-time or scheduled list clean. You need an email verification API when addresses must be checked before they are saved, and on Unlimited Verifier that means the Pro plan, which includes 100,000 API emails a month. If you are still comparing best email verification tools, start with how to choose an email verifier. This page assumes you have a tool and need to decide how to use it.
Quick answer
- Bulk upload covers one-time cleanups, event lists and scheduled re-checks. It needs no code.
- The API covers any flow where an address is saved in real time. On Unlimited Verifier it requires Pro, which includes 100,000 API emails a month. Free has no API access.
- Plan limits decide a lot. Free handles 25 lists a month of up to 150 emails each. Pro handles lists of up to 25,000 emails each. Bulk files are CSV or Excel, up to 10MB.
- Default setup: bulk for the existing backlog, the API at the point of entry, and a scheduled bulk re-check of the full database.
What is the difference between an email verification API and bulk upload?
Both run the same checks: syntax, domain, MX records, the SMTP mailbox, catch-all detection, and disposable and role-based flags. The difference is when the check happens and how the result reaches you.
A bulk upload is a snapshot. You submit a file, every row is processed, and you download a file where each address carries a status. An email verification API and automation setup works differently. Your system sends one address, or a batch of up to 10,000 per request, and receives the result in code. Your application can then decide whether to save, tag or reject the record before it is written.
| Bulk upload | Single-email API check | Batch API call | Free single-email checker | |
|---|---|---|---|---|
| Unit of work | A whole CSV or Excel file | One address per request | Up to 10,000 addresses per request | One address typed in by hand |
| Result arrives as | A downloaded file (CSV, Excel or JSON) | One response your code handles | One batch response your code handles | An on-screen result |
| Best moment | Before a campaign, or on a schedule | At form submit, before the record is saved | Backlogs and nightly pipeline jobs | Spot-checking a single contact |
| Who runs it | Anyone who can export a list | A developer or scripted job | A developer or scripted job | Anyone with a browser |
| Availability on Unlimited Verifier | Free (lists up to 150) or Pro (lists up to 25,000) | Pro only | Pro only | Free |
| Stops a bad address entering your database? | No, it cleans after the fact | Yes, if your code blocks or flags on the result | Partly, only for records already gathered into the batch | No |
The timing gap is the important part. A bulk run tells you what was true when you ran it. An API call tells you what is true when the record enters your system. A list verified in January can drift by spring, because people change jobs, company domains lapse and mailboxes close. Bulk is a cleanup tool. The API is a prevention tool.
Bottom line: Use bulk to clean what you already have, and use the API to stop bad data arriving.
When do you need an email verification API?
You need an API when the decision has to be made before the record is written, and the outcome depends on whether the address is real. If nothing downstream depends on the result until after the data has landed, bulk is the simpler choice.
- Signup and lead forms. A typo such as
gmial.comfails a domain or MX check the moment it is typed. A bulk run would find it days later, after the record has fed a welcome sequence and the welcome email has bounced. - Continuous feeds. Webinar platforms, partner referrals and checkout flows push contacts into your CRM all day. A monthly cleanup always trails them.
- Sales lead routing. A sequence should not start on an address that will fail at step one. Checking at routing time keeps the first touch from becoming a bounce.
- Free trials and account creation. Disposable addresses cluster around trial sign-ups. The disposable flag lets you set a policy at the door, such as blocking the address or requiring a confirmation.
Entry checks are cheaper than cleanup. Rejecting an address costs you nothing. A saved bad address costs a bounce, a suppression record to maintain, and a row that automations keep mailing. Mailbox checks can also take longer than syntax checks. Many teams therefore run the call asynchronously: the form accepts the entry, shows a neutral confirmation, and the back end acts on the result. The visitor never waits on a spinner. For the pattern in detail, see real-time email validation. If your prospecting platform already verifies addresses on export, read whether the email verification built into Apollo is good enough before you add a second layer.
Bottom line: If a bad address can enter your system before anyone checks it, you need the API at that entry point.
When is bulk upload the better choice?
Bulk is the better choice when the work is batch-shaped, when no developer is available, or when you need a dated record of the whole list.
- One-time cleanups before a first campaign, a platform migration or the reactivation of a dormant list. One-time cleanup versus ongoing hygiene explains how to set the cadence.
- Event and trade-show lists that arrive as spreadsheets. They come in one batch, so one batch run fits.
- Scheduled hygiene on an existing database, usually monthly or quarterly.
- No-code teams. Unlimited Verifier has no native ESP, CRM or Zapier integrations. The working loop is export, verify, re-import, and bulk upload is that loop without any code.
- Audit and client reporting. A file with a category on every row is easy to hand to a client, an auditor or a compliance reviewer.
Two practical catches. Results are kept for 24 hours on Free and 30 days on Pro, so save a dated copy of every export in your own storage. The file limit is 10MB. A list of 25,000 rows with an email column and one or two short fields usually fits comfortably. What breaks the limit is a wide export full of unused columns, so strip those before upload.
Bottom line: Bulk gives you a complete, dated picture of a list, and it needs no code.
Can you use the API without a developer?
Not directly. The Unlimited Verifier API is a REST API, and the product has no native integration with ESPs, CRMs or Zapier. Someone has to make the HTTP calls, whether that is your developer, an agency engineer or a short script on a schedule.
If you have no developer, buy Pro for its bulk capacity, not the API. Lists of up to 25,000 emails are useful on their own. Add the API once a developer can wire it into a form or a pipeline and the volume justifies it.
Bottom line: Without code, you have bulk. The API is a build project, so budget developer time for it.
Which should you choose? A five-question framework
Work through these in order. A "yes" to question 1 or 2 means you need the API.
- Do new addresses arrive continuously from forms, feeds, CRM sync or checkouts? If yes, plan an API integration at the entry point.
- Must the decision happen before the record is saved? If yes, use the API. If no, bulk is probably enough.
- Does someone on your team write scripts? If not, start with bulk on a schedule and treat the API as a later project.
- Will monthly API volume stay within the 100,000 emails included on Pro? If yes, the API covers it. If not, use the API for entry checks and bulk for the rest, and confirm current plan details before you commit.
- Do you need a dated file for an audit, a client or a reviewer? If yes, keep bulk runs in your process even if you also use the API.
Applied to common situations:
| Situation | Recommended setup | Why |
|---|---|---|
| Marketer with a 30,000-row list before a launch | Bulk: two Pro lists (25,000 + 5,000), then segment | One batch and nothing new arriving, so no API needed |
| SaaS company with a free trial | API at signup, plus a quarterly bulk re-check | Trials create continuous entry; existing accounts decay |
| Agency importing scraped prospects | Bulk for the backlog; API only if feeds are continuous | Scraped data is a one-off batch unless new prospects keep arriving |
| Ecommerce or SaaS store with customer accounts | API at account creation or checkout; bulk for the existing base | New accounts arrive continuously; the existing base is a one-time cleanup |
| Newsletter with a few hundred subscribers and no developer | Bulk on new signups each week, on Free | Free covers lists of up to 150 emails at $0 |
Bottom line: Continuous entry and a need to decide before saving point to the API. Batch work and no-code teams point to bulk.
What does each option cost?
Pricing on Unlimited Verifier has three layers. Standard verification is unlimited on every plan, with no per-email fee. Deep verification is capped at a monthly count. API access requires Pro. Compare vendors on the number that matters, which is the email verification pricing per 1,000 addresses.
- Free ($0): 25 lists a month, up to 150 emails each, so at most 3,750 emails a month. It includes 750 deep verifications a month, no API access, and results kept for 24 hours.
- Pro: $29 a month, or $25 a month billed annually. Unlimited lists of up to 25,000 emails each, 25,000 deep verifications a month, 100,000 API emails a month, and results kept for 30 days.
The arithmetic for the API allowance:
- At full API use, monthly billing: $29 ÷ 100 = $0.29 per 1,000 API emails. On annual billing: $25 ÷ 100 = $0.25 per 1,000.
- At low API use: 3,000 API checks a month gives $29 ÷ 3 = about $9.67 per 1,000, roughly 33 times the full-allowance rate. Your effective API cost falls as you use more of the allowance, and bulk runs on the same plan lower it further.
When you compare other vendors, convert everything to cost per 1,000 verified addresses. Check whether standard checks, deep checks and API calls are priced separately, and whether any overage applies. The questions to ask before you buy an email verifier list covers the billing details to confirm.
Bottom line: Pick the plan from the volume you will actually use, not from the headline allowance.
How do you verify a list in bulk? A step-by-step tutorial
- Export the list as CSV or Excel. Keep the original file unchanged. Include the email column and any engagement fields, such as last open date or signup source, so you can segment later. Export suppressed contacts as a separate file.
- Sign up for an account. Free handles lists of up to 150 emails. For larger lists, choose Pro.
- Split the file to fit the plan's list size. On Pro, each list holds up to 25,000 emails, so a 40,000-row file becomes two uploads of 25,000 and 15,000. On Free, a 3,000-row file becomes 20 files of 150 rows each (3,000 ÷ 150 = 20), which fits within the 25-list monthly cap.
- Upload the file. CSV and Excel files up to 10MB are accepted, and the email column is detected automatically. Check the detected column before you run the batch, and fix the file if it looks wrong.
- Run the verification and wait for the batch to finish.
- Read the three buckets. Valid addresses are safe to send to. Invalid addresses should be removed and suppressed. Risky addresses include catch-all domains, which accept mail for any name, so the individual mailbox cannot be confirmed. They also include disposable addresses and role accounts such as
info@. Set a policy for each category rather than sending Risky addresses in the same campaign as Valid ones. For catch-all handling, see the catch-all verification page. - Reconcile the counts. Valid + Risky + Invalid should equal the number of rows you uploaded. If it doesn't, find the gap before you go further. A missing row is often a formatting problem in the source file.
- Export the results as CSV, Excel or JSON, and save a dated copy.
- Re-import the Valid contacts into your ESP or CRM as a new segment, and add the Invalid addresses to your suppression list. Because there is no native integration, this step is manual or scripted.
Bottom line: Export, split to the plan limit, upload, sort by category, reconcile the counts, save the file, then re-import only what is Valid.
How do you add an API check to a signup form?
- Confirm you are on Pro. Free has no API access, so the build will stall without it.
- Create a key on the email verification API keys page. Store it in server-side configuration. Never put it in front-end JavaScript, where any visitor can read it.
- Choose the call type. Use a single-email check on form submit. Use batch requests, up to 10,000 emails each, for backlogs and nightly jobs. For the broader pattern, see email verification API and automation again.
- Map each result to a rule. A simple policy:
Valid -> save the contact and continue
Invalid -> reject with "please check this address"
Risky -> save, tag as risky, send a confirmation email
Rejecting Invalid addresses outright is usually right. Rejecting Risky addresses outright is a mistake, because catch-all domains host many legitimate business mailboxes. An SMTP check cannot confirm a catch-all mailbox, so a confirmation click is the strongest proof available at signup that the address works and its owner wants your mail.
- Log each result with a timestamp in your database. This gives you an audit trail for every decision.
- Test before launch. Run a set of known-good and known-bad addresses through the integration, and compare the outputs with the free single-email checker.
- Track usage against the 100,000 monthly API allowance, and set an alert at 80%, so a traffic spike does not exhaust it mid-month.
The verification engine is published on GitHub, so your developers can read how the open-source engine is structured. Test the hosted API's responses directly rather than assuming they match the open-source code.
Bottom line: Keep the key server-side, check on submit, route Risky addresses to confirmation, and log every decision.
What do the numbers look like in practice?
These examples use Unlimited Verifier's plan limits and show the arithmetic. Percentages marked illustrative are assumptions, not measured results.
Example 1: One-time event cleanup (bulk). You have 40,000 badge scans from a trade show. At 25,000 per list, that is two uploads: 25,000 and 15,000. Standard verification is unlimited, so the run carries no per-email charge. Deep verifications are capped at 25,000 a month, so run deep checks only on the Risky subset. Assume 8% come back Risky (illustrative): 0.08 × 40,000 = 3,200 deep checks, well inside the cap. One Pro month costs $29, or $29 ÷ 40 = $0.73 per 1,000 addresses for this run.
Example 2: SaaS signup form (API). You receive 3,000 signups a month, which uses 3,000 ÷ 100,000 = 3% of the included API allowance. Assume 4% of signups have a domain typo, a nonexistent mailbox or a disposable address (illustrative): 0.04 × 3,000 = 120 bad records stopped each month, or about 1,440 a year. If you also push a 45,000-contact re-check through the API, the month totals 48,000 API emails, still under 100,000.
Example 3: Agency with scraped prospects (bulk, above the API allowance). You process 250,000 prospects a month. That exceeds the 100,000 API emails included on Pro, so the API alone cannot cover it. Bulk handles it: 250,000 ÷ 25,000 = 10 lists. Assume 8% are Risky (illustrative), and deep-check only that group: 0.08 × 250,000 = 20,000 deep checks, inside the 25,000 cap. Spread across the month, the plan fee is $29 ÷ 250 = about $0.12 per 1,000 addresses, before any API use. Confirm current plan details before you commit to a volume this high. For agency workflows, see which email verifier cold email agencies use and email verification for sales prospecting.
Example 4: Small newsletter on Free. You have 500 subscribers. At 150 per list, 500 ÷ 150 = 3.33, so four files: 150, 150, 150 and 50. That is well within Free's 25-list monthly cap, at $0. There is no API, so new signups get verified weekly by bulk upload. For this use case, see best email verifiers for weekly newsletter senders.
Bottom line: Work out lists, requests and monthly volume before you choose. The arithmetic usually settles the question.
Should you run both, and how?
For most teams beyond a one-off project, yes. The API checks what enters your system. It does not re-check what is already there. Bulk re-checks the whole base, so each covers a gap the other leaves.
A workable rhythm:
- Day 0: Run one bulk verification on the existing list. Suppress Invalid addresses and segment the rest.
- Ongoing: Check each new entry through the API. Reject Invalid addresses, tag Risky ones and confirm them.
- Quarterly: Run a bulk re-check of the full database. For a 50,000-contact database, that is two uploads of 25,000 each.
For scheduling and metrics, see email list maintenance best practices.
Running two vendors on the same list usually adds cost and conflicting statuses faster than it adds accuracy. If you are changing vendors, plan the cutover first, using how to switch email verification providers. For whether a second check is worth running, see whether to double verify your list with two tools.
Bottom line: The API protects the front door, and scheduled bulk runs cover the rest of the house.
Does verification help with compliance?
Verification improves data quality, but it does not establish consent. Most compliance problems in this area come from confusing those two things. This is the territory of email verification compliance and hygiene.
- United States. The FTC's CAN-SPAM compliance guide focuses on honouring opt-outs, accurate header information, identifying commercial messages and including a valid postal address. A deliverable address is not an opted-in address.
- United Kingdom and EU. The ICO publishes guidance on PECR and UK GDPR. For marketing to individuals, PECR generally requires consent or an existing customer relationship, and verification supplies neither. The accuracy principle in UK GDPR expects personal data to be kept accurate and up to date, which is a sound reason to check addresses at entry.
- Purchased lists. Verification can remove dead addresses from a purchased list. It cannot create permission to email the people on it.
- Evidence. A confirmation click on a Risky address is one of the clearest records of consent you can collect at scale. API timestamps and dated bulk files help show when and how each address was checked.
Bottom line: Verify for deliverability and accuracy, and collect consent separately.
What are the common mistakes to avoid?
- Verifying a purchased list to "make it safe." Verification removes dead addresses. It does not create consent.
- Running bulk once and treating the list as clean. Lists decay, so schedule re-checks.
- Building an API integration on the Free plan. Free has no API access, so the build stops at the first call.
- Uploading more than 25,000 rows as one Pro list. Each Pro list holds up to 25,000 emails. Split larger files first.
- Rejecting every Risky address at signup. You will turn away real customers on catch-all domains. Confirm them instead.
- Sending Risky addresses in the first campaign. Catch-all results cannot be confirmed by SMTP alone. Send them last, or only after a confirmation.
- Skipping the count reconciliation. If Valid + Risky + Invalid does not equal your row count, something went wrong in the file or the export.
- Losing results. Free keeps results for 24 hours and Pro for 30 days. Save dated exports.
- Treating Valid as "wants my mail." A deliverable address can still be unengaged. Use engagement data alongside verification.
- Choosing a vendor on headline accuracy alone. Check how it handles your edge cases, and see which email verifier features actually matter and the red flags when choosing an email verification service.
- Assuming every domain behaves the same. Check how your verifier handles international addresses before relying on it. See whether an email verifier can check international domains.
Bottom line: Most mistakes come from treating verification as a one-time fix, or as proof of consent.
How we compared (and limitations)
This guide is based on public documentation and Unlimited Verifier's published plan facts. It is not based on controlled tests of any vendor's accuracy, and we have not benchmarked the API against live mailbox providers.
- RFC 5321 defines SMTP, the protocol that mailbox checks depend on. Mail servers generally limit what they reveal about individual mailboxes for privacy and anti-abuse reasons, which is one reason some results come back Risky rather than Valid or Invalid.
- Google's sender guidelines advise bulk senders to keep user-reported spam rates below 0.10% and to avoid reaching 0.30%. Note that this is a complaint metric, not a bounce threshold. A clean list supports both goals.
- The FTC and ICO guidance cited above.
Worked-example percentages (the 8% Risky share and the 4% signup failure rate) are illustrative assumptions. Unlimited Verifier states 99.5% accuracy for its deep verification. That is the company's own figure, not an independent benchmark. Plan limits and prices change, so check the current pricing page before you budget.
Which tool to use
| Your situation | Use |
|---|---|
| One-time cleanup of an old list | Bulk upload |
| Event or trade show list before a send | Bulk upload |
| Sign-up form that saves to a database | Verification API at submit |
| Nightly import from another system | Batch API call |
| Checking one contact by hand | Free single-email checker |
| Real-time saves and a periodic full clean | API at entry plus scheduled bulk |
Frequently asked questions
Can I use bulk upload instead of an email verification API?
Bulk upload can replace an API only if you clean lists after the fact and do not need to stop bad addresses at entry. Bulk runs are snapshots, so an address can go bad between runs. If your system must accept or reject a record in real time, you need an API call in your application code.
Is API access included in the free plan on Unlimited Verifier?
No. Free has no API access. On Unlimited Verifier, API access requires the Pro plan, which includes 100,000 API emails a month. Free covers bulk checks on up to 25 lists a month, with each list holding up to 150 emails.
How many addresses can one batch API request include?
A single batch API request can include up to 10,000 addresses. Batch calls suit backlogs and nightly pipeline jobs, and they also require the Pro plan on Unlimited Verifier.
What file formats does bulk upload accept?
Bulk upload accepts CSV or Excel files up to 10MB. Results come back as a downloaded file in CSV, Excel or JSON, with a status on each row. Free lists can hold up to 150 emails, while Pro lists can hold up to 25,000 emails each.
Do the API and bulk upload run the same checks?
Yes. Both run syntax, domain and MX checks, the SMTP mailbox check, catch-all detection, and disposable and role-based flags. The difference is timing and delivery: bulk returns a file after a run, while the API returns a response your code can act on immediately.
Does bulk upload stop bad signups from entering my database?
No. Bulk upload cleans data after it has been collected. It is useful for removing bad records that already exist, but it does not intercept new addresses. To prevent bad entries, call the verification API at the point of form submission and block or flag results in your code.
Should I use both bulk upload and the API?
Often yes. A common setup is bulk for the existing backlog, the API at the point of entry, and a scheduled bulk re-check of the full database. The API handles new data, and scheduled bulk runs catch addresses that change over time, such as closed mailboxes or lapsed company domains.
Why does a list verified earlier need checking again?
Email addresses decay over time. People change jobs, company domains lapse and mailboxes close, so a result from months ago may no longer be accurate. Scheduled bulk re-checks keep the database current, and API checks at entry keep new records clean from the start.
When is bulk upload enough on its own?
Bulk upload is enough when you need a one-time cleanup, are preparing an event list, or only need periodic re-checks of a stored list. If no developer work is available and addresses are not collected in real time, bulk handles the job without any code.
Cut Bounces and Protect Your Sender Reputation With Unlimited Email Verification
Every invalid address you send to hurts your sender reputation and your inbox placement. Verifying your list before each send means fewer bounces, healthier deliverability, and a predictable cost. With Unlimited Verifier, standard verification is unlimited on every plan, with no per-email fees.
Unlimited Verifier checks syntax, domain, MX records and the SMTP mailbox. It also detects catch-all domains and flags disposable and role-based addresses. Export a CSV from your email platform or CRM, upload and verify the list, then re-import the clean results. You can also automate checks with the email verification API.
| Free | Pro | |
|---|---|---|
| Price | $0 | $29/month ($25/month billed annually) |
| Lists | 25 a month, up to 150 emails each | Unlimited, up to 25,000 emails each |
| Deep verifications | 750 a month | 25,000 a month |
| API access | No | Yes (100,000 emails a month) |
| Result retention | 24 hours | 30 days |
Why teams choose Unlimited Verifier
- Unlimited standard verification on all plans, including Free, with no per-email fees.
- Catch-all detection so you know which domains accept every address.
- Clear Valid / Risky / Invalid results, exportable as CSV, Excel or JSON.
- An open-source verification engine you can inspect on GitHub.
Unlimited Verifier states 99.5% accuracy for deep verification.
Create a free account and verify your next list before you hit send.
Want to test a single address first? Try the free email checker.