accessoticketing-mcp
Provides Google Wallet save links for tickets on an accesso Passport order, allowing them to be added to Google Wallet.
Click 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., "@accessoticketing-mcpShow me my order details from the ticket link."
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.
accessoticketing-mcp
An MCP server for accesso Passport mobile ticket links — the URL a venue emails you after a purchase. Reads the order and every admission on it, the scannable barcodes, and Google Wallet save links.
accesso powers ticketing for a lot of theme parks, water parks, camps, museums and festivals, so one server covers all of them: the merchant is encoded in the link.
Developed and maintained by AI (Claude Code). Use at your own discretion.
What it needs
No login. These links carry their own credential — the oToken in the query
string is what authorises the read. There is no account, no password, no browser
session, and no bot wall.
That also meansthe link is a secret. Anyone holding it can view and add the order's tickets. Treat it like a password: don't paste it into issues, logs or chats. This server redacts the tokens from its own output and error messages.
Related MCP server: tokenless-zendesk-mcp
Install
npx -y @chrischall/accessoticketing-mcp// claude_desktop_config.json / .mcp.json
{
"mcpServers": {
"accessoticketing": {
"command": "npx",
"args": ["-y", "@chrischall/accessoticketing-mcp"],
"env": { "ACCESSO_TICKET_URL": "https://media-engine.na3.accessoticketing.com/tickets/v1/..." }
}
}
}ACCESSO_TICKET_URL is optional — it just saves passing url on every call. The
server starts fine without it and reports the missing link on first use.
Variable | Required | Purpose |
| no | Default ticket link, used when a tool is called without |
| no | Where |
| no | Set to |
Tools
Tool | Does |
| The order and every admission: product, participant, date, start time, instructions. Returns the slim per-ticket list by default; |
| One admission in full, by |
| Writes barcode PNGs and returns paths, or returns the images inline. |
| Google Wallet save links for the tickets. |
| Unwraps an email click-tracking link to the accesso URL it hides. |
| Confirms reachability and whether a default link is configured. |
Every tool is read-only; nothing here mutates an order.
> what do we have booked tomorrow?
9:00 AM Tiny Trekkers Full-Day (Ages 4-7) — one participant
9:00 AM Whitewater Kayak Camp I: Intro — two participants
all-day Lunch / Snack / Early Drop-Off — nine more admissionsShell-out skill
Prefer a shell? skills/accesso-tickets/ does the same reading with curl and a
dependency-free parser, no server required. It ships with the package.
Notes on the data
date/timeare the merchant's local wall-clock strings with no timezone attached. They are passed through verbatim rather than converted.Merchant-specific detail rows (
Guest Number,Web Sales ID, …) are harvested generically intodetails, so a venue this was never tested against still works.An expired link returns HTTP 200, not an error status — the server detects the body and says the link is expired rather than reporting zero tickets.
Development
npm install
npm run build
npm test
npm run test:coverage # 100% thresholds, enforced in CISee docs/ACCESSO-API.md for the captured request/response shapes and CLAUDE.md
for repo conventions.
License
MIT
Available Tools
6 toolsaccesso_get_orderARead-only
Read an accesso ticket link: the order number and every admission on it — product, participant, date, start time, barcode text, and the merchant instructions. Covers any accesso-powered venue (theme parks, camps, festivals). Needs no login; the emailed link is the credential.
| Name | Required | Description | Default |
|---|---|---|---|
| url | No | The accesso ticket link from the order-confirmation email. Optional when ACCESSO_TICKET_URL is set. | |
| view | No | Response shape: "compact" (default) drops fields the response already carries elsewhere; "full" returns every field this server understands. compact returns the slim per-ticket projection — identity, participant, date, time; "full" returns every field parsed from the order page. | |
| include_terms | No | Include each ticket's terms and conditions (long, and identical per venue). |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark this as read-only and open-world, and the description adds meaningful behavioral context: no authentication is needed and the emailed link acts as the credential. It also clarifies that the tool can parse links from multiple venue types, which goes 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?
Two tightly packed sentences deliver the core behavior, output scope, venue coverage, and authentication requirement with no wasted words. The most important action is front-loaded, and every clause adds useful information.
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 absence of an output schema, the description compensates by enumerating the returned fields. It also covers authentication, venue scope, and the input source. An agent has enough information to invoke the tool correctly and interpret the result.
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 of 3 applies; all three parameters (url, view, include_terms) are already well documented in the schema. The description does not add parameter-level detail, but it does not need to because the schema covers the semantics fully.
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 'Read' and names the exact resource: an accesso ticket link and its order-level contents. Listing 'every admission' with product, participant, date, time, barcode text, and merchant instructions clearly distinguishes it from a per-ticket sibling such as accesso_get_ticket.
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 usage context: it works for any accesso-powered venue and requires no login because the emailed link itself is the credential. It does not explicitly name alternatives or state when not to use this tool, but the intended scenario is unambiguous.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
accesso_get_ticketARead-only
One admission from an accesso order in full detail, including the merchant instructions and (on request) the terms. Identify it by its index from accesso_get_order.
| Name | Required | Description | Default |
|---|---|---|---|
| url | No | The accesso ticket link from the order-confirmation email. Optional when ACCESSO_TICKET_URL is set. | |
| index | Yes | Ticket index, from accesso_get_order. | |
| include_terms | No | Include the terms and conditions. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With readOnlyHint=true and openWorldHint=true already covering the safety profile, the description adds meaningful behavioral detail: the response includes merchant instructions and optionally terms. This goes beyond what the annotations alone state and helps set expectations.
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 two concise sentences with no filler. It front-loads the core purpose and immediately explains the identifying mechanism, making it easy for an agent 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?
For a simple read-only tool with one required parameter and full schema coverage, the description plus annotations are sufficient. It explains what is returned, how to identify the ticket, and that terms are opt-in, so an agent has enough context to call 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 description coverage is 100%, so the parameters are already documented in the schema. The description restates that the index comes from accesso_get_order, which is already in the schema's index description, adding no new semantic information.
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 identifies the tool as returning a single admission from an accesso order in full detail, distinguishing it from the order-level tool by requiring the index from accesso_get_order. The resource and purpose are specific and 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 clear context: use this tool to get one admission from an order, identified by index obtained from accesso_get_order. It implicitly establishes a workflow but does not explicitly state when to prefer it over sibling tools like accesso_get_wallet_passes or accesso_resolve_link.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
accesso_get_wallet_passesARead-only
Google Wallet save links for the tickets on an accesso order. Open one on a phone to add that ticket to Google Wallet. Not every merchant enables passes.
| Name | Required | Description | Default |
|---|---|---|---|
| url | No | The accesso ticket link from the order-confirmation email. Optional when ACCESSO_TICKET_URL is set. | |
| indexes | No | Ticket `index` values to act on. Omit for every ticket on the order. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint and openWorldHint, so the safety profile is covered. The description adds the useful caveat that not every merchant enables passes, but does not describe the output format or behavior when passes are unavailable. This is acceptable but not richly transparent.
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 short sentences with no wasted words. The core purpose is first, followed by a practical usage note and a caveat. 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?
For a simple read-only tool with two optional parameters, the description covers the main purpose, the output type (save links), and a key limitation. It does not detail the exact response structure, but the absence of an output schema makes the description reasonably complete.
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 description does not need to re-explain parameters. It adds no extra semantics beyond what the schema already provides, which matches the baseline expectation.
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 identifies the tool's output: Google Wallet save links for tickets on an accesso order. It is specific enough to distinguish from siblings like accesso_get_order and accesso_save_barcodes, though it uses a noun phrase rather than an explicit verb like 'retrieves' or 'returns'.
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 usage context: these links are meant to be opened on a phone to add a ticket to Google Wallet. It also notes that not every merchant enables passes, warning about a potential limitation. It does not name alternative tools explicitly, but the context is sufficient for an agent to understand when it applies.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
accesso_healthcheckARead-only
Check that this server can reach accesso and whether a default ticket link is configured.
| Name | Required | Description | Default |
|---|---|---|---|
| url | No | The accesso ticket link from the order-confirmation email. Optional when ACCESSO_TICKET_URL is set. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnlyHint and openWorldHint, covering the safety profile. The description adds detail about checking connectivity and default link configuration, but does not disclose output format, error behavior, or what happens when ACCESSO_TICKET_URL is unset. No contradiction 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?
A single, front-loaded sentence states the tool's purpose without redundancy or fluff. Every word contributes to understanding what the tool does.
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 simple diagnostic tool with one optional parameter and no output schema, the description is mostly sufficient. It could clarify the return value or the behavior when no URL and no default link are present, but these are minor gaps given the tool's simplicity.
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 only parameter, url, is fully described in the schema, including its source and optionality. The description does not add additional parameter semantics beyond what the schema already 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 uses a specific verb ('Check') and names the exact resources: server reachability to accesso and default ticket link configuration. It clearly distinguishes this healthcheck tool from the data-access and mutation sibling tools.
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 a diagnostic use case but does not explicitly state when to call this tool versus alternatives, or when not to use it. The healthcheck name and sibling context make the intended use reasonably clear, but the guidance is not explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
accesso_resolve_linkARead-only
Turn an order-confirmation email's click-tracking link into the direct accesso ticket URL it wraps. Use when a link is not already an accessoticketing.com address.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | The tracking link from the email. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover read-only behavior, and the description adds that the tool unwraps the tracking URL into the wrapped accesso URL. This transformation detail goes beyond the annotations and clarifies what the operation does. It does not discuss failure modes, but for a simple one-parameter read-only resolver this is sufficient.
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 carry the full operational and usage context without any filler. The main action is front-loaded, and the usage condition is stated immediately after, making the description efficient and well-structured.
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 no output schema, the description provides enough context: what the input is, when to use it, and what the result will be (the direct accesso ticket URL). Minor missing details like invalid-link handling are not critical given the tool's simplicity.
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's parameter description is already informative, and the tool description adds further meaning by specifying that the URL must be a 'click-tracking link' and should not already be an accessoticketing.com address. This extra constraint helps the agent pass a valid input.
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 operation—'resolve' a click-tracking link into the 'direct accesso ticket URL'—with a clear resource and result. It also distinguishes the tool from siblings by specifying the input type, so an agent can select it 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?
It gives an explicit usage condition: 'Use when a link is not already an accessoticketing.com address.' This tells the agent when the tool applies and, conversely, when it should not be used, providing a clear decision rule.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
accesso_save_barcodesARead-only
Save the scannable barcode images from an accesso order. Writes PNGs and returns their paths; set inline to receive the images directly instead (which is the only useful mode when this server runs remotely, since its filesystem is not the user's).
| Name | Required | Description | Default |
|---|---|---|---|
| url | No | The accesso ticket link from the order-confirmation email. Optional when ACCESSO_TICKET_URL is set. | |
| inline | No | Return the images in the response instead of writing files. | |
| indexes | No | Ticket `index` values to act on. Omit for every ticket on the order. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations declare readOnlyHint=true, but the description says the tool 'Writes PNGs' and writes to a filesystem, which is a side-effecting behavior. This directly contradicts the read-only annotation. The description is transparent about writing files, but the contradiction with the annotation is a serious inconsistency.
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 efficient: it states the action, the default behavior, the alternative mode, and the key caveat in two sentences. There is no filler and the most important information is 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?
Despite having no output schema, the description explains what the tool returns in both modes ('paths' vs. 'the images directly'). It also covers the remote-server caveat and references the URL source, making it complete enough for an agent to invoke 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 is 100%, so the schema already documents all three parameters. The description adds meaningful extra context about the inline mode being the only useful mode on remote servers, going slightly beyond the schema's parameter descriptions.
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 ('Save the scannable barcode images'), the resource ('from an accesso order'), and the output ('Writes PNGs and returns their paths'). It is specific enough to distinguish this from sibling tools that merely get orders or tickets.
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 for choosing between default file-writing and inline mode, including the strong practical caveat that inline is the only useful mode on a remote server. It does not explicitly name sibling alternatives or say when not to use this tool, but the operational guidance is clear.
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.
6 tool updates
v0.3.0- Changed
accesso_get_order1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
accesso_get_ticket1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
accesso_get_wallet_passes1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
accesso_healthcheck1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
accesso_resolve_link1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
accesso_save_barcodes1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
6 tool updates
v0.2.0- First observed
accesso_get_order - First observed
accesso_get_ticket - First observed
accesso_get_wallet_passes - First observed
accesso_healthcheck - First observed
accesso_resolve_link - First observed
accesso_save_barcodes
TDQS
Scored across 6 tools
Each tool targets a unique function: order retrieval, single ticket lookup, barcode saving, wallet passes, link resolution, and healthcheck. No overlapping purposes, so an agent can cleanly select the right tool.
All tools share the accesso_ prefix and follow a clear verb_noun pattern (get_order, get_ticket, save_barcodes, get_wallet_passes, resolve_link). The one exception, healthcheck, is a standard compound noun and does not break the overall consistency.
Six tools is well-scoped for a specialized ticketing integration. Each tool covers a distinct need without redundancy or bloat, and the count fits the narrow domain perfectly.
For a read-only accesso ticket-linking server, the surface is complete: fetch order, fetch ticket, save barcodes, generate wallet passes, resolve tracking URLs, and verify connectivity. No obvious dead ends or missing workflows.
Maintenance
Related MCP Connectors
An MCP server that provides read access to your cloud storage providers, bank accounts and more.
2,000+ MCP servers read at source level. Know what one does before you connect. Free, no key.
A paid remote MCP for hosted MCP server, built to return verdicts, receipts, usage logs, and audit-r
Remote MCP server for managing Muninx tickets, messages, ticket search, and support analytics.
Related MCP Servers
- AlicenseAqualityAmaintenanceAn MCP server that provides read-only access to MySQL databases.4362 npm72MIT
- AlicenseAqualityDmaintenanceMCP server that authenticates via browser session cookies to access Zendesk's REST API without API tokens, supporting reads and writes with agent permissions.196 npm1MIT
- AlicenseAqualityDmaintenanceRead-only MCP server for the HIT ticket management system that lists queues, searches/fetches ticket details, and lists ticket templates.44 npm1MIT
- AlicenseAqualityBmaintenanceRead-only MCP server for Edenred Plus that enables checking benefit balances, transactions, and deals via local browser authentication.5MIT