Quickstart

Install

npm install @moneyline/sdk

pip install moneyline

go get github.com/paragonhq/moneylined/sdks/go

Base URL

Environment	Base URL
Local (self-hosted, default)	`http://localhost:3000`
Production	`https://api.moneyline.co`

Every example below runs against http://localhost:3000. See self-hosting to bring that up, or swap in your production URL.

Authenticate

Every request needs an API key, sent as either Authorization: Bearer <key> or X-Api-Key: <key>. Keys are ml_live_* (production) or ml_test_* (sandbox).

export MONEYLINE_API_KEY="ml_test_your_api_key_here"

All three SDKs read MONEYLINE_API_KEY from the environment, so you rarely pass the key in code:

import { Moneyline } from '@moneyline/sdk';

// Reads MONEYLINE_API_KEY and MONEYLINE_BASE_URL from the environment.
const client = new Moneyline();

from moneyline import Moneyline

client = Moneyline()

client, err := moneyline.NewClient("")
if err != nil {
	log.Fatal(err)
}
ctx := context.Background()

One naming rule worth knowing up front. The API takes snake_case request bodies and returns camelCase response fields. You send external_id, you read back externalId. The Node and Python SDKs pass your parameters through verbatim, so their create and update params are snake_case too. This trips up nearly everyone once.

Create a submission

A submission is the container for one applicant’s documents and analysis.

curl -X POST http://localhost:3000/v1/submissions \
  -H "Authorization: Bearer $MONEYLINE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "external_id": "deal-001",
    "name": "Acme Corp Application",
    "company_info": { "name": "Acme Corp", "ein": "12-3456789" }
  }'

const submission = await client.submissions.create({
  external_id: 'deal-001',
  name: 'Acme Corp Application',
  company_info: { name: 'Acme Corp', ein: '12-3456789' },
});

console.log(submission.id, submission.externalId, submission.status);

submission = client.submissions.create(
    external_id="deal-001",
    name="Acme Corp Application",
    company_info={"name": "Acme Corp", "ein": "12-3456789"},
)

print(submission.id, submission.external_id, submission.status)

submission, err := client.Submissions.Create(ctx, &moneyline.CreateSubmissionParams{
	ExternalID:  "deal-001",
	Name:        "Acme Corp Application",
	CompanyInfo: map[string]interface{}{"name": "Acme Corp", "ein": "12-3456789"},
})
if err != nil {
	log.Fatal(err)
}

The response is wrapped in a data envelope:

{
  "data": {
    "id": "f47ac10b-58cc-4372-a567-0e02b2c3d479",
    "tenantId": "9c1f0f6e-3f1a-4a5e-9d2b-7c3e1b0a4d55",
    "externalId": "deal-001",
    "name": "Acme Corp Application",
    "status": "new",
    "metadata": {},
    "companyInfo": { "name": "Acme Corp", "ein": "12-3456789" },
    "createdAt": "2026-09-02T00:00:00.000Z",
    "updatedAt": "2026-09-02T00:00:00.000Z"
  }
}

The SDKs unwrap data for you and hand back the object directly.

Upload a document

Documents are uploaded as multipart/form-data and classified automatically — bank statement, tax return, P&L, and so on — then queued for parsing.

curl -X POST http://localhost:3000/v1/submissions/$SUBMISSION_ID/documents \
  -H "Authorization: Bearer $MONEYLINE_API_KEY" \
  -F "file=@./chase-jan-2026.pdf"

import { readFileSync } from 'node:fs';

const document = await client.documents.upload({
  submission_id: submission.id,
  file: readFileSync('./chase-jan-2026.pdf'),
  filename: 'chase-jan-2026.pdf',
});

document = client.documents.upload(
    submission.id,
    file="./chase-jan-2026.pdf",
)

f, err := os.Open("./chase-jan-2026.pdf")
if err != nil {
	log.Fatal(err)
}
defer f.Close()

document, err := client.Documents.Upload(ctx, submission.Id, "chase-jan-2026.pdf", f)

Pass document_class if you already know the type and want to skip classification.

Wait for processing

Parsing and enrichment are asynchronous. Poll the submission until it leaves the processing states — the TypeScript and Python SDKs ship a helper that does exactly this.

curl http://localhost:3000/v1/submissions/$SUBMISSION_ID/status \
  -H "Authorization: Bearer $MONEYLINE_API_KEY"

// Polls until status is processed / reviewed / failed (default timeout 5 min).
const processed = await client.submissions.waitForProcessing(submission.id, {
  timeout: 300_000,
  pollInterval: 5_000,
});

processed = client.submissions.wait_for_processing(submission.id, timeout=300)

// Go has no polling helper — check the status yourself.
status, err := client.Submissions.GetProcessingStatus(ctx, submission.Id)

In production, prefer webhooks over polling: subscribe to submission.processed and react to the event.

List the extracted transactions

Transactions come back enriched — categorized, merchant-matched, and deduplicated.

curl "http://localhost:3000/v1/transactions?submission_id=$SUBMISSION_ID&limit=25" \
  -H "Authorization: Bearer $MONEYLINE_API_KEY"

// `list` returns an async iterator that pages transparently.
for await (const txn of client.transactions.list({ submission_id: submission.id })) {
  console.log(txn.postedAt, txn.amount, txn.category);
}

for txn in client.transactions.list(submission_id=submission.id):
    print(txn.posted_at, txn.amount, txn.category)

page, err := client.Transactions.List(ctx, &moneyline.ListTransactionsParams{
	SubmissionID: submission.Id,
	Limit:        25,
})

Read the analytics

Every calculation lives on the analytics resource — not on submissions.

curl http://localhost:3000/v1/submissions/$SUBMISSION_ID/scorecard \
  -H "Authorization: Bearer $MONEYLINE_API_KEY"

const scorecard = await client.analytics.getScorecard(submission.id);
const cashflow = await client.analytics.getCashflow(submission.id);
const risk = await client.analytics.getRiskScore(submission.id);

scorecard = client.analytics.scorecard(submission.id)
cashflow = client.analytics.cashflow(submission.id)
risk = client.analytics.risk_score(submission.id)

scorecard, err := client.Analytics.GetScorecard(ctx, submission.Id)
cashflow, err := client.Analytics.GetCashflow(ctx, submission.Id)
risk, err := client.Analytics.GetRiskScore(ctx, submission.Id)

There are fifteen analytics methods in every SDK — balances, anomalies, forecasts, recurring payments, merchant summaries, categories, and more. See the SDK reference for the full list.

Next steps

Concepts

The data model behind submissions, documents, and transactions.

Webhooks

React to processing events instead of polling.

Pagination

Cursor pagination, and the auto-paging helpers in each SDK.

Errors

The error envelope, and the typed errors each SDK raises.

Ship it

You have a submission, a parsed document, and analytics. Next: react to events instead of polling, and give every write an idempotency key.

Set up webhooks Browse the SDKs

Get started

Guides

Tools

Install

Base URL

Authenticate

Next steps

Concepts

Webhooks

Pagination

Errors

​Install

​Base URL

​Authenticate

​Next steps

Concepts

Webhooks

Pagination

Errors

Install

Base URL

Authenticate

Next steps