VAT Validation with Make

Make (formerly Integromat) does not have a native VAT validation module. You can call Avatcado from any Make scenario using the HTTP module, which supports custom headers and JSON response parsing. No code required.

This guide walks through setting up a Make scenario that validates a VAT number and routes the result to different actions.

When to use this

Make is a good fit when you want to validate VAT numbers as part of a multi-step automation. Common use cases:

• Validate a VAT number when a new CRM record is created (HubSpot, Salesforce, Pipedrive)
• Validate when a form submission comes in (Typeform, Google Forms, Tally)
• Validate as part of a customer or partner onboarding scenario
• Periodic revalidation of existing records using a scheduled scenario

Setting up the HTTP module

Add an HTTP module to your scenario and configure it to call the Avatcado API.

1. Add the module

In your scenario, add a new module. Search for "HTTP" and select "Make a request" as the action.

2. Configure the request

• URL: https://api.avatcado.com/v1/validate?vat_number={{vat_number}} (map the VAT number from a previous module)
• Method: GET
• Headers: add a header with name Authorization and value Bearer avat_live_your_api_key
• Parse response: set to Yes so Make exposes the JSON response fields as variables in subsequent modules

3. Test the module

Run the module once with a real or test VAT number. Make will display the parsed response. You should see data.valid, data.company.name, and data.country_code as available fields. A real Avatcado response looks like this:

{
  "data": {
    "valid": true,
    "vat_number": "NL123456789B01",
    "country_code": "NL",
    "company": {
      "name": "EXAMPLE B.V.",
      "address": "KEIZERSGRACHT 100, 1015 AA AMSTERDAM"
    },
    "requested_at": "2026-08-07T10:30:00.000Z"
  },
  "meta": {
    "request_id": "550e8400-e29b-41d4-a716-446655440000",
    "cached": false
  }
}

Every field under data becomes a mappable variable in later modules, referenced as {{2.data.valid}} or {{2.data.company.name}} (where 2 is the HTTP module's position in the scenario).

Using the result

After the HTTP module, use a Router to branch the scenario based on the validation result.

• Valid branch: add a filter that checks data.valid equals true. In this branch, update the CRM record with the registered company name from data.company.name.
• Invalid branch: add a filter that checks data.valid equals false. Send a notification (Slack, email, or a task in your project management tool) so someone can follow up.

You can also skip the Router and use a single Filter module if you only need to act on one outcome (e.g., only notify on invalid numbers).

Handling errors and non-200 responses

The HTTP module in Make does not automatically fail a scenario on a non-200 status code unless you check "Evaluate all states as errors (except for 2xx and 3xx)" in the module's advanced settings. For VAT validation, decide deliberately: a 422 means the VAT number is malformed (checksum or format failure), and a 503 means the upstream registry (VIES, HMRC, or a national registry) is temporarily unavailable.

• 422 invalid_vat_format: Treat this as a user input error. Route it to a branch that flags the record for manual review instead of retrying automatically.
• 503 upstream_unavailable: Avatcado already serves a cached, stale result when one exists (check meta.stale in the response). If there is no cached result, add a retry with Make's built-in error handler and a short delay before failing the run.
• 429 rate_limit_exceeded: If you are validating many records in a loop, add a Sleep module between iterations or reduce the scenario's execution frequency to stay within your plan's rate limit.

Scheduled revalidation

VAT registrations can lapse, so periodic revalidation of existing CRM records is common practice for subscription businesses. Build a second scenario on a schedule trigger (for example, monthly) that:

• Retrieves a batch of existing accounts from your CRM with a Search Records module
• Uses an Iterator to loop over each account's stored VAT number
• Calls the same HTTP module pattern described above for each one
• Writes the updated validation result and timestamp back to the record

Because Avatcado caches results for 25 days, a monthly revalidation scenario mostly hits fresh upstream data rather than the cache, which is the point: you want to catch VAT numbers that were deregistered since the last check.

Limitations

• Not built for bulk backlogs. Make supports iterators and aggregators for processing multiple items within a single scenario run, but each item still makes a separate HTTP request and counts against your Make operations quota. For validating thousands of existing records in one pass, the Avatcado batch endpoint (up to 50 numbers per request) is far more efficient, and the async endpoint handles even larger volumes via webhooks.
• No native retry/backoff. Unlike a purpose-built SDK, Make's HTTP module does not retry failed requests automatically. You need to configure Make's error handler directives (Resume, Ignore, Rollback, Break, Commit) explicitly if you want resilience against transient upstream failures.
• Field mapping is manual. Every response field you want to use downstream must be mapped explicitly in each subsequent module. There is no schema validation to catch a typo in a mapped field name until the scenario runs and the field resolves to empty.

Get started

Create a free Avatcado account →

Read the API documentation for the full endpoint reference. For a broader overview of CRM integration patterns, see the CRM validation guide.