ALT eSIM
Server Details
Search & buy travel data eSIMs for 70+ destinations — pay by Stripe link, get the eSIM QR. USD.
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP
- URL
Available Tools
5 toolscreate_checkoutAInspect
Create a secure Stripe payment link for an Alt eSIM plan. Returns a payment URL the BUYER opens to pay (the agent never handles card details) AND a checkout_session_id. After the buyer pays, call get_qr_code with that checkout_session_id to fetch the eSIM QR and show it to the buyer. The QR is also emailed. Charged in USD. You MUST collect the buyer's real email.
| Name | Required | Description | Default |
|---|---|---|---|
| lang | No | Delivery email language (default 'en'). | |
| Yes | Buyer's email — the eSIM QR code is also sent here. | ||
| sku_or_id | Yes | The plan sku or id to buy. | |
| customer_code | No | Optional Alt customer code (format Alt-XXXXXXXX, shown on the buyer's altesim.com account page). If provided, the order is linked to that account and appears in its order history regardless of the delivery email used. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It does well: states the agent never handles card details (security), the buyer opens the payment URL, the QR is emailed, and charges are in USD. It does not disclose potential side effects like charge failures or rate limits, but covers the key behaviors an agent needs to know.
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?
Every sentence in the description earns its place. It starts with the core action, explains return values, gives the follow-up step, and notes the mandatory email. No redundant or filler content. The structure is logical and flows well.
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?
The description is complete for a tool with no output schema: it explains return values, the post-payment flow, the email requirement, and the currency. It doesn't mention error handling or how to obtain the sku, but those are covered by sibling tools and the schema. Given the tool's complexity, this is adequate.
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 is 100%, so the schema already documents all parameters. The description adds some usage context (e.g., stressing the email must be real, mentioning currency), but it does not introduce new semantic meaning beyond the schema. The baseline of 3 is appropriate since the schema does the heavy lifting.
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 clearly states the tool's purpose: 'Create a secure Stripe payment link for an Alt eSIM plan.' It specifies the resource (eSIM plan), the action (create payment link), and the return values (payment URL and checkout_session_id). It also distinguishes itself from siblings by describing the follow-up with get_qr_code, which is a unique workflow.
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 when-to-use context: it's for creating a payment link when a buyer wants to purchase a plan. It gives a sequenced instruction ('After the buyer pays, call get_qr_code') and a mandatory requirement ('You MUST collect the buyer's real email'). It does not explicitly list alternatives or when-not-to-use, but the flow is clear enough for an agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_esim_planAInspect
Get one Alt eSIM plan by its sku or id. Returns full details: title, data amount, validity days, USD price, coverage carriers, product URL.
| Name | Required | Description | Default |
|---|---|---|---|
| sku_or_id | Yes | The plan sku (e.g. 'eSIM_Alt_JP_1DG1') or id. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose all behavioral traits. It states it returns 'full details' including specific fields, which is helpful. However, it does not mention if the operation is read-only, any authorization requirements, error conditions (e.g., invalid sku), or rate limits. The description is adequate but could be more transparent about side effects or limitations.
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 extremely concise—two sentences that front-load the purpose and then list returned details. Every sentence earns its place with no redundancy or filler.
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 a simple single-parameter tool, the description covers the purpose, the parameter usage (implicitly), and the return content. It does not have an output schema, so the description compensates by listing returned fields. However, it could be more complete by noting if the tool is read-only or what happens when the plan is not found, but the low complexity keeps this from being a major gap.
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 the single parameter 'sku_or_id' with its type and example. The description does not add further meaning to the parameter beyond what the schema provides, so a baseline of 3 is appropriate.
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 clearly states the verb 'Get' and the resource 'one Alt eSIM plan by its sku or id', and distinguishes it from sibling tools like 'search_esim_plans' (which lists/filters plans) by specifying a single plan lookup. It also lists the returned fields, adding precision.
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 implies this tool is for fetching a single plan when you already know the sku or id, contrasting with 'search_esim_plans' which searches over plans. However, it does not explicitly state when not to use it (e.g., to list all plans) or provide alternatives beyond the sibling list.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_qr_codeAInspect
Fetch the eSIM QR code(s) for an order, to show the buyer directly. Pass the checkout_session_id from create_checkout. Returns a clear status: 'awaiting_payment' (buyer has NOT paid — tell them to pay), 'processing' (paid, eSIM still provisioning — retry in ~30s), 'ready' (returns the QR image(s) + ICCID(s) to display), 'expired', 'refunded', or 'failed'. Use the status to tell the buyer exactly what's happening — never assume payment succeeded.
| Name | Required | Description | Default |
|---|---|---|---|
| checkout_session_id | Yes | The checkout_session_id from create_checkout (Stripe session id). |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, description fully discloses behavior: lists possible statuses ('awaiting_payment', 'processing', 'ready', 'expired', 'refunded', 'failed') and instructs agent to never assume payment succeeded. This is thorough for a simple tool.
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?
Description is concise, front-loaded with purpose, and each sentence adds meaningful information. No filler or redundancy.
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 tool has only one parameter and no output schema, the description effectively serves as the output schema by enumerating possible statuses and their implications. Covers all necessary guidance for correct invocation.
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%, but the description enhances the parameter by linking it to create_checkout, which adds workflow context. Without this, the parameter is self-explanatory, so baseline 3 + 1 for added value.
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?
Description clearly states 'Fetch the eSIM QR code(s) for an order' with a specific verb and resource. It distinguishes from siblings like create_checkout or get_esim_plan by focusing on QR retrieval linked to a checkout session.
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?
Explicitly says 'to show the buyer directly' and provides a prerequisite: 'Pass the checkout_session_id from create_checkout.' The status descriptions also guide the agent on how to interpret responses.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_destinationsAInspect
List all Alt eSIM destinations (country/region slugs with English names and region). Use a slug as the 'country' argument for search_esim_plans.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full behavioral burden. It effectively discloses that the tool has no parameters (empty input_schema), is a read-only informational listing, and produces slugs for a specific purpose. It does not describe the output format or any potential caching behavior, but the simplicity of the tool (0 params) makes this less critical.
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?
Two sentences, no wasted verbiage. The first sentence states the core function, the second provides critical usage guidance. Every word earns its place. Perfectly 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?
Given 0 parameters, no annotations, no output schema, and a simple listing function, the description is nearly complete. The only minor gap is not mentioning whether the list includes all possible destinations or if there are any prerequisites/caching. However, for a straightforward list tool, this is adequate.
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 has 0 parameters and 100% coverage, so the baseline is 4. The description adds value by explaining how the output (slugs) relates to sibling tool input, which is beyond what the empty schema provides. No need for param documentation since none exist.
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 clearly states the tool lists Alt eSIM destinations including country/region slugs, English names, and region. It distinguishes itself from siblings by explicitly mentioning the output includes slugs that are used as input for search_esim_plans. The verb 'list' is specific and the resource 'Alt eSIM destinations' is well-defined.
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 tells the agent when to use this tool (to find slugs for search_esim_plans), providing a direct connection to a sibling tool. It lacks explicit 'when not to use' guidance, but the context of usage is clear and actionable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_esim_plansAInspect
Search Alt eSIM travel data plans. Filter by destination country slug (e.g. 'japan', 'usa', 'europe'), region, and/or max USD price. Returns plans with sku, data amount, validity days, USD price and coverage carriers. All prices are USD.
| Name | Required | Description | Default |
|---|---|---|---|
| region | No | Optional region filter. | |
| country | No | Destination country/region slug, e.g. 'japan', 'south-korea', 'thailand', 'usa', 'europe'. Omit to list all. | |
| max_price_usd | No | Optional max price in USD. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full transparency burden. It discloses that the tool returns plans with specific fields (sku, data amount, validity days, USD price, coverage carriers) and notes that all prices are in USD. This is adequate for a read-oriented search tool, but it does not discuss rate limits, auth requirements, or potential side effects.
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 concise: three sentences, each serving a distinct purpose (purpose, filters, return fields). Information is front-loaded with the primary action. No unnecessary words or repetition.
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 tool has 3 optional parameters and no output schema, the description covers the essential aspects: what it searches, filters, and returns. It mentions the return fields and price currency. It could be more complete by noting ordering or pagination behavior, but it is sufficient for a simple search tool.
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 baseline is 3. The description adds value by providing concrete examples for the country slug ('japan', 'usa', 'europe') and stating 'Omit to list all', which clarifies behavior beyond the schema. The region enum is also hinted at, though the schema already defines 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 description clearly states 'Search Alt eSIM travel data plans' with a specific verb and resource. It lists filter options and return fields, making the purpose clear. However, it does not explicitly differentiate from sibling tools like 'list_destinations' or 'get_esim_plan', which would strengthen clarity.
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 context on what to filter by (country slug, region, max price) and gives examples ('japan', 'europe'). It implies usage for finding plans but does not give explicit guidance on when to use this tool versus alternatives, nor does it mention when not to use it.
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
Search travel eSIM plans for 150+ countries and buy via Stripe link; eSIM QR delivered by email.
Search travel eSIM data plans for 220+ destinations with live prices and purchase links.
Search, recommend & buy travel eSIM data plans for 190+ destinations via AI agents.
Buy and manage travel eSIM data plans in the conversation. Pay by card (Stripe) or USDC over x402.
Related MCP Servers
- AlicenseAqualityDmaintenanceTravel eSIMs for 193 countries. Stripe + Bitcoin checkout. QR by email in 30s. No API key.499MIT
- -licenseNot gradedqualityBmaintenanceLets AI agents search and buy travel eSIMs from ALT eSIM for 200+ destinations, with Stripe payment links and email delivery of QR codes.
- AlicenseNot gradedqualityCmaintenanceBrowse, compare, and purchase eSIMs for 190+ countries via AI agents. 12 tools for searching 2,300+ data plans, checking coverage, and buying eSIMs with crypto or card. No account required for browsing.MIT
- AlicenseNot gradedqualityBmaintenanceSearch and buy travel eSIMs for 200+ countries, with specialized China plans that deliver uncensored internet without a VPN. Exposes five read-only tools to search plans, check device eSIM compatibility, get plan details, get help, and generate a secure on-site checkout link.MIT
Glama MCP Gateway
Add one secure layer between your agents and this server.
TDQS
Each tool has a clear, distinct role: listing destinations, searching plans, getting one plan, creating a checkout, and fetching QR/status. The create_checkout and get_qr_code tools are related but the descriptions clearly separate payment creation from fulfillment status.
All tool names follow a consistent verb_noun snake_case pattern: create_checkout, get_esim_plan, get_qr_code, list_destinations, search_esim_plans. This makes the API predictable and easy for an agent to navigate.
Five tools is well-scoped for this server's purpose: discover destinations, search and inspect plans, create a payment checkout, and retrieve delivery/status information. Each tool earns its place with no redundancy.
The tool set covers the full eSIM purchase lifecycle: plan discovery, plan detail lookup, payment checkout creation, and QR code delivery with clear status handling. The get_qr_code status states cover waiting, processing, ready, expired, refunded, and failed, so agents can handle all outcome paths.