Monarch Money (Node.js)

Node.js/TypeScript library for accessing Monarch Money data.

Disclaimer: This project is unofficial and not affiliated with Monarch Money.

Installation

npm install @hakimelek/monarchmoney

Requires Node.js 18+ (uses native fetch and AbortSignal.timeout).

Quick Start

import {
  MonarchMoney,
  EmailOtpRequiredException,
  RequireMFAException,
} from "@hakimelek/monarchmoney";

const mm = new MonarchMoney();

try {
  await mm.login("[email protected]", "password");
} catch (e) {
  if (e instanceof EmailOtpRequiredException) {
    // Monarch sent a verification code to your email
    const code = await promptUser("Enter the code from your email:");
    await mm.submitEmailOtp("[email protected]", "password", code);
  } else if (e instanceof RequireMFAException) {
    // TOTP-based MFA is enabled on the account
    await mm.multiFactorAuthenticate("[email protected]", "password", "123456");
  }
}

// Fetch data — fully typed responses
const { accounts } = await mm.getAccounts();
console.log(accounts[0].displayName, accounts[0].currentBalance);

Authentication

Monarch's API requires email verification (OTP) for new devices/sessions, even when MFA is disabled. The library handles this with distinct exception types so your app can respond appropriately.

Login with email OTP handling

try {
  await mm.login(email, password);
} catch (e) {
  if (e instanceof EmailOtpRequiredException) {
    // A code was sent to the user's email — prompt them for it
    const code = await yourApp.promptForEmailCode();
    await mm.submitEmailOtp(email, password, code);
  }
}

With MFA secret key (automatic TOTP)

await mm.login("email", "password", {
  mfaSecretKey: "YOUR_BASE32_SECRET",
});

The MFA secret is the "Two-factor text code" from Settings > Security > Enable MFA in Monarch Money.

Session persistence & token reuse

After a successful login (including email OTP), you can save the token to avoid re-authenticating on every run:

// Save token after login
mm.saveSession(); // writes to .mm/mm_session.json (mode 0o600)

// Next time, login() loads the saved session automatically
await mm.login(email, password); // uses saved token, no network call

// Or pass the token directly (skip login entirely)
const mm = new MonarchMoney({ token: "your-saved-token" });

mm.saveSession();          // save to disk
mm.loadSession();          // load from disk
mm.deleteSession();        // remove the file
mm.setToken("...");        // set token programmatically

Interactive CLI

await mm.interactiveLogin(); // prompts for email, password, email OTP or MFA code

API

All methods return typed responses. Hover over any method in your editor for full JSDoc and type information.

Read Methods

| Method | Returns | Description | |--------|---------|-------------| | getAccounts() | GetAccountsResponse | All linked accounts | | getAccountTypeOptions() | GetAccountTypeOptionsResponse | Available account types/subtypes | | getRecentAccountBalances(startDate?) | GetRecentAccountBalancesResponse | Daily balances (default: last 31 days) | | getAccountSnapshotsByType(startDate, timeframe) | GetSnapshotsByAccountTypeResponse | Snapshots by type ("year" / "month") | | getAggregateSnapshots(options?) | GetAggregateSnapshotsResponse | Aggregate net value over time | | getAccountHoldings(accountId) | GetAccountHoldingsResponse | Securities in a brokerage account | | getAccountHistory(accountId) | AccountHistorySnapshot[] | Daily balance history | | getInstitutions() | GetInstitutionsResponse | Linked institutions | | getBudgets(startDate?, endDate?) | GetBudgetsResponse | Budgets with actuals (default: last month → next month) | | getSubscriptionDetails() | GetSubscriptionDetailsResponse | Plan status (trial, premium, etc.) | | getTransactionsSummary() | GetTransactionsSummaryResponse | Aggregate summary | | getTransactions(options?) | GetTransactionsResponse | Transactions with full filtering | | getAllTransactions(options?) | Transaction[] | All matching transactions (auto-paginates) | | getTransactionPages(options?) | AsyncGenerator<Transaction[]> | Async generator yielding pages | | getTransactionCategories() | GetTransactionCategoriesResponse | All categories | | getTransactionCategoryGroups() | GetTransactionCategoryGroupsResponse | Category groups | | getTransactionDetails(id) | typed response | Single transaction detail | | getTransactionSplits(id) | typed response | Splits for a transaction | | getTransactionTags() | GetTransactionTagsResponse | All tags | | getCashflow(options?) | GetCashflowResponse | Cashflow by category, group, merchant | | getCashflowSummary(options?) | GetCashflowSummaryResponse | Income, expense, savings, savings rate | | getRecurringTransactions(start?, end?) | GetRecurringTransactionsResponse | Upcoming recurring transactions | | isAccountsRefreshComplete(ids?) | boolean | Check refresh status |

Write Methods

| Method | Returns | Description | |--------|---------|-------------| | createManualAccount(params) | CreateManualAccountResponse | Create manual account | | updateAccount(id, updates) | UpdateAccountResponse | Update account settings/balance | | deleteAccount(id) | DeleteAccountResponse | Delete account | | requestAccountsRefresh(ids) | boolean | Start refresh (non-blocking) | | requestAccountsRefreshAndWait(opts?) | boolean | Refresh and poll until done | | createTransaction(params) | CreateTransactionResponse | Create transaction | | updateTransaction(id, updates) | UpdateTransactionResponse | Update transaction | | deleteTransaction(id) | boolean | Delete transaction | | updateTransactionSplits(id, splits) | UpdateTransactionSplitResponse | Manage splits | | createTransactionCategory(params) | CreateCategoryResponse | Create category | | deleteTransactionCategory(id, moveTo?) | boolean | Delete category | | deleteTransactionCategories(ids) | (boolean \| Error)[] | Bulk delete | | createTransactionTag(name, color) | CreateTransactionTagResponse | Create tag | | setTransactionTags(txId, tagIds) | SetTransactionTagsResponse | Set tags on transaction | | setBudgetAmount(params) | SetBudgetAmountResponse | Set/clear budget | | uploadAccountBalanceHistory(id, csv) | void | Upload balance history CSV |

Error Handling

import {
  MonarchMoneyError,          // base class for all errors
  EmailOtpRequiredException,  // email verification code needed — call submitEmailOtp()
  RequireMFAException,        // TOTP MFA required — call multiFactorAuthenticate()
  LoginFailedException,       // bad credentials or auth error (includes .statusCode)
  RequestFailedException,     // API/GraphQL failure (includes .statusCode, .graphQLErrors)
} from "@hakimelek/monarchmoney";

try {
  await mm.login(email, password);
} catch (e) {
  if (e instanceof EmailOtpRequiredException) {
    // e.code === "EMAIL_OTP_REQUIRED"
    // Prompt user for the code sent to their email
    const code = await getCodeFromUser();
    await mm.submitEmailOtp(email, password, code);
  } else if (e instanceof RequireMFAException) {
    // e.code === "MFA_REQUIRED"
    // Prompt for TOTP code or use mfaSecretKey
  } else if (e instanceof LoginFailedException) {
    // e.code === "LOGIN_FAILED", e.statusCode
    console.error("Login failed:", e.message);
  }
}

try {
  await mm.getAccounts();
} catch (e) {
  if (e instanceof RequestFailedException) {
    console.error(e.statusCode);     // HTTP status, if applicable
    console.error(e.graphQLErrors);  // GraphQL errors array, if applicable
    console.error(e.code);           // "HTTP_ERROR" | "REQUEST_FAILED"
  }
}

Configuration

const mm = new MonarchMoney({
  sessionFile: ".mm/mm_session.json", // session file path
  timeout: 10,                        // API timeout in seconds
  token: "pre-existing-token",        // skip login
  retry: {
    maxRetries: 3,                    // retry on 429/5xx (default: 3, set 0 to disable)
    baseDelayMs: 500,                 // base delay with exponential backoff + jitter
  },
  rateLimit: {
    requestsPerSecond: 10,            // token-bucket throttle (default: 0 = unlimited)
  },
});

mm.setTimeout(30); // change timeout later

Retry automatically handles transient failures (429 Too Many Requests, 500, 502, 503, 504) with exponential backoff and jitter. The Retry-After header is respected on 429 responses.

Auto-Pagination

getTransactions() returns a single page. For large datasets, use the auto-pagination helpers:

// Async generator — yields one page at a time (memory-efficient)
for await (const page of mm.getTransactionPages({ startDate: "2025-01-01", endDate: "2025-12-31" })) {
  for (const tx of page) {
    console.log(tx.merchant?.name, tx.amount);
  }
}

// Or collect everything into a flat array
const all = await mm.getAllTransactions({
  startDate: "2025-01-01",
  endDate: "2025-12-31",
  pageSize: 100, // transactions per page (default: 100)
});
console.log(`${all.length} total transactions`);

Both methods accept the same filter options as getTransactions() (date range, category, account, tags, etc.).

Refresh Progress

Track account refresh progress with the onProgress callback:

await mm.requestAccountsRefreshAndWait({
  timeout: 300,
  delay: 10,
  onProgress: ({ completed, total, elapsedMs }) => {
    console.log(`${completed}/${total} accounts refreshed (${(elapsedMs / 1000).toFixed(0)}s)`);
  },
});

MCP Server (AI Agent Integration)

This package includes a built-in Model Context Protocol server with 30 tools, making your Monarch Money data accessible to AI assistants like Claude Desktop, Cursor, and any MCP-compatible client.

Setup

1. Get your Monarch Money auth token by logging in with the library (see Authentication) and saving mm.token.

2. Add to your MCP client config (e.g. Claude Desktop claude_desktop_config.json):

{
  "mcpServers": {
    "monarch-money": {
      "command": "npx",
      "args": ["@hakimelek/monarchmoney"],
      "env": {
        "MONARCH_TOKEN": "your-token-here"
      }
    }
  }
}

Or run it directly:

MONARCH_TOKEN=your-token npx @hakimelek/monarchmoney

Available Tools

Read (18 tools): get_accounts, get_account_holdings, get_account_history, get_account_type_options, get_recent_account_balances, get_aggregate_snapshots, get_institutions, get_budgets, get_subscription_details, get_transactions, get_transactions_summary, get_transaction_details, get_transaction_categories, get_transaction_category_groups, get_transaction_tags, get_cashflow, get_cashflow_summary, get_recurring_transactions

Write (12 tools): create_transaction, update_transaction, delete_transaction, create_manual_account, update_account, delete_account, refresh_accounts, is_refresh_complete, set_budget_amount, create_transaction_tag, set_transaction_tags, create_transaction_category

Every tool has typed parameters with descriptions, so AI agents know exactly what arguments to pass.

Project Structure

src/
  index.ts      — public exports
  client.ts     — MonarchMoney class with all API methods
  mcp.ts        — MCP server (30 tools for AI agents)
  errors.ts     — error classes (MonarchMoneyError hierarchy)
  endpoints.ts  — API URL constants
  queries.ts    — all GraphQL query/mutation strings
  types.ts      — TypeScript interfaces for all API responses

Testing

npm test              # run tests once
npm run test:watch    # run tests in watch mode
npm run test:coverage # run with coverage report

Tests use Vitest and do not require real API credentials (fetch is mocked where needed).

Test the API connection (against the live api.monarch.com):

npm run build

# Login with email + password (will prompt for email OTP code if required)
[email protected] MONARCH_PASSWORD=yourpassword npm run test:connection

# Use a saved token (skips login)
MONARCH_TOKEN=your-token npm run test:connection -- --token

Set these in a .env file for convenience (see .env.example).

FAQ

How do I use this if I login to Monarch via Google?

Set a password on your Monarch account at Settings > Security, then use that password with this library.

Why does Monarch ask for an email code every time I login?

Monarch requires email verification for new/unrecognized devices. After login, save the session token with mm.saveSession() or store mm.token — subsequent runs will reuse it without re-authenticating.

How This Library Compares

There are several unofficial Monarch Money integrations. Here's how @hakimelek/monarchmoney stacks up.

Landscape

| | @hakimelek/monarchmoney | monarch-money-api (pbassham) | monarchmoney (keithah) | monarchmoney (hammem) | |---|---|---|---|---| | Platform | Node.js / TypeScript | Node.js / JavaScript | Node.js / TypeScript | Python | | npm weekly downloads | — | ~440 | ~130 | N/A (pip: ~103K/mo) | | Runtime deps | 1 (speakeasy) | 5 | 7 | 3 | | TypeScript types | Full (every response) | None | Yes | N/A | | Email OTP flow | Yes | No | No | No | | MFA / TOTP | Yes | Yes | Yes | Yes | | Session persistence | Yes (0o600 perms) | Yes | Yes (AES-256) | Yes | | Interactive CLI login | Yes | Yes | Yes | Yes | | HTTP client | Native fetch | node-fetch | node-fetch + graphql-request | aiohttp | | Error hierarchy | 4 typed exceptions | Generic throws | Generic throws | 1 exception | | Read methods | 20 | 15 | ~20 | ~16 | | Write methods | 14 | 9 | ~12 | ~10 | | Rate limiting | Yes | No | Yes | No | | Retry with backoff | Yes | No | Yes | No | | Auto-pagination | Yes | No | No | No | | Dual CJS + ESM | Yes | No | Yes | No | | Refresh progress events | Yes | No | No | No | | Built-in MCP server | Yes (30 tools) | No | No | No |

Where this library wins

Minimal footprint. One runtime dependency vs 5-7 in the JS/TS alternatives. Native fetch means zero HTTP polyfills on Node 18+.

Email OTP support. Monarch now requires email verification for unrecognized devices, even when MFA is off. This is the only Node.js library that handles the full EmailOtpRequiredException → submitEmailOtp() flow. Without it, automated scripts break on first login from a new environment.

Typed everything. Every API response has a dedicated TypeScript interface — 50+ exported types covering accounts, transactions, holdings, cashflow, budgets, recurring items, and mutations. The monarch-money-api package has no types at all.

Structured error handling. Four distinct exception classes (LoginFailedException, RequireMFAException, EmailOtpRequiredException, RequestFailedException) with error codes and status codes. Competitors throw generic errors or strings.

Broader write coverage. Includes updateTransaction(), setBudgetAmount(), uploadAccountBalanceHistory(), getCashflow(), getCashflowSummary(), and getRecurringTransactions() — all missing from monarch-money-api.

Clean, flat API. One class, direct methods, no sub-objects or verbosity levels to learn. Import MonarchMoney, call methods, get typed results.

Contributing

Contributions welcome. Please ensure TypeScript compiles cleanly (npm run build) and tests pass (npm test).

License

MIT