This server is a read-only MCP bridge to AwardMath that plans award travel from your points balances without needing an API key.
list_programs: Lists every tracked rewards program and identifies which program IDs can be used in a solve today.
parse_wallet: Converts free-text balances like "250k Amex, 80k Chase" into structured wallet entries, surfacing ambiguous phrases for clarification.
solve_award_trip: Computes up to three verified, explainable booking plans from your wallet, origins, destinations, cabin, traveler count, and cash cap.
Plans include exact transfer steps, total points required, and priced fees; if no plan fits, it returns no_plan_reasons explaining the failing constraint.
The server does not check live seat availability, so users must confirm award space and transfer terms before moving points.
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., "@awardmath-mcp Find an economy award from LAX to HNL with 60k Amex points"
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.
awardmath-mcp connects AI assistants to the public AwardMath API through the Model Context Protocol.
AwardMath is the travel points optimizer. You provide your points balances and a travel goal. A deterministic solver searches a versioned graph of transfer ratios and award charts, then returns up to three verified, explainable booking plans.
The math is enumeration and scoring over published charts. An LLM can parse your question and explain the results, but it never chooses or optimizes the plans.
This repository contains the MCP server and a free data snapshot under data/. The server is read-only. It requires no API key, login, or subscription, and it does not scrape airline sites.
The server exposes three tools.
Tool | What it does |
| Lists tracked and spendable programs |
| Returns up to three plans |
| Structures wallet text |
list_programslist_programs returns every program AwardMath tracks and identifies which program IDs a solve can spend today.
Spendable programs include award programs with priced charts and bank currencies that transfer into one of those programs. This distinction prevents an assistant from asking the solver to spend a balance that has no path to a priced award.
solve_award_tripsolve_award_trip searches for plans that fit your wallet, origins, destinations, cabins, traveler count, and cash cap.
A successful response contains up to three plans with:
Exact transfer steps
Total points required
Priced fees
If no plan fits, the response includes no_plan_reasons. These identify the constraint that failed instead of filling the gap with a guessed route or price.
parse_walletparse_wallet turns free text into structured balances.
For example:
250k Amex, 80k ChaseClear balances become program IDs and amounts. Ambiguous phrases are surfaced for clarification rather than assigned to a program by guesswork.
Related MCP server: trip-planner-mcp
You can run the server directly from GitHub or install it from a clone.
claude mcp add awardmath -- uvx --from git+https://github.com/DanCastHub/awardmath-mcp awardmath-mcp{
"mcpServers": {
"awardmath": {
"command": "uvx",
"args": ["--from", "git+https://github.com/DanCastHub/awardmath-mcp", "awardmath-mcp"]
}
}
}pip install -e .
awardmath-mcpNo API key or AwardMath account is required.
Ask your assistant for a priced plan using the balances you already have.
You: I have 60,000 Amex Membership Rewards points. Find one economy seat from LAX to HNL.
Assistant: As of 2026-08-27, the best-priced plan used 12,500 Aeroplan points for the seat on a partner award, funded through an Amex transfer at 1:1. The result includes the exact transfer steps, total points, and fees. It does not confirm that a seat is available.
That result is dated because transfer ratios and award prices change. Run a new solve, confirm the award seat, and re-check the transfer terms before moving points.
The data/ directory provides a dated slice of the rewards graph and worked solver output.
data/transfer-ratios-current.csvThis file contains 109 bank-to-program transfer edges from eight source currencies, as observed on 2026-08-23.
Each row represents the most recent observation AwardMath had verified against a program page or corroborated across independent sources. Editorial claims that had not been verified were excluded.
Columns include:
Transfer ratio
Fees
Transfer time, where observed
Verification status
Date observed
Ratios change. Treat every row as valid only as of its observed date, then re-check the program before transferring points.
data/sample-solved-plans.jsonThis file contains six scenarios run through the live solver on 2026-08-27.
Five scenarios produced plans. They include:
LAX to HNL in economy with 60,000 Amex Membership Rewards points
SFO to HND in business with 100,000 Amex Membership Rewards points, priced through ANA at 55,000 points
YVR to DXB in business with 350,000 Aeroplan points, priced at 90,000 points on a partner award
One scenario is deliberately empty. The DFW to CUN economy search shows how the solver responds when the graph cannot price a route. It names the missing graph coverage instead of inventing a plan.
The dataset is a snapshot, not the full AwardMath product.
The versioned history behind it stays at awardmath.com. That history tracks ratios and charts over time and supports price-history and book-now-or-wait calls. It is not included in this repository.
The server does not check live award-seat availability.
Plans are priced from published award charts and transfer relationships. A route can be mathematically valid while having no seats available on your dates.
Before you move any points:
Confirm the award space through Seats.aero, PointsYeah, or the airline.
Check the points price and cash charges with the booking program.
Re-check the transfer ratio and terms.
Transfers are irreversible. Do not transfer because the solver found a priced path. Transfer only after you have confirmed that the seat can be booked.
AwardMath verifies the math. You confirm the seat.
The code is licensed under the MIT License.
The files under data/ are licensed under CC BY 4.0. Use this attribution with a link:
Data: AwardMath
Sources:
List every rewards program AwardMath tracks.
Returns {"names": {program_id: display name}, "plannable": [program_id]}. "plannable" ids are the ones a solve can spend today: award programs with priced charts, plus bank currencies that transfer into one. Use these ids in solve_award_trip wallets.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Since no annotations are provided, the description carries the full burden of behavioral disclosure. It precisely outlines the return structure (an object with 'names' and 'plannable' fields) and elaborates on the meaning of 'plannable' (award programs with priced charts plus bank currencies that transfer into one). This gives the agent solid insight into what the tool returns and on what basis, well beyond a generic 'list' statement.
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 three concise sentences: the first states the purpose, the second defines the return shape, and the third explains the 'plannable' field and its intended use. Every sentence contributes meaningful information with no redundancy or padding, making it efficiently 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 that the tool has no parameters and no output schema, the description is exceptionally complete. It fully defines the return object, explains the semantics of each field, and explicitly ties the output to the sibling tool solve_award_trip. There are no critical gaps that would prevent an agent from correctly invoking the tool and interpreting its results.
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 tool has zero parameters and the input schema is empty, so the description has no parameter semantics to add. Per the rubric, a tool with zero parameters gets a baseline of 4. The description appropriately focuses on output and usage rather than parameters, so the score reflects this baseline.
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 begins with 'List every rewards program AwardMath tracks,' which is a clear verb and resource definition. It does not explicitly differentiate from sibling tools like parse_wallet or solve_award_trip, but the listing nature is unmistakable given the name and the different purposes of those siblings. Thus it is specific but lacks explicit sibling distinction.
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 goes beyond just stating what it does by explaining when to use the output: 'Use these ids in solve_award_trip wallets.' This directly connects the tool to a sibling and prescribes how the returned 'plannable' ids should be consumed. It also clarifies which programs qualify as 'plannable,' giving the agent a clear decision rule for usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Turn free text about points balances into structured wallet entries.
Example input: "I have 250k Amex MR, 80k Chase, and my wife has 60k Alaska". Returns {"balances": [{owner, program, balance, expires}], "unrecognized": [...], "needs_clarification": [...]}. Anything ambiguous lands in the latter two lists instead of being guessed — show it to the user rather than dropping it. If you already know the balances in structured form, skip this and build the wallet directly.
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure, and it delivers: it spells out the return shape (balances, unrecognized, needs_clarification), and crucially states the no-guessing policy — 'Anything ambiguous lands in the latter two lists instead of being guessed — show it to the user rather than dropping it.' This is a meaningful behavioral trait. It stops short of edge-case handling (e.g., empty text), keeping it from a 5.
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 purpose, followed by a compact example, the return schema, and the behavioral contract. Each sentence earns its place. It runs slightly long due to the dual example-and-schema-format block, but nothing is redundant.
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 parse tool with no output schema, the description is nearly complete: it states the input, enumerates the three output lists, and defines the ambiguity contract. The absence of an output schema means the description must explain return values, which it does. Minor omission: it doesn't state a reasonable fallback for degenerate input, but the tool's complexity doesn't demand it.
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% for the single required parameter, so the description must compensate. The example input ('I have 250k Amex MR, 80k Chase...') conveys the expected free-text format with program names and amounts, which is the main semantic need. However, the description never explicitly defines the parameter's contract beyond the example — it leaves the agent to infer that text is a raw user message about point balances.
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 opening line 'Turn free text about points balances into structured wallet entries' uses a specific verb (turn/parse), a defined resource (free text about points balances), and a concrete outcome (structured wallet entries). It clearly differentiates from siblings list_programs and solve_award_trip, which serve materially different purposes.
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 an explicit when-not-to-use condition: 'If you already know the balances in structured form, skip this and build the wallet directly.' This tells an agent precisely when the tool is unnecessary. It implies when to use it (when balances exist only as free text) via the example, though it doesn't formally exclude siblings — acceptable since the siblings are not genuine alternatives to a text-parsing operation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Compute up to three verified award-booking plans for a trip.
wallet: [{"owner": "me", "program": "amex-mr", "balance": 250000}] — ids from list_programs; "expires" (ISO date) optional per entry. origins / destinations: IATA airport codes, e.g. ["LAX"] -> ["HNL"]. cabins: any of "economy", "premium", "business", "first" (default economy). max_cash_usd: cap on out-of-pocket cash (fees, points purchases). window_from / window_to: ISO dates, optional.
Returns plans with exact transfer steps, points math, and fees, plus no_plan_reasons when nothing works — an empty result explains itself. Plans price the award from published charts; they never assert live seat availability, so tell the user to confirm space before transferring anything irreversible.
| Name | Required | Description | Default |
|---|---|---|---|
| cabins | No | ||
| wallet | Yes | ||
| origins | Yes | ||
| travelers | No | ||
| window_to | No | ||
| window_from | No | ||
| destinations | Yes | ||
| max_cash_usd | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full responsibility. It explicitly states plans are priced from published charts and never assert live seat availability, and that empty results include no_plan_reasons. This is a strong disclosure of key behavioral limitations and return expectations, though it doesn't cover every potential edge case.
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 purpose is front-loaded, followed by a systematic per-parameter breakdown and behavioral caveats. The text is longer than average but every sentence adds value; there is no fluff or redundant wording.
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 8 parameters, no annotations, and no output schema, the description covers purpose, inputs, high-level output (plans with transfer steps, points math, fees, no_plan_reasons), and a critical limitation (no live availability). It does not describe the exact output structure, but the summary is sufficient for an agent to call and interpret results.
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 0%, so the description must compensate. It explains wallet with an example, origins/destinations with IATA codes, cabins with options and default, max_cash_usd as a cap, and window dates as ISO optional. It covers 7 of 8 parameters but omits 'travelers', leaving its meaning to inference—a minor but notable 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?
The description opens with a specific verb-resource pair ('Compute up to three verified award-booking plans for a trip') and the context clearly distinguishes it from siblings list_programs and parse_wallet. The 'verified' and 'up to three' qualifiers add specificity without ambiguity.
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 for when to use the tool: after obtaining wallet IDs from list_programs, and it instructs the agent to confirm live availability before irreversible transfers. It does not explicitly name alternatives or exclusions, but the sibling relationships are implicit, so this is adequate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.1.0list_programsparse_walletsolve_award_tripScored across 3 tools
Each tool has a clearly distinct purpose: list_programs enumerates available programs, parse_wallet converts free text into structured wallet entries, and solve_award_trip computes booking plans. There is zero overlap between them, so an agent can easily select the right tool for each step of the workflow.
All three tool names follow a consistent verb_noun pattern: list_programs, parse_wallet, solve_award_trip. The verbs are clear and the nouns match the domain, making the naming predictable and intuitive.
Three tools is well-scoped for the server's purpose: listing programs, parsing input, and solving trips. Each tool is necessary and sufficient for the end-to-end workflow, with no redundancy or missing helper clutter.
The tools cover the full lifecycle: discovering what programs exist, structuring user input, and computing booking plans with transfer steps. A minor gap is the lack of a dedicated tool for fetching detailed program rules or live availability, but the solve tool's output includes sufficient details and reasons for failures, so most practical needs are met.
Search award flights and cash fares, optimize points, and predict fares inside ChatGPT and Claude.
Personal AI travel agent. Points optimization, live flight/hotel/award search, trip planning.
Give AI assistants access to real-time data. Search the web, compare flights, find hotels, and more.
Read and update your Everway trips and itineraries from any MCP-compatible AI assistant.
