TaxFormatter
Developer API · Now Live

Parse any crypto CSV or bank PDF.One API call.

Auto-detection, structured JSON output, and tax-ready formatting — built for developers and AI agents.

Get API KeyRead the Docs
14 exchanges·6 banks·4 output formats·<2s response
api.taxformatter.com
POST/v1/parse
curl -X POST https://api.taxformatter.com/v1/parse \
-H "X-API-Key: tf_live_sk8f2m..." \
-H "Content-Type: application/json" \
-d '{
"file_content": "<base64>",
"filename": "coinbase_2024.csv",
"output_format": "koinly"
}'

Integration

Three lines to parse.
Any language.

Send a base64-encoded file. Get structured JSON back. Auto-detects exchanges, normalizes dates, converts formats.

import requests

response = requests.post(
    "https://api.taxformatter.com/v1/parse",
    headers={"X-API-Key": "tf_live_sk8f2m..."},
    json={
        "file_content": base64_encoded_csv,
        "filename": "coinbase_2024.csv",
        "output_format": "koinly"
    }
)

data = response.json()
print(f"Parsed {data['metadata']['transaction_count']} txs")
for tx in data["transactions"]:
    print(f"  {tx['Date']} {tx['Type']} {tx['Amount']}")
Auto-detect exchange
Base64 in, JSON out
4 output formats
Bank PDF support
Structured errors
Model Context Protocol

Give your AI agent
financial sight.

One install. Your agent can parse crypto CSVs and bank statements without you writing a single line of integration code.

$npx @taxformatter/mcp-server

Works with Claude Code, Cursor, Windsurf, and any MCP-compatible client.

1

Add to your MCP config

claude_desktop_config.json
{
  "mcpServers": {
    "taxformatter": {
      "command": "npx",
      "args": ["@taxformatter/mcp-server"],
      "env": {
        "TAXFORMATTER_API_KEY": "tf_live_..."
      }
    }
  }
}
2

Ask your agent to parse files

You say:

“Parse my Coinbase CSV from Downloads and tell me my total capital gains for 2024.”

3 MCP tools exposed

Your agent gets these capabilities automatically.

parse_crypto_csv

Parse any exchange CSV — auto-detects Coinbase, Binance, Kraken, and 11 more. Returns structured transactions in your chosen tax format.

parse_bank_statement

Extract transactions from bank statement PDFs. Supports Chase, Mercury, Navy Federal, and more. Auto-detects the bank.

list_supported_sources

Query all supported crypto exchanges, banks, and output formats. Perfect for building dynamic UIs or agent prompts.

View on npm

What it parses

One endpoint. Every format.

POST a file to /v1/parse — the API handles detection, normalization, and conversion.

Crypto Exchanges

14

✓verified by a fixture-backed parse test in CI — beta exchanges parse but have no fixture yet

Binance✓
Coinbase✓
Kraken✓
KuCoin✓
Bybit✓
Cash App✓
Robinhood✓
PayPalbeta
Venmobeta
Crypto.com✓
Gemini✓
FTX✓
Bitfinex✓
OKX✓

Bank PDFs

6

✓verified against real statements — beta banks are configured but not yet verified

Chase✓
Mercury✓
Navy Federal✓
Bank of Americabeta
Wells Fargobeta
Citibeta

Output Formats

Koinly
TurboTax
CoinLedger
ZenLedger

Set output_format in your request. Default: Koinly.

Auto-detectionSend any CSV — we detect the exchange from headers alone.
PDF ParsingBank statements in, structured JSON out.
Structured ErrorsMachine-readable codes with actionable suggestions.
EphemeralIn-memory processing. Nothing stored. Ever.
Sub-2sCSVs under 1s. PDFs under 2s. Timing in every response.
Enterprise ReadyRate limits, usage tracking, key management, Stripe billing.
Every response includes
statussummarydetected_sourcesource_typetransactions[]warnings[]metadata.processing_time_msmetadata.transaction_count

Pricing

One plan, two ways to use it.

Drop a file in the dashboard or call our API. Same quota, same categorization, same plan.

Free

$0/ month

Try it. No credit card.

  • 25 files / month
  • 10 requests / minute
  • All 14 exchanges
  • Standard insights
  • JSON response

No credit card required

Starter

$29/ month

Solo work and side projects.

  • 100 files / month
  • 30 requests / minute
  • All 14 exchanges
  • Standard insights
  • JSON response
POPULAR

Growth

$99/ month

Teams and SaaS apps. Bank PDFs unlocked.

  • 500 files / month
  • 60 requests / minute
  • Bank PDF parsing
  • Advanced insights
  • All output formats
  • Priority support

Business

$249/ month

High-volume processing, deepest insights.

  • 2,000 files / month
  • 120 requests / minute
  • Everything in Growth
  • Premium insights
  • Custom integrations

Security

Engineered for paranoia.

We assume your data is toxic. Our system is designed to touch it, fix it, and let go of it within 30 days.

Raw Data
Void

Deleted Within 30 Days

Your financial data is a liability. Uploads, outputs, and parsed rows are deleted within 30 days — sooner the moment you delete them from your dashboard. API payloads are never stored at all.

30-day auto-delete
Date
Type
Amount
23/30/01
STAKE_R
0.005 ETH
2023-01-30
INCOME
0.005 ETH

The Diff Guarantee

Don't trust "magic." Our engine fixes formats, not financials. We provide a cell-level audit trail for every modification. Verify every single decimal point.

Audit trail active
What we accept
Uploads only
exchange-export.csv
exchange API key
bank login

No Credentials, Ever

We never ask for exchange API keys, bank logins, or wallet keys. You upload the export files your exchange or bank already gives you — there is nothing to connect and nothing we could withdraw.

Nothing to connect

API data handling

Payloads never stored

API request bodies are parsed in memory and never written to S3 or the database. Nothing from the payload outlives the invocation.

Metadata-only logging

Per request we keep the key id, endpoint, status code, byte size, latency, detected source, error code, and caller IP for rate limiting — never file contents or transaction rows. Every response carries processing_time_ms in its metadata.

SHA-256 key hashing

API keys are one-way hashed at rest. Even in a full database breach, your active keys are unreadable. Keys are prefixed tf_live_ for identification only.

TLS in transit

Every request to api.taxformatter.com is TLS-encrypted between your app and our API Gateway. No plaintext financial data touches the wire.

Hosted on AWS (us-east-1)
AES-256 Encryption at Rest
AWS & Stripe: SOC 2–audited providers
Card data handled by Stripe, never us
View our full security practices

Before you integrate

Things devs actually ask.

No fluff. Real answers about the API, MCP server, and how it all works.

Header fingerprinting. Every exchange exports slightly different column names and ordering. We hash the headers against our registry of 14 known formats and match instantly. If we can't match, we fall back to a generic parser that looks for date + amount columns. You can also pass the exchange name explicitly to skip detection.
It wraps our REST API as three MCP tools that any compatible AI agent (Claude, GPT, custom builds) can call natively. Your agent can read a CSV from disk, base64-encode it, POST it to /v1/parse, and get structured transactions back — all without you writing any integration code. Just add our npx package to your MCP config and go.
No. Files are processed in-memory inside the Lambda and discarded immediately after the response is sent. Nothing touches disk, nothing gets logged, nothing persists. We track usage counts and byte totals for billing, but never the file contents or transaction data.
We don't hard-block you. Requests keep working but we set an X-Api-Overage header on responses so your app knows you're over. No surprise 403s killing your users' experience. Upgrade your tier or wait for the month to roll over.
Yes. Send a PDF with filename ending in .pdf and we'll route it to the bank statement processor automatically. Chase, Mercury, and Navy Federal are verified against real statements; Bank of America, Wells Fargo, and Citi are in beta (configured, not yet verified). The API auto-detects the bank from the PDF content — no configuration needed. The live list is always at GET /v1/sources.
Four: Koinly (universal template), TurboTax (Form 8949), CoinLedger (manual import), and ZenLedger (custom CSV). Pass output_format in your request. Default is Koinly. All formats normalize dates, amounts, and transaction types to match what each tax platform expects.
Typical CSV parsing completes in under 1 second. Bank statement PDFs take 1-2 seconds depending on page count. The API Lambda has a 120-second timeout and 1GB memory, so even large files (up to 10MB) process without issues. We include processing_time_ms in every response so you can monitor latency.
Pass the exchange parameter explicitly in your request to override auto-detection. If you're not sure which exchange it is, hit GET /v1/sources first to see all supported formats. The API also returns a detected_source field in every response so you can verify what it matched.
Starter is $29/mo — 100 files, 30 requests per minute, all 14 exchanges, all output formats. Enough to build and ship a real integration. When you need more volume, upgrade to Growth ($99/mo for 500 files) or Business ($249/mo for 2,000 files).