Integrate Loqate with AI Agents using GBG Reach CLI or MCP
Addresses, emails, and phone numbers verified in real time, each one returning a confidence score, a policy-aware recommendation, and a full audit trail. An address verification API built for agents: call it from an agent, a service, or a terminal over CLI, MCP, Claude Agent Skill, or REST.
Use your existing Loqate API keys.
Fewer bad records, fewer manual reviews, and a decision you can show someone.
Bad data gets caught at the point of entry instead of surfacing later as a failed delivery, a bounced email, or an onboarding case someone has to work by hand. The policy decides accept, review, or reject, so agents and services act on a decision rather than a raw score. And every call returns the confidence, the policy applied, and the reason, so when a regulator or a colleague asks why a record was accepted, the answer already exists.
Running in one command.
CLI is the recommended interface for most use cases: one binary, works in any agent framework, and pipes straight into your tool loop.
# macOS (Apple Silicon - swap arm64 for amd64 on Intel) curl -sL https://github.com/gbgplc/lqt/releases/latest/download/lqt_darwin_arm64.tar.gz | tar xz sudo mv lqt /usr/local/bin/ export LOQATE_API_KEY=your-key-here lqt verify -a "10 Downing St, London, GB" --policy shipping -o json
Ten tools that return the same decision on every interface.
One decisioning engine sits behind the CLI, the hosted MCP server, the Claude Agent Skill and the REST API. Same input, same confidence score, same recommendation, whichever way you call it.
Verify an address with a confidence score, AVC-derived match level, and policy-aware recommendation.
Detect disposable domains, catch-all and fraud-risk flags, and deliverability risk level.
Validate phone numbers, detect type, and decide whether to proceed.
Run address, email, and phone together. The overall recommendation is the most conservative of the three, and the overall confidence is the lowest score across the fields checked.
Resolve a suggestion id to a cleansed address. This is the second half of the suggest loop, and it consumes a credit.
Parse and standardize messy input via Claude Haiku. No Loqate credits are spent (stdio only).
List the four built-in policies: strict, shipping, standard, permissive.
Inspect a policy's thresholds, match-level floor, and reject rules.
Register a custom policy for the current session (stdio only).
Describe your use case; get a recommended policy (stdio only).
Important notice·GBG is not responsible for any decisions, whether automated or not, that the Customer makes based on the information, Service, Results or data provided (including, but not limited to onboarding decisions) through any GBG for Agents capability.
A number your systems can act on.
Every address verification returns a score between 0 and 1, derived from Loqate's verification signals and country-aware coverage. The same input gives the same score every time, so any system can threshold it. There are no letter grades to interpret.
When you verify address, email, and phone together, the overall confidence is the lowest score across the fields checked, and the overall recommendation is the most conservative of the individual recommendations. One reject makes the whole result a reject.
The score is fixed, but the recommendation depends on the policy applied. Each card above assumes the standard policy. The same 0.70 that reads as review here comes back as accept under shipping, which is the example shown at the top of this page.
The same address can get different answers.
Four policies ship with Reach: strict for KYC, shipping for delivery, standard for general verification, and permissive for lead capture. You can also drop in a custom JSON policy tuned to any workflow.
KYC, fraud prevention, regulated
- Addr confidence
- 0.90
- Match level
- premise
- Email confidence
- 0.85
- Phone required
- yes
- Suggest below
- 0.90
Physical delivery, ecommerce
- Addr confidence
- 0.70
- Match level
- street
- Email confidence
- 0.50
- Phone required
- no
- Suggest below
- 0.85
General verification (default)
- Addr confidence
- 0.55
- Match level
- street
- Email confidence
- 0.45
- Phone required
- no
- Suggest below
- 0.85
Lead capture, early funnel
- Addr confidence
- 0.30
- Match level
- locality
- Email confidence
- 0.30
- Phone required
- no
- Suggest below
- 0.70
| Policy | Addr confidence | Match level | Email confidence | Phone required | Suggest below | Use case |
|---|---|---|---|---|---|---|
| strict | 0.90 | premise | 0.85 | yes | 0.90 | KYC, fraud prevention, regulated |
| shipping | 0.70 | street | 0.50 | no | 0.85 | Physical delivery, ecommerce |
| standard | 0.55 | street | 0.45 | no | 0.85 | General verification (default) |
| permissive | 0.30 | locality | 0.30 | no | 0.70 | Lead capture, early funnel |
A rejected address doesn't have to be a dead end.
When an address doesn't clear the policy, Reach returns real alternatives instead of a dead stop. The agent can put them to the customer, pick the right one, re-verify it, and carry on with the journey.
Requires a separately licensed Loqate feature. Address-only and off by default. Full flags and options are in the docs.
Call it however your agent likes.
Output parity is a design principle: same input produces the same confidence score across CLI, MCP, Claude Agent Skill, and REST.
A single Go binary. Verify, parse, pipe the JSON, ship it. Batch a whole CSV, TSV, or pipe-delimited file in one command. Exports a ready-made tool definition for LangChain, OpenAI, or any agent framework.
lqt verify -a "10 Downing St, London, GB" \
-e "user@example.com" \
-p "+442079460000" \
--policy strict -o jsonStdio for local agents (10 tools). HTTP for hosted deployments (7 tools) with per-IP rate limiting, request logging, and a /health endpoint. Supports tools & prompts.
lqt mcp # stdio lqt mcp --http :8080 # HTTP, rate-limited
Verification inside Claude. Connect once, ask in plain language, get decisions. Install via npx.
# Claude Code - from GitHub npx skills add https://github.com/gbgplc/loqate-skill
A plain HTTP + JSON API over the same decisioning engine, callable from any backend in any language. It ships with a full OpenAPI spec.
See the REST API sectionWhichever of the four you use, the same input returns the same confidence score and the same recommendation.
Connect Loqate to your MCP client in two steps.
We host the HTTP MCP server, so Claude, Cursor, Windsurf, Copilot, or any MCP-compatible client can connect without you deploying anything. For non-MCP integrations, use the REST API above.
Add the Loqate connector
Works in any MCP-compatible client, with no install required.
- 1Open your MCP client's connector settings
- 2Add a new connector named "Loqate"
- 3Paste the server URL below and save
Provide your Loqate key
The Loqate tools need an API key to call the service. How you provide it depends on your client.
Get an API keyAn admin adds your key once, and every team member gets it automatically.
<loqate_api_key>YOUR-KEY</loqate_api_key>Same tag, scoped to your own profile. Great for personal accounts.
<loqate_api_key>YOUR-KEY</loqate_api_key>Type your key in chat and it's used for the session. Fastest way to try it out.
Loqate tools accept a key parameter on every call. Most MCP clients let you set default tool parameters in their config. Add your API key there so it is passed automatically.
A decision over plain HTTP.
GBG Loqate verifies the data. Reach adds the decision on top: a 0 to 1 confidence score, a policy-driven accept, review or reject, and an audit trail. It works as a plain address verification API, so any backend can get that decision over a standard REST call, with no agent, CLI or MCP client in the way.
curl -X POST https://reach.prod.fabric.gbgplatforms.com/v1/verify/contact \
-H "Authorization: Bearer $LOQATE_API_KEY" \
-H "Content-Type: application/json" \
-d '{"address":"10 Downing St, London, GB","email":"user@example.com","phone":"+442079460000","policy":"strict"}'Same decisioning engine, plain HTTP
REST puts Reach in front of workloads that have nothing to do with agents. If it can make an HTTPS call, it can get the same confidence score, policy recommendation, and audit trail.
Validate address, email, and phone inline and act on the recommendation before the record is created.
Score existing records in bulk, route reviews, and evidence what was checked and when.
Call it from any language or job runner. Generate an SDK straight from the OpenAPI 3.1 spec.
Wire it into Zapier, n8n, Workato, or an iPaaS step with a bearer token and a JSON body.
Get started with your existing Loqate API keys.
Install the binary and run your first verification in under five minutes. Running full onboarding journeys rather than single verifications? That’s GoPlane.
Questions? Email labs@gbg.com
Frequently asked questions
How do I install Reach?
Download the pre-built lqt binary from https://github.com/gbgplc/lqt/releases/latest, place it on your PATH, set LOQATE_API_KEY, and run `lqt verify -a "your address" --policy shipping -o json`. Builds are provided for macOS (Apple Silicon and Intel), Linux (x86_64 and ARM64), and Windows (x86_64).
Which agent frameworks does Reach support?
Anything that speaks MCP (Claude Desktop, Claude Code, Cursor, Cline, Copilot), the Claude Agent Skill format, anything that can call a CLI, or anything that can make an HTTPS request to the REST API. Use `lqt tool-description` to export a JSON tool schema for LangChain, OpenAI tool-calling, and other frameworks.
What policies are built in?
Four built-in policies: strict (KYC), shipping (deliverability), standard (general), and permissive (marketing). Custom policies can be registered per session.
What does Reach cost?
Get started with your existing Loqate API keys. Verification calls draw from your Loqate account credits. If you want to talk through volumes or commercial terms, email labs@gbg.com.
Why does the MCP config ask for an ANTHROPIC_API_KEY?
One tool uses it: parse_address, which parses messy free-text input before verification. The tool is optional, it runs over stdio only, and every other tool works without it. The key is your own Anthropic key, set in your own MCP config on your own machine. GBG does not supply it, store it, or see it. If you leave it out, parse_address is unavailable and the rest of Reach runs normally.
Does Reach have a REST API?
Yes. Reach exposes a REST + JSON API at https://reach.prod.fabric.gbgplatforms.com. It runs on the same decisioning engine as the CLI, MCP server, and Claude Agent Skill, and returns identical output. Authenticate with your Loqate API key as a bearer token. Full docs and the OpenAPI spec are linked in the REST API section above.
Can I use Reach without AI agents?
Yes. The REST API makes Reach usable from any non-agentic workload: checkout and signup forms, batch data cleanup, backend services and ETL jobs, and low-code or iPaaS tools such as Zapier, n8n, and Workato. You get the same confidence scores, policy-driven accept / review / reject recommendations, and audit trail as the CLI, MCP server, and Claude Agent Skill, and you can generate an SDK from the OpenAPI 3.1 spec.
What happens when an address does not clear the policy?
Reach can return alternatives instead of a dead end. With --suggest (or the suggest flag on verify_address / verify_contact), a review or reject result comes back with candidate addresses under address.suggestions. Verify the chosen one with --suggestion-id, or resolve it via the retrieve_address MCP tool. That resolution consumes a Loqate credit. Address suggestions require a separately licensed Loqate feature on your account.
Can I generate an SDK or add Reach to my LLM tool loop?
Yes. Reach ships an OpenAPI 3.1 spec, so you can auto-generate client SDKs, import it into Postman, or drop it straight into OpenAI/LangChain tool-calling.
What is an MCP?
MCP stands for Model Context Protocol. It's a shared standard that lets AI assistants like Claude, Cursor, Copilot or ChatGPT plug into outside tools safely. Think of it as a universal socket: once a product exposes an MCP server, any MCP-compatible AI can use its features without a custom integration. Reach ships an MCP server, so an agent can verify addresses, emails and phones as tools.
What is a CLI?
CLI stands for Command Line Interface. It's a small program you run in a terminal by typing commands, instead of clicking around a website. Developers, scripts and AI agents can all call a CLI to do work and get results back. Reach ships as a single lqt binary, and it runs the same decisioning engine as the MCP server, the Claude Agent Skill and the REST API, so a build pipeline and an agent get identical results.
What is an agent experience layer?
Reach is the agent experience layer on top of Loqate. It gives your agents address, email and phone verification natively, with confidence scores and a policy-driven accept, review or reject recommendation. No wrestling with the API, no bespoke integration.