RiseUp MCP Server
OfficialThe RiseUp MCP server provides programmatic, read-only access to your RiseUp cashflow and budget data, enabling AI assistants to answer questions about your finances.
Get Budget (get_budget): Retrieve your budget for a specific month (YYYY-MM, current, or previous), including:
Envelope (category) breakdown with planned vs. actual spending
Envelope types: fixed expenses, variable expenses, tracked categories, variable income, and savings goals
Individual transactions per envelope with merchant name, date, billing amount, installment info, and account nickname
Excluded (one-off) transactions marked outside regular cashflow
Get Transactions (get_transactions): Retrieve individual cashflow transactions filtered by:
Cashflow month (
YYYY-MM), exact transaction date (YYYY-MM-DD), or merchant/business name (case-insensitive substring match)Filters combine with AND; at least one date-based filter is required
Each transaction includes merchant name, amount (ILS), income/expense flag, installment details, account nickname, category label, and category type
Key Constraints:
Read-only: No write or modification operations are supported
Authentication required: A RiseUp Personal Access Token (PAT) with
budget:readscope must be configuredCurrency: All monetary values are in Israeli Shekels (ILS)
AI Integration: Designed for use with MCP clients like Claude Desktop and Claude Agent SDK
Provides programmatic read-only access to your own cashflow data from RiseUp, allowing you to query budgets for specific months.
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., "@RiseUp MCP ServerWhat's my budget for this month?"
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.
@riseup-oss/mcp
Official MCP server for RiseUp — programmatic read-only access to your own cashflow data from Claude Desktop, Base44, the Claude Agent SDK, and other MCP clients.
Status: v0.1. The package returns real data via the RiseUp API.
What you can do with it
Once installed and configured, ask your AI assistant questions like:
"What's my RiseUp budget for this month?"
"Show me my budget for May 2026."
"Compare my budget to last month."
The assistant calls the get_budget tool, which fetches your real cashflow data through RiseUp's Exposed API using a Personal Access Token (PAT) you created.
Related MCP server: actual-mcp-server
Installation
npm install -g @riseup-oss/mcpRequires Node.js 18+.
Setup
1. Create a Personal Access Token
Visit RiseUp's developer tokens page, create a token, pick the budget:read scope, and copy it. It is shown only once.
The token looks like riseup_pat_<32-bytes-base64url>.
2. Configure your MCP client
Claude Desktop
Add to your claude_desktop_config.json (on macOS: ~/Library/Application Support/Claude/claude_desktop_config.json):
{
"mcpServers": {
"riseup": {
"command": "npx",
"args": ["-y", "@riseup-oss/mcp"],
"env": {
"RISEUP_PAT": "riseup_pat_paste_your_token_here"
}
}
}
}Fully quit Claude Desktop (Cmd+Q on macOS) and reopen — closing the window isn't enough. Claude Desktop reads claude_desktop_config.json only at startup, so any change to RISEUP_PAT or other env values needs a full restart to take effect. After restart, the get_budget tool should appear.
Claude Agent SDK
import { Claude } from '@anthropic-ai/claude-agent-sdk';
const claude = new Claude({
mcpServers: {
riseup: {
command: 'npx',
args: ['-y', '@riseup-oss/mcp'],
env: { RISEUP_PAT: process.env.RISEUP_PAT },
},
},
});Environment variables
Variable | Required | Default | Description |
| yes | — | Your |
| no |
| Override for staging / dev environments |
Tools (v0.2)
Tool | Scope | Description |
|
| Get the customer's budget for a given month. Accepts |
|
| Get individual cashflow transactions filtered by |
More tools (get_balances, get_cashflow) coming in future releases.
Documentation
Longer-form docs live in docs/:
Quickstart — first API call in five minutes
Authentication — token format, headers, revocation, the
X-Riseup-Token-Refcorrelation headerRate limits — limits, the
429shape, how to handle itErrors — the full error catalog
Budget reference — the three budget endpoints in detail
Security
The PAT lives only in your local MCP client config — it is never sent to Anthropic or any third party. The MCP server runs on your machine; it only communicates with the RiseUp API and your local MCP client.
The token is read-only. It cannot make changes to your account.
Tokens expire after 30 days by default. Revoke a token any time at
/developer/tokens.Never share your token, paste it into a chat, or commit it to source control.
Development
git clone git@github.com:riseup-oss/mcp.git
cd mcp
npm install
npm run build
npm testLocal smoke tests
examples/smoke-test.mjs drives the built MCP server as a real MCP client (same @modelcontextprotocol/sdk stdio transport Claude Desktop uses), calls get_budget, and prints PII-safe shape signals about the response — useful for verifying the end-to-end pipeline (PAT → RiseUp API → back) without piping an LLM into the loop:
RISEUP_PAT=riseup_pat_... RISEUP_API_BASE=http://127.0.0.1:6040 \
node examples/smoke-test.mjs --date=currentexamples/fetch-budget.mjs is a lower-level alternative that calls the HTTP endpoint directly and dumps the JSON body to stdout for local inspection:
RISEUP_PAT=riseup_pat_... node examples/fetch-budget.mjs 2026-05 > /tmp/budget.jsonBoth default RISEUP_API_BASE to http://127.0.0.1:6040 because Node 18's fetch resolves localhost to ::1 and most servers bind IPv4 only — set explicitly if your local API server is elsewhere.
License
MIT
Available Tools
2 toolsget_budgetA
Get the customer's RiseUp budget for a given month. The budget groups transactions into envelopes (categories) and shows planned vs. actual amount for each. Use this when the user asks about their budget as a whole, categories, envelopes, planned vs. actual spending, or overspending; use get_transactions instead when they ask about individual transactions or merchants.
Input parameters:
date (string, required): The month to fetch. One of:
"YYYY-MM" — a specific month (e.g. "2026-05")
"current" — the current cashflow month
"previous" — the previous cashflow month
Response shape:
{
budgetDate: "YYYY-MM", // the month this response covers
lastUpdatedAt: ISO datetime, // when the cashflow was last refreshed
envelopes: [
{
id: string,
type: "fixed" | "variable" | "variableIncome" | "trackingCategory" | "riseupGoal",
balancedAmount: number, // planned/budgeted amount for this envelope (ILS, negative for expenses)
originalAmount: number, // original budgeted amount before any customer adjustment
balanceDate: string, // when this envelope was last balanced
isCustomPrediction: boolean, // true if customer overrode the prediction
sequenceCustomerComment: string, // customer's own note about this envelope
actuals: [
{
transactionId: string,
transactionDate: "YYYY-MM-DD", // when the transaction happened
billingDate: "YYYY-MM-DD", // when it was billed
businessName: string, // merchant name
isIncome: boolean, // true = income, false = expense
billingAmount: number | null, // ILS amount for EXPENSES; null when isIncome is true
incomeAmount: number | null, // ILS amount for INCOMES; null when isIncome is false
// exactly one of billingAmount / incomeAmount is non-null per transaction
originalAmount: number, // amount in original currency / before conversions
accountNickname: string | null, // customer-defined label for the source account, set in the RiseUp app; null if the customer hasn't set one
accountNumberHash: string | null, // stable 6-character opaque identifier for the source account. Use to distinguish actuals across multiple accounts under the same source (e.g. two different Isracard cards on the same customer). Same account → same hash across every response. Not a cryptographic hash and not the raw account number. Null when no matching identifier is available.
isInstallment: boolean, // true when part of a payment plan
paymentNumber: number, // 1..totalNumberOfPayments (installments only)
totalNumberOfPayments: number, // total installments (installments only)
expense: string, // system-computed fallback category label (Hebrew), e.g. "ביגוד", "מסעדות"; used when no specific category is set
// ... plus sequenceId, placement, transactionBudgetDate, isPostponed,
// sourceType, source, monthsInterval when applicable
}
]
}
],
excluded: [...], // transactions the customer marked as one-offs
_meta: { source: "riseup-external-api", tokenRef: string }
}
Envelope type semantics:
'fixed': Fixed customer expenses (rent, subscriptions, insurance) — recurring with known amounts.
'trackingCategory': A category the customer has chosen to track with a spending goal (e.g. "restaurants" with an 800 ILS/month target).
balancedAmounthere represents the goal.'variable': "Other" day-to-day discretionary spending — not fixed and not in a tracked category. When users ask about "variable expenses" they mean this bucket.
'variableIncome': Variable (non-fixed) income — freelance, one-off payments, etc. There is no tracked-category concept for incomes.
'riseupGoal': A savings goal the customer set through the RiseUp product.
excluded contains transactions the customer marked as one-offs to exclude from the monthly cashflow — atypical spending they don't want counted as regular. Same shape as the transactions inside envelope actuals.
All money fields are in Israeli shekels (ILS). On each actual, billingAmount is populated for expenses and incomeAmount for incomes — exactly one is non-null per transaction (use isIncome to pick which). Envelope-level balancedAmount uses a signed convention: negative for expense categories, positive for income categories.
| Name | Required | Description | Default |
|---|---|---|---|
| date | Yes | The month to fetch. Accepts "YYYY-MM" (e.g. "2026-05"), "current" (the current cashflow month), or "previous" (the previous cashflow month). |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description fully discloses the tool's behavior: it retrieves budget data, describes the response structure, envelope types, and money field semantics. It does not mention side effects or authorization, but as a read-only operation, this is not a major gap. The detailed response shape provides substantial transparency.
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 lengthy but well-structured with clear sections (purpose, usage, parameters, response shape, envelope semantics). Every section adds necessary value for understanding the tool's complex response. It is appropriately sized for the complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the single parameter, no output schema, and no annotations, the description fully compensates by providing the complete response shape, all field explanations, envelope type semantics, and even notes on money conventions. It leaves no ambiguity for an agent to interpret the response.
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 single parameter 'date' is fully documented in the description with allowed values ('YYYY-MM', 'current', 'previous') and their meanings. Since the input schema already describes the parameter (100% coverage), the description adds extra value by explaining the context of each 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?
The description explicitly states the tool retrieves the RiseUp budget for a given month, grouping transactions into envelopes with planned vs actual amounts. It clearly distinguishes from the sibling tool get_transactions by specifying when to use each.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance: 'Use this when the user asks about their budget as a whole... use get_transactions instead when they ask about individual transactions or merchants.' This clearly delineates when to use this tool vs the sibling.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_transactionsA
Get individual transactions from the customer's RiseUp cashflow, filtered by month, exact date, or merchant name. Use this when the user asks about specific transactions, purchases, or spending at particular merchants — as opposed to overall budget categories which live in get_budget.
Filters combine with AND. At least one of cashflowMonth or transactionDate is required — unfiltered queries are rejected server-side to avoid unbounded results.
Input parameters:
cashflowMonth (string, optional): The cashflow month in "YYYY-MM" format (e.g. "2026-06"). Compute the current month from today's date if the user asks about "this month" — the API does not accept "current" or "previous".
transactionDate (string, optional): An exact transaction date in "YYYY-MM-DD" format (e.g. "2026-06-15"). Matches transactions whose transactionDate equals this value.
businessName (string, optional): A substring of the merchant name. Matched case-insensitively as a substring — passing "restaurant" matches "Some Restaurant Chain". Max 100 chars, no HTML/code chars (<>{}[]/"').
Response shape:
{
transactions: [
{
transactionId: string,
transactionDate: ISO datetime, // when the transaction occurred, e.g. "2026-06-15T00:00:00.000Z" — always UTC midnight; the date part is the transaction day
billingDate: ISO datetime, // when it was billed (differs from transactionDate for credit cards); absent on some transactions
cashflowDate: "YYYY-MM", // the cashflow month this transaction is allocated to
businessName: string, // merchant name
isIncome: boolean, // true = income, false = expense
amount: number, // money value in ILS (absolute); use isIncome to determine direction
accountNickname: string | null, // customer-defined label for the source account, set in the RiseUp app; null if the customer hasn't set one
accountNumberHash: string | null, // stable 6-character opaque identifier for the source account. Use to distinguish transactions across multiple accounts under the same source (e.g. two different Isracard cards on the same customer). Same account → same hash across every response. Not a cryptographic hash and not the raw account number. Null when no matching identifier is available.
isInstallment: boolean, // true if part of a payment plan
installmentNumber: number, // current installment index (only meaningful when isInstallment)
totalNumberOfInstallments: number, // total planned installments (only meaningful when isInstallment)
totalNumberOfPayments: number, // legacy alias for totalNumberOfInstallments; may also appear
isPostponed: boolean, // true if pushed to the next month's cashflow (credit-card postponement)
sourceType: string, // account type enum, e.g. "creditCard", "checkingAccount"
source: string, // specific source name/identifier (bank / credit-card provider)
commitmentId: string | null, // populated when the transaction is part of a recurring/fixed commitment (rent, subscription, etc.); null for variable/one-off expenses. Same signal as actualType === "fixed".
actualType: "fixed" | "variable", // whether the transaction is a recurring fixed expense/income or a variable/one-off. May be absent for older transactions.
categoryLabel: string, // customer-facing category name (Hebrew string, e.g. "מסעדות", "ביגוד"). Can be "אחר" (other) when unclassified.
categoryType: "default" | "custom" | "other", // "default": one of RiseUp's built-in system categories. "custom": a category the customer created themselves. "other": the transaction didn't fit any known category (unclassified). May be absent for older transactions.
},
...
],
_meta: { source: "riseup-external-api", tokenRef: string }
}
All money values are in Israeli shekels (ILS) and stored as positive numbers — use isIncome to determine income vs expense, don't infer from sign. Installment fields (installmentNumber, totalNumberOfInstallments, totalNumberOfPayments) are only meaningful when isInstallment is true. Fields that aren't populated for a given transaction may be absent.
| Name | Required | Description | Default |
|---|---|---|---|
| businessName | No | A substring of the merchant name, matched case-insensitively. Max 100 chars. | |
| cashflowMonth | No | The cashflow month in "YYYY-MM" format (e.g. "2026-06"). Required unless transactionDate is provided. Does not accept "current" or "previous" — compute the actual month from today's date. | |
| transactionDate | No | An exact transaction date in "YYYY-MM-DD" format. Filters transactions whose transactionDate equals this value. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description fully discloses behavior: required parameters, filter logic, rejection of unfiltered queries, and a detailed explanation of the response shape including field meanings, currency, and nullability. It even advises on computing the current month.
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 well-structured with sections for purpose, filtering rules, input parameters, and response shape. While lengthy, the detail is justified by the complex response and lack of output schema. It is front-loaded with the core 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?
Given the tool's complexity (3 parameters, rich response with many fields, no output schema), the description is remarkably complete. It explains all response fields, their meanings, special cases (installments, nulls), and provides necessary context for correct interpretation.
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 covers all parameters with descriptions (100% coverage), but the description adds extra context: computation advice for 'this month', substring matching details, character limits, and format examples. This goes beyond the schema's 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 tool retrieves individual transactions from RiseUp cashflow with filters, and explicitly distinguishes it from the sibling tool get_budget for budget categories. The verb 'Get' and resource 'transactions from cashflow' are specific.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use (specific transactions, purchases, merchants) and when not (budget categories, which go to get_budget). It also details filter combination (AND) and required parameter constraints, including the server-side rejection of unbounded queries.
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.
2 tool updates
v0.2.0- Changed
get_budget1 field changed- added
Input schema / properties / date / descriptionAdded value: +"The month to fetch. Accepts \"YYYY-MM\" (e.g. \"2026-05\"), \"current\" (the current cashflow month), or \"previous\" (the previous cashflow month)."
- Added
get_transactions
1 tool update
v0.1.1- First observed
get_budget
TDQS
Scored across 2 tools
The two tools, get_budget and get_transactions, have clearly distinct purposes: get_budget provides budget overview with envelope-level detail, while get_transactions returns individual transactions with various filters. Their descriptions explicitly differentiate usage scenarios, eliminating any ambiguity.
Both tool names follow a consistent verb_noun pattern (get_budget, get_transactions), using lowercase with underscores. This pattern is clear and predictable.
With only 2 tools, the set feels thin for a personal finance domain. While the tools cover core read-only functionality (budget overview and transaction details), a more complete interface might include tools for managing envelopes, goals, or modifying transactions. However, given the explicit read-only nature (riseup-external-api), the count is borderline acceptable.
For a read-only API, the two tools cover the essential views: budget summaries with envelope actuals and individual transaction listings with filtering. Minor gaps exist (e.g., no search by amount, no aggregation functions), but the core needs are met without significant dead ends.
Maintenance
Related MCP Connectors
Query your real net worth, spending, transactions, budgets and portfolio from any MCP client.
Personal finance for AI agents — onboard, import statements, categorize & budget over MCP.
The Ramp MCP server enables users to securely connect Ramp with AI assistants like ChatGPT and Claude to query financial data and take actions using natural language. It transforms Ramp's developer API into a SQL interface that LLMs can query, allowing admins to analyze spend trends, identify cost savings, and run complex SQL analyses on comprehensive datasets (transactions, purchase orders, vendors, users), while all users can manage cards, view transactions, request reimbursements, and get expense policy answers.
An MCP server that provides read access to your cloud storage providers, bank accounts and more.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceAn MCP server that enables AI assistants to interact directly with Lunch Money's financial API, allowing users to query transactions, access budget information, and perform financial analysis through natural language.-
- AlicenseNot gradedqualityAmaintenanceMCP server that connects AI assistants to Actual Budget for budget management, enabling natural language queries, transaction creation, and spending analysis.390 npm54MIT
- AlicenseNot gradedqualityCmaintenanceAn MCP server that connects AI assistants to YNAB budgets, enabling natural language queries about finances backed by full API coverage and built-in YNAB methodology knowledge.1MIT
- AlicenseAqualityDmaintenanceRead-only MCP and HTTP proxy server for accessing Monarch Money financial data, enabling transaction analysis, budget tracking, and cashflow insights through natural language.6MIT