@giftcardshop/mcp
Click on "Install 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., "@@giftcardshop/mcplist the available gift card brands"
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.
@giftcardshop/mcp
MCP server that lets AI agents browse the giftcardshop catalog and buy gift cards with Lightning - no account, no signup. The agent pays a Lightning invoice and receives a single-view reveal link with the code.
Read tools work against the live public API with no key. create_order is
early access: it needs the shared GCS_INTERNAL_SECRET (request one at
https://giftcardshop.org/contact); without it the read tools still work and
create_order reports that it is not configured.
Tools
Tool | Kind | Backed by |
| read |
|
| read |
|
| read |
|
| read |
|
| write |
|
Read tools pass the API JSON through verbatim. create_order returns
{ orderId, invoiceId, invoiceUrl, bolt11?, sats?, total, currency, expiresAt }.
Related MCP server: Crossmint Checkout MCP Server
Run
# read-only (browsing works, create_order reports "not configured")
npx @giftcardshop/mcp
# with checkout enabled
GCS_INTERNAL_SECRET=<64-hex> npx @giftcardshop/mcpClaude Desktop / any MCP client (stdio):
{
"mcpServers": {
"giftcardshop": {
"command": "npx",
"args": ["-y", "@giftcardshop/mcp"],
"env": { "GCS_INTERNAL_SECRET": "<64-hex>" }
}
}
}Config
Env | Default | Purpose |
|
| public API base |
| (unset) | 64-hex HMAC secret; enables |
Checkout (create_order)
create_order POSTs to POST /internal/agent-orders, HMAC-signed with
GCS_INTERNAL_SECRET (header x-internal-sig), and returns a Lightning
invoice. Pay it, then poll get_order_status for the single-view reveal
link. No Nostr identity and no partner account required.
Roadmap
L402 (Lightning HTTP 402) so an agent pays per-call without a human step.
A hosted remote MCP over HTTP, so there is nothing to install.
A btcrecharge MCP for mobile top-ups (same shape).
Available Tools
5 toolscreate_orderCreate orderA
Create an order and get a Lightning invoice to pay. After payment, poll get_order_status for the reveal link. Needs the variantId from get_product.
| Name | Required | Description | Default |
|---|---|---|---|
| No | optional: also send the reveal link here | ||
| amount | Yes | face value as a decimal string, e.g. "50" | |
| currency | Yes | ISO 4217, e.g. EUR | |
| productId | Yes | ||
| variantId | Yes | ||
| idempotencyKey | Yes | unique key so a retry never double-charges |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Since no annotations are provided, the description must disclose behavior. It does reveal that it creates an order, returns an invoice, and that payment is required for the reveal link. However, it doesn't mention idempotency behavior, failure modes, authentication requirements, or the full return format. For a mutation tool with no annotations, more disclosure is expected.
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, each carrying information: the action, the follow-up step, and the dependency. No filler, front-loaded with the main purpose.
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 that creates an order and returns an invoice, the description covers the flow: create, pay, poll. It mentions the dependency and the next step. With no output schema, it indicates the primary return (invoice). It lacks details on error handling or idempotency, but the essential workflow is clear.
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 covers 67% of parameters with descriptions. The description adds meaning for variantId by pointing to get_product as its source, which is helpful. It doesn't explain productId or the relationship between amount and currency beyond schema. Overall, it adds some value but doesn't fully compensate for the missing parameter details.
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 action (create an order), the resource (order), and the outcome (get a Lightning invoice). It distinguishes itself from siblings by naming get_order_status as the next step and get_product as the source of variantId, making its role unique.
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?
It gives explicit guidance: use when you want to create an order and get an invoice, and it tells the agent to poll get_order_status after payment. It also specifies a prerequisite (variantId from get_product). It doesn't explicitly state when not to use, but the context is clear enough.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_order_statusGet order statusA
Check an order: payment state and whether the reveal link (the code) is available yet.
| Name | Required | Description | Default |
|---|---|---|---|
| orderId | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the behavioral burden. The verb 'Check' conveys a read-only operation, and the description specifies the observable outputs. It does not mention error behavior or side effects, but for a simple status query this is adequate.
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?
Single sentence, front-loaded with the action, with no wasted words. The parenthetical clarifies the reveal link without adding bulk.
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 read tool with no output schema, the description covers the essential return values (payment state, reveal link availability) and implies the input. It lacks explicit parameter guidance and edge-case behavior, but these are minor for this 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 0%, and the description does not mention the orderId parameter or its format/meaning beyond the schema's property name. Since the description must compensate for low schema coverage and does not, this is a clear gap.
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 ('Check') and resource ('order'), and clarifies exactly what is returned (payment state, reveal link availability). This clearly distinguishes it from sibling tools like create_order and get_product, which operate on different resources or actions.
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 clear context: use this when you need an order's payment status or reveal link availability. It does not explicitly name alternatives or exclusions, but the purpose is unambiguous relative to the sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_productGet productA
Get one product by id, including its denominations/variants (the variantId + amount needed for create_order).
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes | giftcardshop product id |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of behavioral disclosure. It discloses that the response includes denominations/variants and specifically surfaces the variantId + amount fields relevant to create_order, which is useful beyond the tool name. It doesn't mention errors or auth, but for a simple read-only lookup the key return characteristic is covered.
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?
A single sentence with no redundant words; it leads with the action and resource, then appends the key output detail in a parenthetical. Every element 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?
For a one-parameter tool with no output schema and no annotations, the description covers the essential lookup semantics and highlights the output fields that matter for a downstream create_order call. It stops short of full return-format or error details, but the minimal complexity means nothing critical is missing 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?
The input schema already fully documents the single id parameter with a description ('giftcardshop product id') and minLength, so schema coverage is 100%. The tool description only repeats 'by id' and adds no new semantic detail about the parameter, matching the baseline of 3.
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 uses the specific verb 'Get' with a clear resource ('one product') and lookup key ('by id'), immediately distinguishing it from list_brands and search_products. The added detail about denominations/variants further clarifies the exact resource shape.
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: use this to retrieve a single product by id, and the output supplies variantId and amount needed for create_order. It does not explicitly name sibling tools or state when to prefer search_products, but the direct-lookup framing makes the intended usage clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_brandsList brandsA
List gift-card brands in the giftcardshop catalog. Optionally filter by country and paginate.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| offset | No | ||
| country | No | ISO 3166-1 alpha-2 country code, e.g. US |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. The verb 'list' clearly indicates a read-only operation with no side effects. It does not mention rate limits or data modifications, but none are implied.
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 a single, concise sentence that covers the core functionality and optional parameters without unnecessary fluff. It is well-structured and easy to parse.
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 simplicity of the tool, the description provides sufficient context: it states what is listed, the optional filter, and pagination support. It does not specify the output format (e.g., fields returned), but since no output schema is provided, this is not strictly required for correct usage.
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 description explicitly mentions country filtering and pagination, giving context for the 'country', 'limit', and 'offset' parameters. However, the schema only provides a description for 'country'; 'limit' and 'offset' lack individual explanations, leaving some ambiguity about their exact semantics (e.g., default values).
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: listing gift-card brands from the catalog. It also mentions optional filtering and pagination, distinguishing it from sibling tools that focus on products and orders.
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 when to use this tool (when brand lists are needed) and explains optional parameters (country filter, pagination). It does not explicitly contrast with sibling tools, but the domain difference is clear from the context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_productsSearch productsB
Search/list purchasable products. Filter by free-text query, brand slug, country, or category.
| Name | Required | Description | Default |
|---|---|---|---|
| q | No | free-text search, e.g. "amazon" | |
| brand | No | brand slug | |
| limit | No | ||
| country | No | ||
| category | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It does not disclose whether this is a read-only operation, how results are ordered, pagination behavior, or any rate limits. The description only states what the tool does, not its behavioral nuances.
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 a single sentence that front-loads the purpose and lists filters without any wasted words. It is concise and structured for quick scanning.
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 no output schema and no annotations, the description fails to explain the return format (e.g., a list of product objects), pagination, or the semantics of the limit parameter. An agent calling this tool would not know what to expect in response or how to use limit effectively, making it incomplete for a 5-parameter 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 only 40% (q and brand have descriptions; limit, country, and category do not). The description lists the filter fields (q, brand, country, category) but omits limit entirely. It adds some context by clarifying these are filters, but does not explain formats like country code length or what category expects, leaving gaps for undocumented parameters.
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 ('Search/list') and resource ('purchasable products'), and lists the available filter dimensions. It doesn't explicitly differentiate from siblings like get_product or list_brands, but the purpose is unambiguous enough for an agent to recognize it as a search tool.
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 is for searching products, but provides no explicit guidance on when to use it versus alternatives (e.g., get_product for a single item, list_brands for brands). No when-not-to-use or alternative routing is given, leaving the decision to the agent's inference.
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. Dates show when Glama detected each change.
5 tool updates
v0.1.1- First observed
create_order - First observed
get_order_status - First observed
get_product - First observed
list_brands - First observed
search_products
TDQS
Scored across 5 tools
Each tool has a clear, distinct purpose: browsing brands, searching products, fetching product details, creating orders, and checking order status. No meaningful overlap or ambiguity.
All tool names follow a consistent verb_noun snake_case pattern (list_, search_, get_, create_), making the API intuitive and predictable.
Five tools cover the essential gift card shop workflow without unnecessary bloat or missing core operations. The count is well-scoped for the domain.
The toolset covers the full user journey: browse brands, search products, inspect product details/denominations, create an order, and poll order status. No obvious gaps for the stated purpose.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Verified merchants accepting agentic payments on Lightning/L402/BOLT12/USDT — search, verify, pay.
AI-agent product catalog: search, lookup & purchase routing over verified merchant data.
Directory of APIs, merchants, and tools AI agents can actually use.
Product search for AI agents: Amazon + Shopify, cart-to-checkout buy path. Pay-per-call, no API key.
Related MCP Servers
- AlicenseBqualityFmaintenanceEnables interaction with lightning addresses and common lightning tools via your LLM, providing Lightning Network functionality through natural language.3121MIT
- FlicenseNot gradedqualityDmaintenanceEnables AI agents to programmatically purchase physical and virtual goods from platforms like Amazon and Shopify using stablecoins, without the need for virtual debit cards or browser automation.1-
- FlicenseNot gradedqualityCmaintenanceBuy video game keys, gift cards, and digital subscriptions via x402 USDC payments on Base. 8 tools covering catalog search, price quotes, on-chain purchase confirmation, delivery status, and refunds.-
- AlicenseAqualityDmaintenanceEnables AI assistants to search for and purchase gift cards, mobile topups, and digital products via Bitrefill, with tools for managing invoices, orders, and account balance.12272MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/i2dor/giftcardshop-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server