Byteplant Validator MCP Server
OfficialClick on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Byteplant Validator MCP Servervalidate email address user@example.com"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
This is an MCP server that connects AI assistants such as Claude, Cursor and VS Code to the Byteplant validation APIs. Ask your assistant to check an email address, phone number or postal address, and it calls the matching Byteplant tool and reads back the result.
The server runs locally on your computer and talks to your MCP client over stdio.
Installation
The easiest way to run the server is with uv. uvx downloads the package and a suitable Python version automatically, so there is nothing else to install.
Add the server to your MCP client with one of the configurations below, and replace the placeholders with your API keys. You only need the keys for the services you use.
Claude Desktop
In Claude Desktop, go to Settings → Developer → Edit Config. This opens
claude_desktop_config.json:macOS:
~/Library/Application Support/Claude/claude_desktop_config.jsonWindows:
%APPDATA%\Claude\claude_desktop_config.json
Add the Byteplant server:
{ "mcpServers": { "byteplant": { "command": "uvx", "args": ["byteplant-mcp@latest"], "env": { "EV_TOKEN": "<EMAIL VALIDATOR API KEY>", "PV_TOKEN": "<PHONE VALIDATOR API KEY>", "AV_TOKEN": "<ADDRESS VALIDATOR API KEY>" } } } }Restart Claude Desktop.
Claude Code
claude mcp add \
--env EV_TOKEN=<EMAIL VALIDATOR API KEY> \
--env PV_TOKEN=<PHONE VALIDATOR API KEY> \
--env AV_TOKEN=<ADDRESS VALIDATOR API KEY> \
--transport stdio byteplant -- uvx byteplant-mcp@latestCursor
Add the same mcpServers entry as for Claude Desktop to ~/.cursor/mcp.json (all projects) or .cursor/mcp.json (one project).
VS Code
Add the server to .vscode/mcp.json in your project:
{
"servers": {
"byteplant": {
"type": "stdio",
"command": "uvx",
"args": ["byteplant-mcp@latest"],
"env": {
"EV_TOKEN": "<EMAIL VALIDATOR API KEY>",
"PV_TOKEN": "<PHONE VALIDATOR API KEY>",
"AV_TOKEN": "<ADDRESS VALIDATOR API KEY>"
}
}
}
}Using pip instead of uv
pip install byteplant-mcpThis installs a byteplant-mcp command. Use its full path as the command, because desktop apps often don't see your shell's PATH (find it with which byteplant-mcp on macOS/Linux or where byteplant-mcp on Windows):
"command": "/full/path/to/byteplant-mcp"Alternatively, run the module with the Python installation you installed it into:
"command": "/path/to/python",
"args": ["-m", "byteplant_mcp"]Related MCP server: email-verify
Tools
Tool | What it does |
| Checks whether an email address is deliverable and detects freemail providers |
| Validates a phone number and returns its line type, carrier codes, location and formats |
| Validates and standardizes a postal address, with optional geocoding |
Credentials
Each tool uses its own API key, passed to the server as an environment variable. Sign up for the service you need to get one:
Environment variable | Used by | Get an API key |
|
| |
|
| |
|
|
You can manage your keys in your Byteplant account. If a key is missing, the matching tool tells the assistant which variable to set instead of calling the API.
Usage
Just ask your assistant in plain language, for example:
"Is support@byteplant.com a valid email address?"
"Check whether +49 9874 322466 is a mobile or a landline number."
"Validate this address and give me the standardized version: Heilsbronner Str. 4, 91564 Neuendettelsau, Germany."
The assistant fills in the tool parameters below. Every tool also has a timeout parameter, which sets how long the API may take to respond: 5–300 seconds, 10 by default.
validate_email - API Docs
Parameter | Required | Description |
| ✅ | The email address to validate |
Output
Field | Description |
| Numeric result code, e.g. |
| Added by the server: |
| Added by the server: what the |
| |
| |
|
|
validate_phone - API Docs
Parameter | Required | Description |
| ✅ | The phone number to validate, in national format or in international format with a leading |
| Two-letter ISO 3166-1 country code. Optional if the phone number is in international format. | |
| IETF language tag for geocoding results. Defaults to | |
|
|
Output
Field | Description |
|
|
|
|
| Geographical location (city, county, state) |
| Two-letter ISO 3166-1 country code |
| Phone number in national format |
| Phone number in international format |
| Mobile country code, which identifies the mobile network operator (carrier) |
| Mobile network code, which identifies the mobile network operator (carrier) |
validate_address - API Docs
Parameter | Required | Description |
| ✅ | Two-letter ISO 3166-1 country code. Use |
| ✅ | Street, house number and building. May include the unit or apartment, or even the complete address. |
| House or building number, if it isn't part of | |
| Building, unit, apartment or floor | |
| City or locality | |
| ZIP or postal code | |
| State or province | |
| Whether to return coordinates for the address. Off by default. | |
| Output language for countries with more than one postal language. Use it only to translate addresses, and leave it empty for address validation. | |
|
|
Output
Field | Description |
|
|
| Full address in standardized format |
| Additional address details (building, unit, apartment, suite) |
| Street in standardized format |
| Street number in standardized format |
| ZIP or postal code in standardized format |
| City in standardized format |
| District in standardized format |
| County in standardized format |
| State or province in standardized format |
| Two-letter ISO 3166-1 country code |
| Address type: |
| Residential Delivery Indicator: commercial or residential |
| Hints about errors in the address input. See the full list of diagnostic hints. |
| Hints about which parts of the address input were fixed. See the full list of correction hints. |
| Coordinates. Only returned for valid addresses when |
Compatibility
Requirement | Version |
Python | 3.10 or later (installed automatically by |
MCP client | Any client that runs local stdio servers, e.g. Claude Desktop, Claude Code, Cursor, VS Code, Windsurf or OpenAI Codex |
ChatGPT and Claude on the web or mobile only connect to remote (hosted) MCP servers, so they can't use this server yet.
Resources
Contact: contact@byteplant.com
License
Available Tools
3 toolsvalidate_addressValidate a postal addressARead-only
Validate and standardize a postal address and return its status, standardized address components, and optionally its coordinates.
Result fields:
status (string): VALID: address is correct and deliverable. SUSPECT: address is incorrect and needs corrections to be deliverable, a suggested correction is provided. INVALID: address is incorrect and not deliverable - either there is no match at all in the reference data or the address is ambiguous and there are a lot of different matches. In these cases automatic correction suggestions are not available. DELAYED, NO_COUNTRY, RATE_LIMIT_EXCEEDED, API_KEY_INVALID_OR_DEPLETED, RESTRICTED, INTERNAL_ERROR
formattedaddress (string): full address in standardized format
supplement (string): additional address details (building / unit / apt / suite etc.)
street (string): street address in standardized format
streetnumber (string): street number in standardized format
postalcode (string): zip / postal code in standardized format
city (string): city in standardized format
type (string): address type: S = Street address | P = P.O. Box, Pick-Up or other delivery service
rdi (string): Residential Delivery Indicator (Commercial / Residential)
district (string): district in standardized format
county (string): county in standardized format
state (string): state / province in standardized format
country (string): two-letter ISO 3166-1 country code
latitude (number): latitude (for valid addresses if Geocoding is enabled)
longitude (number): longitude (for valid addresses if Geocoding is enabled)
diagnostics (string): detailed diagnostic hints, indicating errors in the address input
corrections (string): detailed correction hints, indicating which parts of the address input have been fixed
ratelimit_remain (int): number of API requests remaining before the API rate limit is reached (the default API rate limit allows 100 API requests in 300s)
ratelimit_seconds (int): number of seconds remaining in the current rate limit interval
| Name | Required | Description | Default |
|---|---|---|---|
| city | No | ||
| code | Yes | Two-letter ISO 3166-1 country code, 'XX' for international | |
| state | No | ||
| locale | No | Output language for countries with multiple postal languages, as an IETF language tag. Use only to translate addresses; always leave empty for address validation | |
| charset | No | Output character set: 'utf-8' or 'us-ascii' | utf-8 |
| timeout | No | Timeout in seconds (min 5, max 300, default 10) | |
| geocoding | No | Return latitude and longitude for valid addresses | |
| street_adr | Yes | Street, house number and building, may include unit/apt etc. May also contain the complete address (leave the other optional fields empty then). Always use ',' to separate address elements where required | |
| street_num | No | House number/building, if it isn't part of street_adr | |
| postal_code | No | ||
| additional_info | No | Building/unit/apt/floor etc. |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only declare readOnlyHint and openWorldHint, but the description discloses the full failure surface: DELAYED, NO_COUNTRY, RATE_LIMIT_EXCEEDED, API_KEY_INVALID_OR_DEPLETED, RESTRICTED, INTERNAL_ERROR, and concrete rate-limit numbers (100 requests / 300s, with remaining count and seconds). It also explains that corrections are unavailable for INVALID/ambiguous input, which is meaningful operational context an agent needs to handle responses.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The opening sentence is well front-loaded, but the bulk of the text is a field-by-field enumeration of return values, which is redundant because an output schema already exists. The status-code semantics are worth keeping; the remaining per-field listing does not earn its space.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With an output schema present, the description is not obliged to explain return values, and it still adds useful status semantics and rate-limit behavior. The main gap is the absence of any input-parameter guidance for a tool with 11 parameters, but the schema covers most of them.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 73%, which is close to the high-coverage band where the schema does the heavy lifting, and the description adds nothing about input parameters at all. Notably it does not compensate for the undocumented city, state and postal_code fields, so it lands at the baseline rather than above it.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The first sentence states a specific verb+resource ('validate and standardize a postal address') plus the return shape (status, standardized components, optional coordinates). Against siblings validate_email and validate_phone the resource alone is unambiguous, so an agent can route correctly without opening the schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no explicit when-to-use or when-not sentence; usage is only implied by the name and by the note that coordinates are returned only 'for valid addresses if Geocoding is enabled'. The geocoding conditional is the closest thing to a usage rule, so the score sits at implied-usage level rather than clear guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
validate_emailValidate an email addressBRead-only
Validate an email address and return info about it.
Result fields:
status (int): API result code. 401, 118 and 119 status codes indicate API errors: 401 -> info: 'Email address missing' 118 -> info: 'Rate Limit Exceeded' 119 -> info: 'API Key Invalid or Depleted'
info (string): short status description
details (string): full status description
freemail (boolean): indicates freemail addresses (Gmail, Yahoo, Outlook/Hotmail/Live, AOL, ...) [true | false]
ratelimit_remain (int): number of API requests remaining before the API rate limit is reached (the default API rate limit allows 100 API requests in 300s)
ratelimit_seconds (int): number of seconds remaining in the current rate limit interval
category, status_description: added from the numeric status code (category is VALID, SUSPECT, INVALID, INDETERMINATE or UNKNOWN)
| Name | Required | Description | Default |
|---|---|---|---|
| Yes | The email address to validate | ||
| timeout | No | Timeout in seconds (min 5, max 300) |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only supply readOnlyHint and openWorldHint, so the description carries the rest and does so well: it documents rate-limit behavior (100 requests per 300s), the ratelimit_remain/ratelimit_seconds fields, and specific error codes (401 missing address, 118 rate limited, 119 invalid/depleted API key, implying an API key is required). That is meaningful operational context beyond the structured fields.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The core purpose is front-loaded in one sentence, but the bulk of the body is an enumerated list of result fields, which duplicates the existing output schema and does not earn its place in a tool description. Structure is readable but somewhat bloated with redundant return-value documentation.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a two-parameter read-only validation tool, the description covers error semantics, rate limiting, and the meaning of the category enum, which is enough for correct invocation. The return-value section is redundant given the output schema, but nothing essential is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% (email and timeout both documented in the schema), so the baseline is 3. The description adds nothing about the timeout parameter or accepted email formats, but it does explain what the operation does with the address, so it is not below baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a concrete verb+resource: 'Validate an email address and return info about it.' The resource (email) is distinct from the sibling tools validate_address and validate_phone, so an agent can route correctly even though siblings are never named explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no statement about when to use this tool versus validate_address or validate_phone, and no prerequisites or exclusions are given. Usage is only inferable from the name and first sentence, which is the minimum implied context rather than real guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
validate_phoneValidate a phone numberBRead-only
Validate a phone number and return its status, line type, carrier codes, location and national/international formats.
Result fields:
status (string): VALID_CONFIRMED, VALID_UNCONFIRMED, INVALID, DELAYED, RATE_LIMIT_EXCEEDED, API_KEY_INVALID_OR_DEPLETED
linetype (string): FIXED_LINE, MOBILE, VOIP, TOLL_FREE, PREMIUM_RATE, SHARED_COST, PERSONAL_NUMBER, PAGER, UAN, VOICEMAIL
location (string): geographical location (city, county, state)
countrycode (string): two letter ISO 3166-1 country code
formatnational (string): phone number in national format
formatinternational (string): phone number in international format
mcc (string): mobile country code to identify a mobile network operator (carrier) using the GSM (including GSM-R), UMTS, and LTE networks
mnc (string): mobile network code to identify a mobile network operator (carrier) using the GSM (including GSM-R), UMTS, and LTE networks
ratelimit_remain (int): number of API requests remaining before the API rate limit is reached (the default API rate limit allows 100 API requests in 300s)
ratelimit_seconds (int): number of seconds remaining in the current rate limit interval
| Name | Required | Description | Default |
|---|---|---|---|
| code | No | Two letter ISO 3166-1 country code. Required for numbers in national format; leave empty if the number starts with '+' | |
| mode | No | 'extensive' (full validation) or 'express' (static checks only, faster) | extensive |
| phone | Yes | Phone number to validate, in national format or international format with a leading '+' | |
| locale | No | IETF language tag for geocoding results | en-US |
| timeout | No | Timeout in seconds (min 5, max 300) |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations declare readOnlyHint=true and openWorldHint=true, so safety is already covered, and the description adds genuinely useful behavior: enumerated status outcomes (RATE_LIMIT_EXCEEDED, API_KEY_INVALID_OR_DEPLETED, DELAYED) and explicit rate-limit semantics (100 requests per 300s). This tells the agent what failure and throttling look like, which the annotations do not.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The lead sentence is front-loaded and efficient, but the bulk of the text enumerates result fields that duplicate the existing output schema. That enumeration is largely redundant and crowds out more valuable guidance such as when to use express vs extensive.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With an output schema present, the description need not re-explain return values, and it covers the core purpose plus rate-limit behavior. The main gap is the absence of usage guidance for mode selection and country-code handling, but the tool is otherwise callable as described.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents phone, code, mode, locale, and timeout. The description adds no parameter-level meaning beyond that, so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb ('validate') and resource ('phone number') plus the returned data categories, so an agent can immediately distinguish it from validate_email and validate_address by resource. It does not explicitly name siblings, but the resource is unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives no when-to-use guidance, no prerequisites, and no exclusions. It never explains the tradeoff between the extensive and express modes that the schema exposes, nor when a country code is needed beyond what the schema already says.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
3 tool updates
v1.1.0- First observed
validate_address - First observed
validate_email - First observed
validate_phone
TDQS
Scored across 3 tools
Each tool targets a distinct data type (email, address, phone) with no overlap in purpose. An agent can easily select the correct tool based on input type.
All tools follow the same predictable verb_noun pattern: validate_email, validate_address, validate_phone. No naming deviations or mixed conventions.
Three tools cleanly cover the three core validation domains. The count is well-scoped with each tool earning its place.
The server provides complete validation coverage for email, postal address, and phone number, which are the primary contact-data validation needs. No obvious missing operations for a read-only validation service.
Related MCP Connectors
BounceBan MCP — wraps the BounceBan email-verification API (bounceban.com)
1Email validation for Claude and any MCP client — verdicts with evidence and bulk jobs.
Verify addresses, email addresses, and phone numbers with confidence scores.
Emailable MCP — wraps the Emailable email verification API (emailable.com)
Related MCP Servers
- AlicenseAqualityCmaintenanceEmail validation MCP server using MailboxValidator API to determine validity of an email address.337 npm1MIT
- AlicenseAqualityDmaintenanceEnables real-time email verification via MCP tools, checking syntax, MX, disposable domains, and optional SMTP probe to determine deliverability with a VALID/RISKY/INVALID verdict.211 npmMIT
- FlicenseNot gradedqualityDmaintenanceComprehensive email validation MCP server that checks syntax, MX records, disposable domains, role-based accounts, SPF/DKIM, typo suggestions, and risk scoring.-

Tomba Agent Pluginsofficial
AlicenseNot gradedqualityBmaintenanceProvides email discovery, verification, enrichment, and company research through a remote MCP server.MIT