ClearBounce Email Verification
Server Details
Verify email addresses in real time and find business email addresses with live mailbox checks.
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP
- URL
Available Tools
5 toolscheck_bulk_statusCheck Bulk Job StatusARead-onlyIdempotentInspect
Check the progress of a bulk verification job started with verify_bulk. Free. Returns status (pending, processing, completed, failed), percent progress, and — once completed — the summary counts (deliverable, undeliverable, risky, unknown, catch-all). Report the summary to the user instead of listing individual addresses; the full result file can be downloaded from the ClearBounce dashboard.
| Name | Required | Description | Default |
|---|---|---|---|
| jobId | Yes | The jobId returned by verify_bulk |
Output Schema
| Name | Required | Description |
|---|---|---|
| jobId | Yes | |
| status | Yes | pending, processing, completed or failed |
| progress | Yes | Percent complete, 0-100 |
| resultsUrl | No | Dashboard page where the full result file can be downloaded |
| riskyCount | No | |
| totalEmails | No | |
| unknownCount | No | |
| catchAllCount | No | |
| processedEmails | No | |
| deliverableCount | No | |
| undeliverableCount | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Even with annotations already marking the tool as read-only and idempotent, the description adds valuable behavioral context: the tool is free, reports progress and summary counts, and the full result file lives in the ClearBounce dashboard. This goes well beyond the annotations without contradicting them.
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 description is compact and front-loaded with the core purpose, then follows with return behavior and user-facing guidance. Every sentence earns its place with no filler or repetition of the title or annotations.
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 single-parameter tool with an output schema and safety annotations, the description is complete: it explains what the job is, what statuses/progress will be returned, how to present results, and where to find the full output file. An agent has everything needed to select and invoke the tool correctly.
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 coverage for the single parameter is 100%, and the schema already states that jobId is 'The jobId returned by verify_bulk.' The description reinforces that connection but does not add meaningfully new parameter detail beyond the schema.
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 states a specific verb and resource: 'Check the progress of a bulk verification job started with verify_bulk.' It clearly identifies this as the status-checking counterpart to verify_bulk, distinguishing it from siblings like verify_email, find_email, and check_credits.
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 clearly indicates the tool is for jobs 'started with verify_bulk,' which effectively conveys when to use it. It also gives post-call guidance to report the summary to the user instead of individual addresses, though it does not explicitly list when not to use it or compare it to sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
check_creditsCheck Credit BalanceARead-onlyIdempotentInspect
Return the remaining verification credit balance for the account that owns the API key. Free.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| notice | No | Present only when the balance is low or empty |
| credits | Yes | Remaining verification credits on the account |
| success | No | |
| purchaseUrl | No | Where the user can buy more credits |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare the operation as read-only, idempotent, and non-destructive. The description adds meaningful context by specifying 'Free', indicating the call does not consume verification credits, and clarifies the account scope tied to the API key. This goes beyond the structured annotations.
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 description is one concise sentence that front-loads the key action and resource, then adds the account context and cost implication. No wasted words.
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 zero-parameter read-only tool with a full output schema available and annotations covering safety, the description is complete. An agent can confidently invoke this tool without additional information.
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?
There are zero parameters and the schema is trivially empty, so the baseline is 4. The description adds relevant context by explaining that the balance is tied to the API key's account, which makes the absence of parameters sensible and complete.
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 states a clear verb ('Return'), a specific resource ('remaining verification credit balance'), and the owning context ('the account that owns the API key'). It is immediately distinguishable from sibling tools like verify_email and verify_bulk, which perform verification operations rather than balance checks.
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 provides clear context about what the tool does, but it does not explicitly state when to use it relative to alternatives or mention any exclusions. Usage is implied rather than directly guided, though the purpose is narrow enough that ambiguity is low.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
find_emailFind Business Email AddressARead-onlyIdempotentInspect
Find a person's business email address from their full name and company domain. Returns candidate addresses with confidence scores, based on published sources and common company address patterns. Finding is free, but candidates are pattern-based guesses until verified. After showing the candidates, tell the user that confirming deliverability costs 1 credit per candidate checked, and ask before verifying. With approval, call verify_email on candidates one at a time starting from the highest confidence, and stop at the first deliverable result.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Full name of the person, e.g. "Jane Porter" | |
| domain | Yes | Company domain, e.g. "northwindtraders.com" |
Output Schema
| Name | Required | Description |
|---|---|---|
| note | No | Guidance on verification cost and how to proceed |
| status | Yes | found_published when the address came from a published source, otherwise pattern_guesses |
| best_match | No | Highest-confidence candidate address |
| candidates | Yes | Candidate addresses, highest confidence first |
| confidence | No | Confidence of the best match, 0-100 |
| seen_at_company | No | Addresses already published at this domain |
| total_candidates | Yes | |
| detected_company_pattern | No | Address pattern used at this company, when known |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the readOnly and idempotent annotations, the description discloses that candidates are unverified pattern-based guesses, that finding is free while verification costs credits, and that the tool should not verify without user approval. This is substantial behavioral context that the agent would otherwise lack.
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 description is front-loaded with the core purpose, then efficiently covers return behavior, cost implications, and the required verification workflow. Every sentence delivers essential operational information without padding.
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 tool with two fully documented parameters and an output schema, the description covers purpose, result nature, cost, consent, and the exact follow-up action with verify_email. No critical operational detail is missing for an agent to call it correctly.
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?
The input schema already fully describes both parameters with examples, so the description's mention of full name and company domain adds limited new meaning. It reinforces the source fields but does not introduce additional parameter-level semantics beyond what the schema provides.
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 specific verb and resource: find a person's business email from full name and company domain. It clearly differentiates the tool from verify_email by describing find as generating pattern-based candidates rather than confirming deliverability.
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 provides explicit workflow guidance: show candidates, inform the user about credit costs, ask before verifying, then call verify_email one at a time by confidence until a deliverable result is found. This makes the tool's role relative to verify_email and the approval process unambiguous.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
verify_bulkVerify Email List (Bulk)AInspect
Verify a list of email addresses (2 to 10,000) as one bulk job using the full ClearBounce bulk pipeline — per-domain caching and greylist retries give better accuracy than verifying one by one. Costs 1 credit per unique address; duplicates are removed for free. Returns a jobId immediately (the job runs in the background, roughly 1-10 minutes depending on size). Use check_bulk_status with the jobId to get progress and the final summary. Before starting a large list, confirm with the user that spending that many credits is intended.
| Name | Required | Description | Default |
|---|---|---|---|
| emails | Yes | The email addresses to verify (2 to 10,000 items) |
Output Schema
| Name | Required | Description |
|---|---|---|
| note | No | |
| jobId | Yes | Use this with check_bulk_status |
| uniqueEmails | Yes | Addresses queued after duplicate removal — credits charged for these |
| estimatedSeconds | No | Rough time until the job completes |
| duplicatesRemoved | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond annotations, the description discloses that the job runs asynchronously in the background, takes roughly 1-10 minutes, costs 1 credit per unique address, deduplicates for free, and returns a jobId rather than immediate results. It also reveals a meaningful side effect (credit consumption) and the need for user confirmation, which annotations alone do not convey.
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 description is compact but information-dense. Purpose, accuracy benefit, cost model, async behavior, and follow-up action each appear in tight prose, and the most critical facts are front-loaded.
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 tool with one parameter and an output schema, the description covers everything needed to call it correctly: constraints, cost, async return, follow-up status polling, and user-confirmation guidance. It also distinguishes the tool from the sibling verify_email tool without needing further context.
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?
The schema already documents the emails parameter and its 2-to-10,000 item range at 100% coverage, so the baseline is 3. The description adds valuable semantics beyond the schema: duplicates are removed for free and cost is calculated per unique address, so an agent understands the real meaning of the list contents.
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 specific verb and resource: 'Verify a list of email addresses (2 to 10,000) as one bulk job.' It also differentiates from single-address verification by highlighting the bulk pipeline's per-domain caching and greylist retries, so an agent can see why this tool exists apart from verify_email.
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 explicitly explains when to choose bulk verification over one-by-one verification and names the follow-up tool, check_bulk_status, with the jobId. It also gives a clear behavioral instruction to confirm with the user before spending many credits, which is a strong usage guideline.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
verify_emailVerify Email AddressARead-onlyIdempotentInspect
Verify a single email address in real time with a live mailbox check. Returns status (deliverable, undeliverable, risky, unknown), a sub-status reason, a 0-100 quality score, and detailed checks (syntax, MX records, disposable, role-based, catch-all, typo detection). Costs 1 credit per call.
| Name | Required | Description | Default |
|---|---|---|---|
| Yes | The email address to verify, e.g. jane@example.com |
Output Schema
| Name | Required | Description |
|---|---|---|
| Yes | The address that was checked | |
| score | Yes | Quality score from 0 to 100 |
| checks | No | Detailed checks: syntax, MX, SMTP, disposable, role, catch-all, typo, risk |
| notice | No | Present only when the balance is low or empty: tells the user where to buy more credits |
| status | Yes | deliverable, undeliverable, risky or unknown |
| subStatus | No | Reason code behind the status |
| isDeliverable | Yes | |
| creditsRemaining | No | Credits left on the account after this check |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, and openWorldHint. The description adds meaningful behavioral context beyond annotations: real-time execution, live mailbox check, detailed result structure, and the 1-credit cost per call. No contradiction with annotations exists.
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?
Three sentences with no filler. The core action and key differentiator ('single email address') are front-loaded, followed by output details and cost. Every sentence earns its place.
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?
Given the single parameter, high schema coverage, comprehensive annotations, and presence of an output schema, the description covers all essential operational context: what it does, what it costs, and what it returns. Nothing critical is missing for an agent to invoke it correctly.
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 parameter is already well documented with an example. The description adds 'single' and 'live mailbox check' but does not meaningfully extend the semantic understanding of the email parameter beyond what the schema provides. 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?
The description uses a specific verb ('verify') with a clear resource ('a single email address') and states the mechanism ('live mailbox check'). The word 'single' explicitly differentiates it from the sibling tool verify_bulk, making its purpose unmistakable.
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 clearly implies the tool is for verifying a single email address in real time, which signals when to use it over verify_bulk or find_email. However, it does not explicitly mention alternatives or state when-not-to-use conditions, so it stops short of full routing guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Frequently Asked Questions
Claiming proves that you control a remote MCP connector. It does not move, proxy, or interrupt the server.
Open the connector listing, choose Claim ownership, and sign in to Glama.
Complete one verification method:
GitHub identity — fastest for official registry listings. For a namespace such as
io.github.alice/server, link the matching GitHub user or an account that owns the GitHub organization, then choose Claim with GitHub.HTTP challenge — works when you can deploy a public file. Generate a token, publish the exact JSON Glama shows at
/.well-known/glama.jsonon the same origin as the connector, then choose Check HTTP challenge.DNS challenge — works when you control DNS but cannot change the server. Generate a token, create the exact TXT record Glama shows, wait for it to propagate, then choose Check DNS challenge.
After verification, Glama sends a confirmation email and gives you access to listing details, thumbnails, health checks, and analytics. Keep the HTTP file or DNS record in place: Glama periodically checks it and ownership remains verified while the token is discoverable.
The HTTP ownership file has this structure:
{
"$schema": "https://glama.ai/mcp/schemas/connector.json",
"claim": "glama_claim_..."
}Claim tokens are opaque, stable, and bound to the signed-in Glama account. They contain no email address or other personal information. If Glama can no longer discover a verified HTTP or DNS token, it starts a seven-day grace period before removing claim-based access. Restore the same token during that period to keep ownership verified. Never publish an email address, Glama session token, GitHub token, or connector credential as ownership proof.
If verification fails, confirm that you copied the current token exactly. The HTTP file must be public, return valid JSON with a successful HTTP response, and stay on the connector's origin. DNS changes may need more time to propagate. A claim cannot transfer to a different origin or hostname: if the connector target changes, Glama starts the grace period and the new target must be claimed separately after the previous claim is released.
For a connector linked to the official MCP Registry, registry updates continue to replace its name, description, and URL by default. After claiming, open Manage connector and enable Use Glama listing details as the source of truth if edits made on Glama should be preserved. Categories and thumbnails are always managed on Glama; registry linkage and technical connection settings continue to sync.
Control your server's listing on Glama, including description and metadata
Access analytics and receive server usage reports
Get monitoring and health status updates for your server
Feature your server to boost visibility and reach more users
To improve your MCP server's ranking:
Claim ownership of the server listing
Complete the server profile with an accurate description and thumbnail
Provide a test profile so Glama can connect to and evaluate the server
Keep tool definitions clear and complete to earn a high Tool Definition Quality Score (TDQS)
Route real usage through the Glama Gateway; more recorded successful server uses also improve the ranking
For users:
Full audit trail – every tool call is logged with inputs and outputs for compliance and debugging
Granular tool control – enable or disable individual tools per connector to limit what your AI agents can do
Centralized credential management – store and rotate API keys and OAuth tokens in one place
Change alerts – get notified when a connector changes its schema, adds or removes tools, or updates tool definitions, so nothing breaks silently
For server owners:
Proven adoption – public usage metrics on your listing show real-world traction and build trust with prospective users
Tool-level analytics – see which tools are being used most, helping you prioritize development and documentation
Direct user feedback – users can report issues and suggest improvements through the listing, giving you a channel you would not have otherwise
The connector status is unhealthy when Glama is unable to successfully connect to the server. This can happen for several reasons:
The server is experiencing an outage
The URL of the server is wrong
Credentials required to access the server are missing or invalid
If you are the owner of this MCP connector and would like to make modifications to the listing, including providing test credentials for accessing the server, please contact support@glama.ai.
Discussions
No comments yet. Be the first to start the discussion!
Related MCP Connectors
Find verified work emails from a name, company, role or LinkedIn URL, and verify emails you have.
Verify emails — deliverability, disposable/role/free detection, MX validity, domain age.
Corporate identity finder and email verification. Map real addresses and users to real people.
Find verified B2B emails and phone numbers; search and enrich people and companies for prospecting.
Related MCP Servers
- AlicenseAqualityDmaintenanceFinds and verifies business email addresses using DNS/SMTP verification and web scraping, with no external API costs.5406MIT
- FlicenseNot gradedqualityBmaintenanceEnables AI agents to verify email addresses in real-time, checking syntax, DNS, MX records, and SMTP handshake, returning verdicts and deliverability scores without sending actual emails.
- FlicenseNot gradedqualityCmaintenanceProvides email verification as a tool, performing syntax validation, domain verification, and disposable-domain risk detection.
- AlicenseNot gradedqualityCmaintenanceB2B email finder and reverse-email lookup tool for finding professional email addresses via findymail.com.14MIT
Glama MCP Gateway
Add one secure layer between your agents and this server.
TDQS
Each tool has a clearly distinct responsibility: real-time single verification, background bulk verification, bulk job status polling, credit balance lookup, and email discovery. The overlap between verify_email and verify_bulk is resolved by descriptions of real-time vs async batch processing.
All tool names follow a consistent verb_noun pattern using lowercase snake_case: verify_email, verify_bulk, check_bulk_status, check_credits, find_email. The naming convention is uniform and predictable.
Five tools is well-scoped for an email verification service: single verification, bulk verification, status polling, credit tracking, and person email discovery. No redundant tools exist and each earns its place.
The set covers the core email verification lifecycle well, including single and bulk paths plus credit management. The only minor gap is that detailed bulk result files are accessible via the dashboard rather than the API, and there is no cancel/delete operation for bulk jobs.