MCP Verify Email: validate emails, phones, and data from ChatGPT, Claude, and other AI assistants

What is MCP VerifyEmails

MCP VerifyEmails is a service that allows you to use VerifierEmails tools directly from artificial intelligence assistants such as ChatGPT, Claude or other clients compatible with MCP.

Simply put: instead of manually entering an API, preparing technical calls, or interpreting complex responses, you can ask the assistant something like:

Valida este email: antxon.pous@gmail.com

or:

Valida este número de teléfono: 34677934019

or even:

He subido un fichero con emails. Los emails están en la primera columna. Valídalos.

The wizard uses the Verify Emails MCP service, runs the validation, and returns a natural language response.

The service is available at:

https://mcp.apinombres.workers.dev/

And the primary MCP endpoint is:

https://mcp.apinombres.workers.dev/mcp

This is the endpoint that is configured in ChatGPT, Claude, or any MCP-compatible client.

What is MCP VerifyEmails for?

The service is used to validate data from a chat.

It allows you to check emails, phone numbers, names, addresses and complete files. It also allows you to check the available credits in the VerificarEmails account.

This is useful for cleaning databases, reviewing contacts, validating leads, checking phone numbers before campaigns, detecting false data in forms or verifying entire files without leaving the AI assistant.

The service is designed for searches and uses such as:

MCP verificar email
MCP validar email
MCP validar números de teléfono
MCP validar datos
MCP validar ficheros
MCP VerificarEmails
VerificarEmails ChatGPT
VerificarEmails Claude

What data can be validated

MCP VerifyEmails allows you to work with different types of data.

You can verify an individual email using the tool validate_email.

You can validate a phone number using HLR using validate_phone.

You can check only the syntax of a phone using validate_phone_syntactic.

You can check the portability or operator of a number using validate_phone_mnp.

You can also validate names with validate_name, addresses with validate_address, search for similar names with fuzzy_search_name , and autocomplete partial names with name_complete.

In addition, the service allows you to validate entire files using validate_file, check the status of that validation with get_file_validation_status , and download the result with download_file_validation_result.

Configuring the MCP Service

The service published in:

https://mcp.apinombres.workers.dev/

Returns a description with the main configuration data.

The most important points are:

Servicio: verificaremails-mcp
Estado: online
Versión: 1.8.1
Endpoint MCP: https://mcp.apinombres.workers.dev/mcp
Transporte: http-json-rpc

It also indicates that it supports several versions of the MCP protocol:

2025-06-18
2025-03-26
2024-11-05

The normal user does not need to know all these details. The important thing to know is that the endpoint that must be configured in ChatGPT, Claude or the MCP client is:

https://mcp.apinombres.workers.dev/mcp

Settings in ChatGPT

To configure MCP VerifyEmails in ChatGPT, a new MCP application or connector is created.

On the configuration screen, you must indicate the name of the connector, for example:

Verificar Emails MCP

In the MCP server URL field, you enter:

https://mcp.apinombres.workers.dev/

or, if the client directly requests the MCP endpoint:

https://mcp.apinombres.workers.dev/mcp

The authentication must be:

OAuth

In advanced OAuth settings, the most important point is the registration method.

The following must be selected:

Registro dinámico de clientes (DCR)

This point is important because it allows ChatGPT to automatically register the OAuth client against the MCP server.

In the settings displayed by ChatGPT, available scopes or tools are usually automatically detected, such as:

validate_email
validate_phone
validate_phone_syntactic
validate_phone_mnp
validate_name
validate_address
fuzzy_search_name
name_complete
get_credits
get_service_credits
get_all_credits
validate_file
get_file_validation_status
download_file_validation_result

In most cases, these values do not have to be changed. ChatGPT detects them from the MCP server and shows them selected by default.

You may also see a notice that CIMD is unavailable because the server did not announce support for CIMD. This notice does not prevent you from using the service if you are using dynamic client registration using DCR.

The key point of the setup is:

Autenticación: OAuth
Método de registro: Registro dinámico de clientes (DCR)
URL del servidor MCP: https://mcp.apinombres.workers.dev/

What happens when you connect the MCP

When the connector is created and ChatGPT initiates the connection, a VerifyEmails authorization screen appears.

On that screen, the Verify Emails API token is requested.

The text that the user sees is similar to:

Conectar verificaremails.com

Introduce tu token API de verificaremails.com. El servidor MCP no almacena tokens de usuario. El token se entregará al cliente como access_token OAuth para que pueda llamar al MCP con Authorization: Bearer.

Token API de verificaremails.com

Autorizar MCP

This means that each user must enter their own Verify Emails token.

The Worker does not save the user’s token. The token is used so that ChatGPT can make calls to the MCP using Bearer authorization.

The idea is that each user will use their own Verify Emails credits and that the MCP service will act as a bridge between the AI assistant and Verify Emails.

Configuration in Claude

In Claude or other clients that support Remote MCP, the idea is similar.

The URL of the MCP server is indicated:

https://mcp.apinombres.workers.dev/mcp

The recommended authentication is:

OAuth

If the client allows you to choose dynamic logging, you should use:

Dynamic Client Registration

or:

DCR

If the client automatically detects the OAuth configuration from the MCP server, you typically don’t need to manually enter all endpoints.

Available OAuth endpoints

The MCP service publishes multiple OAuth endpoints so that clients can connect successfully.

The most important are:

Authorization endpoint:
https://mcp.apinombres.workers.dev/authorize

Token endpoint:
https://mcp.apinombres.workers.dev/token

Registration endpoint:
https://mcp.apinombres.workers.dev/register

OAuth metadata:
https://mcp.apinombres.workers.dev/.well-known/oauth-authorization-server

Protected resource metadata:
https://mcp.apinombres.workers.dev/.well-known/oauth-protected-resource

In a normal setup with ChatGPT or Claude, the user usually does not have to enter all these fields. The client detects them from the MCP server.

Still, it’s helpful to know them if you’re setting up an advanced client or your own integration.

Use from technical clients

In addition to ChatGPT or Claude, the service can also be used from technical clients, scripts or own tools.

In that case you can send the token directly as a Bearer:

Authorization: Bearer <TOKEN_DE_VERIFICAREMAILS>

For example, a technical customer can call the MCP endpoint with:

https://mcp.apinombres.workers.dev/mcp

and add the authorization header.

This mode is useful for developers, local testing, or custom integrations.

Verify an individual email from chat

One of the main functions of the service is to verify emails from the chat.

A real example of use was:

Utiliza VerificarEmails MCP 1.7 para validar el mail antxon.pous@gmail.com

The assistant replied:

Voy a buscar la herramienta disponible de VerificarEmails y usarla para validar esa dirección.

The wizard then called the corresponding MCP tool.

In the conversation appeared:

Herramienta llamada

And then the result was shown:

Validación realizada.

No es concluyente; el dominio acepta correos de forma amplia o no permite confirmar el buzón concreto con certeza.

This example shows the basic flow of MCP verify email.

The user writes the email, the wizard calls Verify Emails using MCP, and returns the result in an understandable sentence.

The specific answer always depends on what Verify Emails returns for that email. In this example, the result was “inconclusive.”

Why ChatGPT can ask for authorization before verifying

When an email, phone number or any other piece of information is validated, the assistant will call an external tool.

That is why ChatGPT can ask for authorization before executing the action.

This is normal. It is used for the user to confirm that they want to share that data with the MCP service of VerifyEmails.

The service declares its individual validation tools as read-only tools. In other words, they are designed to consult information, not to modify user data.

Even so, each platform decides when to ask for confirmation.

Validate a phone number from chat

The same flow can be used to validate phone numbers.

For example, the user can type:

Utiliza VerificarEmails MCP para validar el número 34677934019

The wizard can use the tool:

validate_phone

This tool verifies a phone using HLR query.

There are also two other phone-related options:

validate_phone_syntactic

to check if the number has a correct syntax, and:

validate_phone_mnp

to consult portability or operator.

This use is intended for searches such as:

MCP validar números de teléfono
MCP validar teléfono
validar teléfono desde ChatGPT
validar teléfono con Claude

Check available credits

MCP VerifyEmails also allows you to check the available credits.

The tools are:

get_credits
get_all_credits
get_service_credits

get_credits is an alias for get_all_credits.

If you want to check all the credits, you can order:

Consulta los créditos que me quedan

If you want to check the credits for a specific service, you can request:

Consulta los créditos que me quedan para email

The services supported for credits are:

name
phone
email
address
phonemnp
fuzzysearch
namecomplete
phonesyntactic

Validate files with emails, telephone numbers or other data

One of the most useful features of MCP VerifyEmails is file validation.

The user can upload a file to the chat and indicate where the data is.

For example:

Ahora quiero verificar los emails del fichero. Los mails están en la primera columna.

The wizard uses the tool:

validate_file

The process is asynchronous. This means that the file is sent to VerifyEmails, the system returns a request identifier and the status can be checked later.

That identifier is called:

request_id

Real example of file validation

In a real conversation, the user uploaded a file called:

Email.txt

and asked:

Ahora quiero verificar los emails del fichero. Los mails están en la primera columna.

The wizard initiated bulk email validation using the first column.

The CCM’s actual response was:

{
  "request_id": "6918337",
  "service": "validate_email",
  "api_service": "email",
  "filename": "Email.txt",
  "column": 1,
  "send_email": 0,
  "async": true,
  "status_tool": "get_file_validation_status",
  "download_tool": "download_file_validation_result"
}

The most important thing about this answer is:

request_id: 6918337

This number allows you to check the status of the process later.

Check the status of file validation

The user then asked:

Comprueba el estado de la verificación

The assistant used:

get_file_validation_status

The CCM’s actual response was:

{
  "request_id": "6918337",
  "service": "validate_email",
  "api_service": "email",
  "status": "Completado",
  "items": {
    "total": "2",
    "processed": "2",
    "pending": "0"
  },
  "credits": {
    "billed": "2.00",
    "not_billed": "0.00"
  },
  "name": "Email.txt",
  "date_created": "2026-05-12 14:21:04",
  "date_updated": "2026-05-12 14:21:20",
  "download_available": true,
  "completed": true
}

With this answer you can see that:

El estado es Completado.
El fichero tenía 2 registros.
Se procesaron 2 registros.
No quedó ningún registro pendiente.
Se facturaron 2.00 créditos.
El resultado está disponible para descarga.

Download and display the results of the file

When validation is complete, the user can request:

Píntame una tabla con los resultados de la verificación

The wizard uses:

download_file_validation_result

This tool downloads the result without displaying the internal download URL, because that URL contains the user’s token.

In a real test, the downloaded content was a CSV like this:

status,email,result,Email
No concluyente,apousb@yahoo.es,"{""status"":""ok_for_all""}",apousb@yahoo.es
No concluyente,isa@yahoo.es,"{""status"":""ok_for_all""}",isa@yahoo.es

Presented as a table:

apousb@yahoo.es

isa@yahoo.es

status	email	result	Email
Inconclusive		{"status":"ok_for_all"}	apousb@yahoo.es
Inconclusive		{"status":"ok_for_all"}	isa@yahoo.es

This table shows the actual data returned by the result file. It does not add invented information or interpret beyond the fields received.

Why the download URL isn’t showing

When EmailCheck generates the output of a file, there is an internal download URL.

That URL contains the user’s token, so it shouldn’t be displayed in the chat.

That’s why the MCP doesn’t return the URL directly. Instead, use the tool:

download_file_validation_result

This allows the wizard to read the result and display it as text or table, but without exposing the token.

Services available to validate files

File validation allows you to use these services:

validate_email
validate_phone
validate_phone_syntactic
validate_phone_mnp
validate_name
validate_address
fuzzy_search_name
name_complete

The user must indicate what they want to validate and in which column the data is.

For example:

Valida los teléfonos del fichero. Están en la segunda columna.

or:

Valida los emails del fichero. Están en la primera columna.

File inputs and outputs

The CCM can receive files in two ways:

file_base64
file_url

And it can return the results as:

text
base64

To work from a chat, the most convenient format is usually:

text

because it allows the wizard to directly read the CSV and convert it into a table.

Overview of available tools

Here are the main tools of the CCM:

Tool	Application
validate_email	Verify an individual email.
validate_phone	Validate a phone using HLR.
validate_phone_syntactic	Validate the syntax of a phone.
validate_phone_mnp	Check portability or operator.
validate_name	Validate name or surname.
validate_address	Validate and normalize address.
fuzzy_search_name	Search for similar name.
name_complete	Autocomplete name.
get_service_credits	Check credits for a service.
get_all_credits	Check all credits.
get_credits	Alias to check all credits.
validate_file	Start bulk file validation.
get_file_validation_status	Check the status of the file.
download_file_validation_result	Download validated result.

Advantages of MCP VerifyEmails

MCP VerifyEmails allows you to use VerifyEmails from a natural conversation.

Its main advantages are:

Permite verificar emails desde ChatGPT o Claude.
Permite validar números de teléfono con MCP.
Permite validar datos como nombres y direcciones.
Permite validar ficheros completos.
Permite consultar créditos.
No almacena tokens de usuario en el Worker.
No muestra URLs internas con auth-token.
Permite transformar resultados técnicos en tablas fáciles de leer.

Common use cases

This service can be used to:

Validar emails de clientes.
Comprobar teléfonos antes de una campaña.
Limpiar bases de datos.
Revisar leads.
Detectar datos incorrectos en formularios.
Validar ficheros de contactos.
Consultar créditos disponibles.
Usar VerificarEmails desde ChatGPT.
Usar VerificarEmails desde Claude.

Final summary

MCP VerifyEmails allows you to connect VerifyEmails with AI assistants such as ChatGPT, Claude, and other MCP-compatible clients.

The primary endpoint is:

https://mcp.apinombres.workers.dev/mcp

To set it up, the most important thing is:

Usar autenticación OAuth.
Seleccionar Registro dinámico de clientes (DCR).
Introducir el token API de VerificarEmails cuando se solicite.

From there, the user can request in natural language that emails, telephone numbers, names, addresses or complete files be validated.

This service is especially aimed at searches such as:

MCP verificar email
MCP validar números de teléfono
MCP validar datos

The goal is for anyone to be able to use EmailVerification from a chat, without having to manually build API calls or interpret complex technical responses.