The Simplest EU VAT Validation: Pay Per Validation, No Setup Required

EU VAT validation (quick definition)

EU VAT validation is the act of checking whether a VAT number issued by an EU member state is currently registered and active in the European Commission's VIES database. The simplest path is a pay-per-use API that wraps VIES directly — no key to provision, no subscription, no servers to run.

Also known as: VIES VAT check, EU VAT lookup, intra-community VAT verification, VAT number validation API, VIES bulk check, VAT registration check.

What is the simplest EU VAT validation API?

The simplest EU VAT validation API is a pay-per-use endpoint that wraps the official European Commission VIES service and returns a structured JSON answer per number, with no API key, no subscription, and no setup. The EU VAT Number Validator Apify actor charges $0.002 per validated number, runs against your existing Apify token, and clears 1,000 numbers in roughly 50 seconds.

It uses the same VIES REST endpoint at ec.europa.eu/taxation_customs/vies/rest-api that national tax authorities use across all 27 EU member states (European Commission VIES service). Apify's free tier covers around 2,500 validations per month before any spend kicks in (Apify pricing).

The problem: The official VIES portal answers one VAT at a time. Type the number, wait for the response, copy-paste into a spreadsheet, archive the receipt manually if you need audit evidence, then come back next month and do it again. For 50 customers that takes over an hour. For 500 it takes a full working day. And you still don't know which VAT numbers were valid last quarter and aren't anymore — VIES has no historical API. Building your own wrapper around the VIES REST endpoint is a different kind of pain: country-specific format pre-checks for 28 jurisdictions, per-country rate limiting (VIES throttles France aggressively, the German node is offline 40-60% of the time), exponential backoff on MS_MAX_CONCURRENT_REQ errors, two-tier circuit breakers, change detection state, audit consultation references — that's a maintained service, not a weekend script. Internal-build estimates land at 4-8 engineer-weeks before you have something tax-audit safe.

What is EU VAT validation? It's the act of confirming, via the European Commission's VIES database, that a VAT number is currently registered to a trader in a specific EU member state — and (for audit-grade workflows) capturing a consultation reference number that tax authorities accept as proof of verification under VAT Directive Article 138.

Why it matters: If you issue a zero-rated B2B invoice to a counterparty whose VAT was deregistered between runs, your member state can hold you liable for the full VAT on that invoice. EU VAT rates run 17-27% depending on the country (European Commission VAT rates). Getting this wrong is expensive. Doing it manually doesn't scale.

Use it when: You need to validate one VAT number, a thousand VAT numbers, or every counterparty in your customer or supplier database — without standing up infrastructure, signing up for another SaaS, or babysitting a custom VIES wrapper.

Problems this solves

• How to validate an EU VAT number without writing code
• How to bulk-check 1,000+ VAT numbers in under a minute
• How to wire VAT validation into a checkout or onboarding flow
• How to catch deregistered customers before issuing zero-rated invoices
• How to generate audit-grade consultation references for tax filings
• How to integrate VIES into Slack, Jira, Salesforce, or n8n via webhooks

Quick answer

• What it is: Pay-per-use EU VAT validation API that wraps the official VIES service.
• When to use: Checkout flows, supplier onboarding, scheduled compliance monitoring, KYB pipelines, audit prep.
• When NOT to use: Real-time sub-100ms checks (VIES itself responds in 500ms-2s), UK GB VAT numbers (post-Brexit only Northern Ireland XI is in VIES), national checksum validation.
• Typical workflow: Paste VAT numbers into the input → run → download JSON or wire to a webhook.
• Main tradeoff: It's not free per call ($0.002 per validation), but you skip every line of plumbing code and get audit-ready output the moment the run finishes.

In this article: What is the simplest EU VAT validation API? · Examples · Why it matters · How it works · Alternatives · Best practices · Common mistakes · Limitations · FAQ

Key takeaways

• $0.002 per VAT validated — pay-per-event, no subscription, no monthly fee, no card-on-file unless you exceed the free tier.
• Apify free tier covers ~2,500 validations per month before any charge hits (Apify pricing).
• No API key required — you use your existing Apify token, which you already have if you've ever run an actor.
• 1,000 numbers in ~50 seconds with 20 concurrent workers and per-country rate limiting; 100 numbers in ~10 seconds; 5,000 in ~4 minutes.
• 28 country codes supported — all 27 EU member states plus XI for Northern Ireland (post-Brexit).
• Cache hits, skipped countries, and failures are NOT charged.

What does the output look like?

Concrete input → output, no parsing required:

Each row is plain JSON with stable enums. Filter on valid = false for invoice blocking. Filter on recommendedAction = "block_invoice" for ticket-ready signals. Wire recordType = "change-event" rows to Slack via Apify Webhooks. No prose parsing.

Why does EU VAT validation matter?

Because intra-community zero-rating depends on it. Under VAT Directive Article 138, a B2B sale between EU member states can be invoiced VAT-free only if the buyer holds a valid VAT registration in another member state. If the buyer's VAT is invalid at the moment of supply, your tax authority can deny the zero-rating and treat the transaction as a domestic sale — meaning you owe the VAT yourself, plus penalties.

The European Commission flags VIES as the official tool for confirming this status across all member states (European Commission taxation portal). Tax authorities in member states like France, Germany, and the Netherlands explicitly require VIES checks plus a stored consultation reference number as part of the audit trail for cross-border B2B invoices.

Manual VIES portal lookups don't scale past tens of numbers. An EU VAT validation API that wraps VIES — and stores the consultation reference automatically — turns an hour of clerical work into a 10-second job and a webhook payload.

How does pay-per-validation VAT checking work in practice?

The EU VAT Number Validator Apify actor sits in front of the VIES REST endpoint and adds the layers VIES alone doesn't give you. Conceptually:

1. Normalise input. Strip spaces, dots, dashes; uppercase the country prefix; deduplicate identical numbers.
2. Country format pre-check. Each EU country has its own VAT structure (NL: 9 digits + B + 2 digits; DE: 9 digits; FR: 2 alphanumeric + 9 digits). Numbers that fail the regex are rejected without hitting VIES — saving money and reducing VIES load.
3. Cache lookup. In monitoring mode, recently-validated numbers come back from state. Cache hits are NOT charged.
4. VIES validation. 20 concurrent workers, per-country rate limiting (France capped at 2 concurrent because VIES throttles FR aggressively, default 4 elsewhere), 3 retries with exponential backoff (3s, 6s, 9s) on rate-limit and 5xx errors, 30-second per-call timeout.
5. Two-tier circuit breaker. Global breaker stops the run on 10 consecutive infrastructure failures (VIES outage). Per-country breaker isolates a single bad country after 5 consecutive failures so a flaky DE node doesn't burn the rest of your budget.
6. Output. Per-row JSON with validity, parsed trader fields, failure classification, audit reference (in verified consultation mode), and a recommendedAction enum for downstream automation.

You don't have to know any of that to use it. You paste VAT numbers, click Start, and pull the dataset. The internals are the actor's problem.

Calling it from code

You can run the actor on demand from any HTTP client using the Apify API. Same pattern as any other Apify actor — start a run with input, poll or use a webhook for completion, read the dataset:

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("ryanclinton/eu-vat-validator").call(run_input={
    "vatNumbers": ["FR40303265045", "NL004495445B01", "IE6388047V"],
    "mode": "auto"
})

# Pull rows from the run's default dataset
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["vatNumber"], row.get("valid"), row.get("traderName"))

That's the entire integration. The actor handles VIES, retries, rate limits, format pre-checks, and output shape. You get JSON.

What are the alternatives to pay-per-validation VAT checking?

Three other ways to solve this problem. Each has a place — and a cost profile that's worth understanding before you pick one.

Pricing and features based on publicly available information as of May 2026 and may change.

Pay-per-validation API — fits anyone who'd rather pay $0.002 than write a wrapper. No setup, audit-grade output, scales from 1 to 10,000 numbers per run. Best for teams who want compliance signal without owning compliance infrastructure.

VIES portal (manual) — fine for a one-off check on a single VAT number. Beyond ~50 numbers per session, it's clerical work. The portal also doesn't generate machine-readable consultation references via the UI; you only get those through the verified consultation REST API the actor wraps.

DIY VIES wrapper — if you have engineers and a multi-month roadmap, you can build it. You'll inherit per-country rate-limiting, exponential backoff for MS_MAX_CONCURRENT_REQ and SERVICE_UNAVAILABLE, two-tier circuit breakers (one bad day at the European Commission shouldn't burn your monthly budget), country format pre-validation across 28 jurisdictions, change detection state across scheduled runs, audit consultation reference handling, and Germany's 40-60% uptime VIES node. Best for very large enterprises who already operate multiple compliance services and want VAT validation under the same pager rotation.

Commercial SaaS VAT validator — typically a monthly subscription regardless of volume. Best for organisations who already have procurement contracts with the vendor and want VAT validation bundled with broader tax automation.

Each approach has trade-offs in setup time, recurring cost, audit fit, and maintenance burden. The right choice depends on volume, frequency, and how much engineering capacity you can spare for tax plumbing.

Best practices for EU VAT validation

1. Always validate at the moment of invoicing for cross-border B2B sales. Tax authorities care about VAT status at the time of supply, not at the time of customer signup.
2. Capture and archive consultation references. Set requesterVatNumber to your own EU VAT and the actor returns a requestIdentifier per row — that's the legal evidence under VAT Directive Article 138.
3. Schedule monthly compliance runs against your customer database. Use mode: "monitoring" with a stable monitorStateKey so you only see what changed since last run.
4. Pair cacheTTLHours with compareToPrevRun for the no-cost no-noise loop. Cache hits aren't charged, and emitOnlyChanges suppresses uneventful rows.
5. Use expectations for supplier onboarding. Pass the company name you THINK the VAT belongs to and the actor scores the match (Levenshtein similarity 0-100). Catches typos, name variations, and outright fraud before the wire transfer.
6. Don't enable Germany unless you really need it. DE's VIES node runs 40-60% uptime. The actor skips DE by default and tells you why; flip includeUnreliableCountries only if you're prepared to retry.
7. Wire recommendedAction to your ticketing system, not your alerting system. block_invoice and hold_payment need a human-in-the-loop; monitor_only doesn't.
8. Treat UK separately. Standard GB VAT numbers left VIES after Brexit. Only Northern Ireland (XI) is still in VIES. For mainland UK, use HMRC's separate VAT API.

Common mistakes with EU VAT validation

• Validating once at signup and never again. VAT registrations get cancelled. Schedule recurring checks on existing customers and suppliers, not just new ones.
• Forgetting requesterVatNumber when audit evidence matters. Without it the VIES check is informational only — no consultation reference, no proof under Article 138.
• Treating a "valid" response as an identity check. VIES confirms the VAT is registered. It does NOT confirm the company name on your invoice matches the registered trader. Use the actor's expectations field for that.
• Hitting VIES at sub-second cadence in a checkout flow. VIES typically responds in 500ms-2s; for sub-second checkout you cache results locally with a TTL and re-validate asynchronously.
• Trusting checksum-only libraries. Local checksum validation tells you a VAT is plausible. It doesn't tell you it's registered. VIES is the only source of truth for active registration status.
• Building a custom VIES wrapper without circuit breakers. A bad day at the European Commission cascades into burned compute and false negatives across your entire customer database.

How to validate EU VAT numbers in bulk

Concrete steps to run the actor for the first time:

1. Open the EU VAT Number Validator on Apify.
2. Click Try for free (or Run if you're signed in).
3. Paste your VAT numbers into vatNumbers, one per line. Country prefix required (FR40303265045, not 40303265045). Spaces, dots, dashes are stripped automatically.
4. Leave mode at auto. The actor picks sensible defaults from your other inputs.
5. (Optional) Set requesterVatNumber to your own EU VAT for audit-grade consultation references.
6. (Optional) For supplier onboarding, set expectations with the company name you expect for each VAT.
7. Click Start. 100 numbers complete in ~10s, 1,000 in ~50s, 5,000 in ~4 minutes.
8. Pull results from the Dataset tab (six pre-built views: Overview, Audit Evidence, Parsed Trader Fields, Changes Since Last Run, Entity Verification, Failures Only) or wire a webhook for automation.

That's the whole flow. No environment variables. No API key registration. No subscription.

Why this beats the manual VIES portal workflow

The European Commission's VIES portal is fine for one-off lookups. For anything recurring, it's the painful path:

• One number at a time. Type, wait for the captcha-shaped response, screenshot or copy-paste, paste into a spreadsheet, repeat.
• No bulk endpoint via the UI. The bulk REST API exists, but the portal doesn't expose it.
• No consultation references in the UI. The legal-evidence reference number is only returned via the verified consultation REST API.
• No change detection. VIES has no historical API. The portal can't tell you which customers were valid last quarter and aren't now.
• No retry logic. If a member state's node is down, you get a generic error and no guidance.
• No audit bundle. Compliance teams have to manually archive evidence per number.

For 50 customers that's an hour. For 500 it's a full working day. Every quarter. The pay-per-validation API replaces all of it for $0.002 per number — and gives you the consultation reference and the audit bundle the portal can't.

Mini case study

A finance team running quarterly compliance checks on 800 customers used to assign one person two days per quarter to log into VIES, paste each VAT, screenshot the result, and archive evidence in SharePoint. Roughly 16 hours of work, no machine-readable output, zero change detection.

After moving to a pay-per-validation API: one scheduled run per quarter, ~40 seconds of wall-clock, $1.60 in PPE charges (well inside the Apify free tier), audit bundle archived automatically, and a Slack alert per deregistered customer between runs. The clerical workload dropped to zero and the team gained signal — not just data — about VAT health drift.

These numbers reflect one team's setup. Volume, country mix, and audit requirements will shift the picture; treat them as a sense of scale, not a benchmark.

Implementation checklist

1. Sign in to Apify (free account is enough for ~2,500 validations/month).
2. Open the EU VAT Number Validator actor page.
3. Paste a small test batch (10-20 known-good VATs) into vatNumbers. Run.
4. Verify the output shape against your expectations. Each row carries valid, trader fields, and recommendedAction.
5. Decide on a mode: auto for ad-hoc checks, audit for tax filings (set requesterVatNumber), monitoring for scheduled runs (set monitorStateKey and cacheTTLHours).
6. (Optional) Configure an Apify webhook to POST dataset rows to your downstream system.
7. (Optional) Schedule the run via Apify Schedules — daily, weekly, or monthly.
8. Archive AUDIT_BUNDLE from the run's key-value store with your tax filings.

Limitations of pay-per-validation VAT checking

This isn't a fit for every use case. Be honest about where it doesn't fit:

• Not under 100ms. VIES itself responds in 500ms-2s per number. The actor is fast at bulk; it's not a sub-second checkout endpoint. For real-time checkout, cache locally with a TTL and re-validate asynchronously.
• Standard UK (GB) VAT numbers aren't in VIES anymore. Post-Brexit, only Northern Ireland (XI) is in VIES. For mainland UK use HMRC's separate VAT API.
• Germany's VIES node is unreliable. DE runs 40-60% uptime; the actor skips DE by default and surfaces the reason. Enabling includeUnreliableCountries lets you try anyway.
• No national checksum validation. The actor pre-validates against country-specific length and character patterns but doesn't run national checksum algorithms (e.g., the Spanish DNI). VIES is the source of truth for validity.
• Not a Companies House replacement. VIES confirms VAT registration. It doesn't cross-check against corporate registries. For richer KYB pair with OpenCorporates Search or GLEIF LEI Lookup.

Key facts about EU VAT validation via the VIES API

• VIES is operated by the European Commission and is the official source for active VAT registration status across all 27 EU member states.
• A VIES consultation reference number is recognised as proof of verification under VAT Directive Article 138.
• VIES has no historical API — the portal can only confirm current status. Change detection has to be reconstructed across scheduled runs.
• Standard UK GB VAT numbers left VIES after Brexit; only Northern Ireland (XI) numbers remain in scope.
• The German VIES node is documented as chronically unreliable (40-60% uptime in observed runs) and is skipped by default by the actor.
• VIES rate-limits aggressively per country; France in particular returns MS_MAX_CONCURRENT_REQ errors at modest concurrency.
• The EU VAT Number Validator Apify actor charges $0.002 per validated number, with cache hits and skipped countries not charged.
• Apify's free tier covers approximately 2,500 validations per month before any paid usage applies.

Short glossary

• VIES — VAT Information Exchange System, the European Commission's database for confirming active VAT registrations across the EU.
• Consultation reference — A requestIdentifier returned by VIES when the requester supplies their own VAT. Tax authorities accept it as proof of verification.
• Pay-per-event (PPE) — Apify's pricing model where you pay per discrete output, not per minute of compute. See the PPE glossary entry.
• Webhook — A platform-level outbound HTTP POST fired on dataset events. See the webhook glossary entry.
• Circuit breaker — A pattern that stops calls to a failing dependency (here, VIES or a single member state's node) before failures cascade.
• KYB — Know Your Business; corporate-side identity verification, of which VAT validation is one component.

Where this pattern applies beyond VAT

Pay-per-validation against an authoritative public dataset isn't unique to VAT. The same shape applies to any compliance check that has:

1. A public source of truth with a REST endpoint (VIES, OFAC, GLEIF, Companies House, HMRC).
2. Per-jurisdiction quirks that punish naive callers (rate limits, format rules, downtime).
3. Audit-grade output that downstream teams need to archive.
4. Bulk demand that doesn't fit a portal UI.
5. Cross-run signal that only emerges from scheduled comparisons.

Sanctions screening, beneficial ownership lookups, tax ID validation in other regions — they all benefit from the same "thin compliance layer in front of a public source" approach. The actor is one example; the pattern is the broader story.

When you need this

You probably need a pay-per-validation EU VAT API if:

• You issue cross-border B2B invoices in the EU.
• You onboard EU suppliers and need to verify their VAT before paying them.
• Your customer or supplier database has more than a few dozen VAT numbers.
• You schedule any kind of compliance check and want diff signal between runs.
• You need audit-grade evidence under VAT Directive Article 138.

You probably don't need this if:

• You only ever check one VAT, once a year. The VIES portal is fine.
• All your counterparties are in mainland UK (GB) — they're not in VIES anymore.
• You need sub-100ms latency in a checkout path. Cache locally instead.
• Your stack is already running a maintained internal VIES service with circuit breakers, change detection, and audit bundling. Then keep what works.

Frequently asked questions

Is there a free EU VAT validation API?

The European Commission's VIES REST API is free to call directly, but it's a single-VAT-per-call service with no retries, no rate-limit handling, no change detection, and no audit bundle. The simplest pay-per-validation alternative is the EU VAT Number Validator Apify actor at $0.002 per number, with the first ~2,500 validations per month covered by Apify's free tier. For low monthly volume, you may not pay anything.

Do I need an API key for VIES?

No. VIES itself doesn't issue API keys. To use the EU VAT Number Validator Apify actor you only need an Apify token, which you already have if you have an Apify account. There's no separate provisioning step, no approval queue, no email-based onboarding.

How fast can I validate 1,000 EU VAT numbers?

Roughly 50 seconds end-to-end with the actor's 20 concurrent workers and per-country rate limiting. 100 numbers complete in about 10 seconds, 5,000 in about 4 minutes. The bottleneck is VIES response time (500ms-2s per call), not compute — so the actor runs on a 128-512 MB memory footprint.

Does this generate audit-grade evidence for tax filings?

Yes — when you set requesterVatNumber to your own EU VAT, the actor switches to verified consultation mode. VIES then returns a requestIdentifier per lookup, which EU tax authorities accept as proof of verification under VAT Directive Article 138. The actor also writes an AUDIT_BUNDLE record to the run's key-value store as a drop-in compliance archive.

Can I validate UK VAT numbers?

Standard UK (GB) VAT numbers left VIES after Brexit and aren't supported. Northern Ireland (XI) numbers are still in VIES and work normally. For mainland UK, use HMRC's separate VAT API or pair with Companies House lookups for entity verification.

How does this integrate with Slack, Jira, Salesforce, or n8n?

Through Apify Webhooks. Configure a webhook on the run, point it at Zapier, Make, or n8n, and branch on recommendedAction (block_invoice, hold_payment, request_certificate, review, retry_later) or recordType = "change-event". The actor produces structured signals; your existing automation layer routes them. For more on this pattern see the compliance and discovery learn guide.

What happens if VIES goes down mid-run?

A two-tier circuit breaker handles it. The global breaker stops the run after 10 consecutive infrastructure failures (full VIES outage). The per-country breaker isolates a single bad member state after 5 consecutive failures so a flaky DE node doesn't burn the rest of your spending limit. Failed rows are tagged failureType: "no-data-temp" with retryEligible: true so you can re-run them later without re-validating the rest.

How does this compare to building it myself?

Building a production-grade VIES wrapper requires per-country format pre-validation (28 jurisdictions), per-country rate limiting (France throttles aggressively, Germany's node runs 40-60% uptime), exponential backoff on MS_MAX_CONCURRENT_REQ and SERVICE_UNAVAILABLE, two-tier circuit breakers, change detection state across scheduled runs, audit consultation reference handling, and an audit bundle for tax filings. Internal-build estimates run 4-8 engineer-weeks before you have something tax-audit safe — and it stays a maintained service forever after that. At $0.002 per validation the actor is cheaper than one engineer-day of maintenance for most teams.

Common misconceptions

"VIES is just a checksum check."
No. VIES confirms the VAT is currently registered to a trader in a member state's tax database. Checksum-only libraries can tell you a VAT is plausibly formatted; only VIES confirms it's active. The two are not interchangeable.

"A successful VIES check means the company on the invoice matches the VAT."
It doesn't. VIES returns the registered trader name and address. It does not check that name against what's printed on your invoice. For supplier identity verification, use the actor's expectations field to score the match.

"You can use VIES for UK VAT validation."
Standard UK GB VAT numbers left VIES after Brexit. Only Northern Ireland (XI) is still in scope. For mainland UK, HMRC operates a separate VAT API.

Try it

The whole point of this article is the no-setup angle, so I'll be direct: the fastest way to see whether the EU VAT Number Validator fits is to paste 5 known VAT numbers into the input and click Start. The first ~2,500 validations per month sit inside Apify's free tier, so an honest first test costs nothing.

For a deeper view of how VAT validation fits into broader compliance and KYB workflows, see the compliance & sanctions screening comparison and the compliance use case on ApifyForge.

Ryan Clinton operates 300+ Apify actors and builds developer tools at ApifyForge.

Last updated: May 2026.

This guide focuses on the EU VIES system, but the same pay-per-validation pattern applies broadly to any compliance check that wraps a public, jurisdiction-fragmented source of truth.