# Accounting integrations Source: https://getlemma.com/docs/accounting-integrations Connect Lemma directly to your accounting software. Lemma integrates directly with your practice's accounting software. The integration reads and writes financial data — transactions, invoices, and bills — without any manual export or import steps. If you prefer to move data manually, the [Export transactions](/docs/guides/export-transactions) guide covers CSV and QuickBooks `.qbo` file exports. ## Supported platforms Lemma integrates with the following accounting platforms: * Acumatica * Exact Online * Fortnox * FreeAgent * FreshBooks * Fulfil * Holded * Kashflow * Lexware * Microsoft Dynamics 365 Business Central * Microsoft Dynamics 365 Finance & Operations * Microsoft Great Plains * Moneybird * MYOB * NetSuite * Odoo * Oracle Fusion ERP Cloud * Pennylane * QuickBooks Desktop * QuickBooks Online * Sage Business Cloud Accounting * Sage Intacct * SAP Ariba * SAP Business One * SAP S/4HANA * Visma * Wave * Xero * Zoho Books ## Get connected Connect your accounting software from the [integrations page](https://app.getlemma.com/_/settings/integrations). If you don't see your platform listed, contact Lemma and we'll turn it on for your account. # Charge a virtual card yourself from Move money Source: https://getlemma.com/docs/acquiring/charge-a-card Charge a payer's virtual card directly in Lemma when you receive the card by payer portal, fax, or phone instead of lockbox mail. Reach out to Lemma to get self-serve card charging enabled for your entity. It also requires [card acquiring](/docs/acquiring). When a virtual card arrives in your [lockbox](/docs/guides/lockbox) mail, Lemma detects and charges it for you. But payers sometimes hand you a card directly instead: in a payer portal, over fax, or read out over the phone. Charge those cards yourself from [Move money > Charge a card](https://app.getlemma.com/_/move-money/charge-card). ## Before you start * **Self-serve charging is enabled.** The **Charge a card** option only appears on the Move money page after Lemma enables it for your entity. Reach out to us to turn it on. * **You have a banking role.** Any [banking role](/docs/guides/team-management#banking-permissions) can charge a card, including Read Only. Charging a card only brings money in, the same as depositing a check. * **You have the card details.** Have the card number, expiration date, and security code exactly as the payer provided them. ## Charge a card Go to [Move money](https://app.getlemma.com/_/move-money) and select **Charge a card**. Enter the amount to charge. A single charge can be up to \$50,000. Payer virtual cards typically carry an exact authorized amount, so enter it precisely. Enter the card number, expiration date, and security code exactly as the payer provided them, then select **Charge**. If the card is declined, no money moves. If the card was already charged, Lemma tells you instead of charging it twice. ## After you charge The card is charged immediately and the funds appear in your account in 24 to 36 hours. The charge shows up on your [Card Processing](https://app.getlemma.com/_/acquiring) page alongside the cards Lemma charges from your lockbox, and you can follow its status there. Like every card payment, a self-serve charge produces two line items: an **Acquiring** transaction for the gross amount and a separate **Fee** transaction for the processing cost. See [how card payments show up](/docs/acquiring#payments-and-fees-are-separate-transactions) and the [pricing page](/docs/billing/pricing) for card processing fees. ## Related How Lemma charges cards from your lockbox and how payments appear. What happens when a payer disputes a card charge. # Chargebacks Source: https://getlemma.com/docs/acquiring/chargebacks Understand the chargeback lifecycle on Lemma, when funds are debited, what fees apply, and how disputed money is returned when you win. A chargeback happens when a cardholder disputes a charge with their card issuer instead of paying it. Visa and Mastercard arbitrate the dispute, and while it runs the disputed funds are held back from your account. Chargebacks are rare when your card volume comes from payers reimbursing a clinic. They come up more often when a patient disputes a bill they don't want to pay. ## The chargeback lifecycle Some disputes open as an inquiry — the issuer asks for information before anything is formally disputed. Your money is untouched at this stage. The \$25 dispute fee is charged as soon as the chargeback opens. The disputed amount itself is not debited yet. We contact you for documentation supporting the charge — typically the invoice, proof of service, patient consent, and any correspondence with the cardholder. Respond within the window we give you; the card networks enforce tight deadlines. Once the dispute is formally opened, the disputed amount is debited from your account and appears as its own transaction. Lemma packages your evidence and submits it to Visa or Mastercard on your behalf. * **You win.** The disputed amount is credited back to your account as a separate transaction. * **You lose.** The debit stands and the funds stay with the cardholder. A dispute can be provisionally decided in your favor before it's final. Your funds stay held until the issuing bank makes its final decision — a provisional win doesn't credit you back. ## Fees The **\$25 dispute fee** is charged as soon as a chargeback is filed, regardless of who eventually wins, and appears as a **Fee** transaction. The disputed amount is separate from that fee. It stays debited while the dispute is open, is credited back in full if you win, and stays debited if you lose. ## What you'll see A single chargeback can produce up to three transactions, each on its own line: * The **dispute fee**, when the chargeback opens. * The **disputed amount**, debited when the dispute is formally opened. * The **credit back**, if you win. Together with the original card payment, that gives your billing team the full history of a disputed payment without stitching statements together. ## Related * [How card payments show up](/docs/acquiring) * [Transaction types](/docs/guides/transactions#transaction-types) # How card payments show up Source: https://getlemma.com/docs/acquiring/index Understand how Lemma charges virtual cards from your lockbox and how the resulting transactions appear. Reach out to Lemma to get card acquiring enabled. Payers increasingly reimburse clinics by virtual card instead of check or ACH — a single-use card number printed on the remittance advice that you're expected to key into a terminal yourself. Lemma does that for you: we detect the card in your [lockbox](/docs/guides/lockbox) mail, charge it, and deposit the money into your account as itemized transactions. ## How a card payment happens A payer sends an explanation of benefits with a virtual card on it, or a standalone virtual card, to your lockbox address. We scan and classify every piece of lockbox mail. When a document carries a virtual card, we extract the card details and the amount to charge. We charge the card on your behalf. Nothing is required from you — there's no terminal to key the number into and no portal to log into. Once the payment settles, the funds are deposited into your account and the payment appears on your [Transactions page](https://app.getlemma.com/_/transactions). ## Tracking a card payment Each card payment carries a status you can follow from the mail item in your [lockbox](/docs/guides/lockbox): | Status | What it means | | -------------- | ------------------------------------------------------------------------------ | | **Processing** | The card has been charged and the payment is settling. | | **Deposited** | The funds have landed in your account. | | **Failed** | The card was declined and no money moved. | | **Refunded** | The payment was refunded back to the payer. | | **Chargeback** | The payer disputed the charge. See [Chargebacks](/docs/acquiring/chargebacks). | | **Canceled** | The charge was canceled before it went through. | ## Charge a card yourself Not every virtual card arrives by mail. When a payer gives you a card directly, in a payer portal, by fax, or over the phone, you can charge it yourself from [Move money > Charge a card](https://app.getlemma.com/_/move-money/charge-card). See [Charge a card](/docs/acquiring/charge-a-card) for requirements and steps. ## Payments and fees are separate transactions Every card payment produces two transactions: * **The card payment**, as an **Acquiring** transaction — the gross amount charged to the card. * **The processing fee**, as a **Fee** transaction — what it cost to process that payment. Splitting them is deliberate. A typical processor sends one lump-sum ACH every day or two and leaves your billing team to work out which payments and which fees it covers. Because Lemma is also your bank, we drop a labeled line item straight into the account for every economic event instead — so the reconciliation is already done when you open the page. Refunds and chargebacks follow the same rule: each gets its own transaction, and each carries its own fee. On the [Transactions page](https://app.getlemma.com/_/transactions), filter by the **Acquiring** type to see the payments you collected and by the **Fee** type to see what they cost. Combined with a date range, that makes month-end reconciliation of card revenue against processing fees straightforward. ## Next steps * Charge a card a payer gave you directly in [Charge a card](/docs/acquiring/charge-a-card). * Learn how disputes work in [Chargebacks](/docs/acquiring/chargebacks). * See how card payments arrive in [Lockbox](/docs/guides/lockbox). * Review the full list of [transaction types](/docs/guides/transactions#transaction-types). # Authentication Source: https://getlemma.com/docs/api-reference/authentication Integrate with the Lemma API as a platform and authenticate your requests. The Lemma API is currently in beta. If you're interested in integrating with Lemma as a platform, reach out to the Lemma team at [contact@getlemma.com](mailto:contact@getlemma.com) to get started. ## How it works The Lemma API is designed for **platform integrations**. As a platform, you integrate with Lemma directly and receive API keys from the Lemma team. Your customers — the businesses that hold Lemma accounts — then grant your platform permission to access their data through Lemma. Here's the flow: 1. You receive an API key from Lemma 2. Your customer logs in with their Lemma credentials and grants your platform permission to view their accounts 3. You use your API key to access the customer's data on their behalf ### Customer-granted permissions Your platform can only access data that the customer has explicitly authorized. When a customer grants access, they choose which accounts your platform can see. For sensitive actions like moving money, customers are required to limit the permission to specific accounts. This means: * If a customer creates a new account on their Lemma dashboard (e.g., a savings account), your platform will **not** automatically have access to it — the customer must explicitly grant access. * However, you **will** still see transactions on accounts you do have access to, including transfers made to or from accounts you cannot see. For example, if a customer moves money from an account you can access into a savings account you cannot, the outgoing transaction will still be visible. ## Getting an API key API keys are issued directly by the Lemma team as part of your platform onboarding. Contact [contact@getlemma.com](mailto:contact@getlemma.com) to begin the integration process. Store your API key securely. Do not share it or commit it to source control. If you believe a key has been compromised, contact the Lemma team immediately to revoke it and issue a new one. ## Using your API key Include the key in the `Authorization` header of every request using the `Bearer` scheme: ```bash theme={null} curl https://api.getlemma.com/v0/accounts \ -H "Authorization: Bearer your_api_key" ``` ## Rate limits The API allows up to **500 requests per minute** per API key. If you need higher limits, [contact us](mailto:contact@getlemma.com) and we're happy to increase them. See the [introduction](/docs/api-reference/introduction#rate-limits) for more details. ## Revoking a key If you need to revoke an API key, contact the Lemma team at [contact@getlemma.com](mailto:contact@getlemma.com). Revoked keys stop working immediately and any requests using that key will begin receiving `401` responses. # Create card Source: https://getlemma.com/docs/api-reference/create-card POST /v0/cards Issue a virtual debit card with custom spending limits. Issues a virtual debit card on a bank account, with the spending limits you specify. The card's `authorization_controls.usage.category` must be `multi_use`, and at least one limit is required. Every limit matching a payment is checked and the most restrictive one applies, so a payment is declined once it exceeds the per-transaction cap, or once the day's spend would pass the daily cap, even while the weekly and monthly caps still have room. Card payments will be rejected when there's insufficient balance on the bank account regardless of the limits you set. ## Headers A key that prevents issuing a duplicate card if the same request is retried. Reusing a key returns the originally created card instead of issuing a second one. See [Idempotency](/docs/api-reference/idempotency). ## Request body The bank account this card draws from. A human-readable label for this card. Between 1 and 50 characters. Controls that restrict how this card can be used. How many times this card can be used, and the controls for that usage. Whether the card is for a single use or multiple uses. The card can be used for multiple authorizations. The only category issuable today. Controls for multi-use cards. Required if and only if `category` is `multi_use`. The spending limits to enforce on this card. Must contain at least one limit and at most one limit per interval. Where several limits apply to a transaction, the most restrictive one wins. The window this limit is enforced over. Applies over the lifetime of the card. Applies to each individual transaction. Resets nightly at midnight UTC. Resets weekly on Mondays at midnight UTC. Resets on the first of the month at midnight UTC. The cap on settled spend in this window, in cents. Must be positive, and at least as large as the cap on every narrower interval — a wider window capped below a narrower one can never be reached, so it is rejected. ## Response Returns the created card object. Unique identifier for the card, prefixed with `card_`. [ISO 8601](/docs/api-reference/timestamps) timestamp of when the card was created. The ID of the entity that owns this card. The bank account this card draws from. The human-readable label for this card. The last 4 digits of the card number. The card's status. The card can be used for payments. The card is temporarily disabled. The card is permanently canceled. Every control restricting how this card can be used, including the ones Lemma applies to every card it issues. How many times this card can be used, and its controls. Whether the card is for a single use or multiple uses. The card can be used for multiple authorizations. The only category issuable today. Controls for multi-use cards. Every spending limit enforced on this card, including the ones Lemma applies automatically. The window this limit is enforced over. Applies over the lifetime of the card. Applies to each individual transaction. Resets nightly at midnight UTC. Resets weekly on Mondays at midnight UTC. Resets on the first of the month at midnight UTC. Cap in cents. Merchant category codes this limit applies to. `null` applies to all merchants. Restricts which Merchant Acceptor IDs this card may transact with. `null` when this dimension is unrestricted. The only Merchant Acceptor IDs this card may transact with. `null` when this dimension is not an allow list. Merchant Acceptor IDs this card may never transact with. `null` when this dimension is not a block list. Restricts which merchant categories this card may transact with, including the categories Lemma blocks on every card it issues. `null` when this dimension is unrestricted. The only merchant category codes this card may transact with. `null` when this dimension is not an allow list. Merchant category codes this card may never transact with. `null` when this dimension is not a block list. Restricts which merchant countries this card may transact with, as [ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2) codes. `null` when this dimension is unrestricted. The only merchant countries this card may transact with. `null` when this dimension is not an allow list. Merchant countries this card may never transact with. `null` when this dimension is not a block list. ```json 201 theme={null} { "id": "card_Bx5nTm8hKw3pVd7c", "created_at": "2026-07-28T18:45:00Z", "entity_id": "entity_k7mXp2vR9nTfBw4s", "bank_account_id": "account_maple_ridge_cigna_01", "nickname": "Acme ops card", "last_4": "4242", "status": "active", "authorization_controls": { "usage": { "category": "multi_use", "multi_use": { "spending_limits": [ { "interval": "per_transaction", "amount": 25000, "merchant_category_codes": null }, { "interval": "per_day", "amount": 100000, "merchant_category_codes": null }, { "interval": "per_day", "amount": 300000, "merchant_category_codes": ["6010", "6011"] } ] } }, "merchant_acceptor_identifier": null, "merchant_category_code": { "allowed": null, "blocked": ["7995", "6051"] }, "merchant_country": null } } ``` ```json 400 theme={null} { "statusCode": 400, "error": "Bad Request", "message": [ "authorization_controls.usage.multi_use.spending_limits amounts must not decrease as the interval widens (per_transaction, per_day, per_week, per_month, all_time)" ] } ``` # Create external account Source: https://getlemma.com/docs/api-reference/create-external-account POST /v0/external-accounts Save an external bank account as a recipient for outbound transfers. Creates a saved external account that can be used as a destination for [transfers](/docs/api-reference/move-money-externally). External accounts represent bank accounts outside of Lemma, such as a vendor, payroll provider, or another financial institution. External accounts cannot be edited after creation. If you need to change account details, archive the existing external account and create a new one. See [Saved recipients](/docs/api-reference/saved-recipients) for more on why. The `nickname` is visible to the account owner on their Lemma dashboard. Choose something descriptive and recognizable (e.g., "Owner's Personal Account" rather than "Acct 4821"). We recommend making nicknames unique within an entity. ## Headers A key that prevents creating a duplicate external account if the same request is retried. Reusing a key returns the originally created account instead of saving a second one. See [Idempotency](/docs/api-reference/idempotency). ## Request body The ID of the entity this recipient belongs to. A human-readable label for this recipient. Displayed on the Lemma dashboard and in transaction history. Whether the account holder is a business or an individual. One of `business` or `individual`. The 9-digit ABA routing number of the recipient's bank. The bank account number. Digits only. The legal name of the account holder. The account holder's mailing address. Must be a US address. Street address. Apartment, suite, or unit number. City name. Two-letter US state code. ZIP code. ISO 3166-1 alpha-2 country code. Must be `US`. ## Response Returns the created external account object. Unique identifier for the external account, prefixed with `external_account_`. The ID of the entity that owns this external account. The human-readable label for this external account. `business` or `individual`. The routing number of the account holder's bank. The external account's account number. The external account's status. Always `active` on creation. [ISO 8601](/docs/api-reference/timestamps) timestamp of when the external account was created. ```json 200 theme={null} { "id": "external_account_Bx5nTm8hKw3pVd7c", "entity_id": "entity_k7mXp2vR9nTfBw4s", "nickname": "Quest Diagnostics Operating Account", "routing_number": "021000021", "account_number": "123456789", "status": "active", "created_at": "2026-03-20T18:45:00Z" } ``` ```json 400 theme={null} { "error": "holder_address.line1 is required" } ``` # Delete a card Source: https://getlemma.com/docs/api-reference/delete-card DELETE /v0/cards/{card_id} Permanently cancel a card so it can no longer be used. Cancels a card so it can no longer be used for payments. Cancelling a card cannot be undone: if you only need to pause spending temporarily, freeze the card instead. You can only cancel cards issued by your platform. A card issued by the entity’s staff in the Lemma app returns a 404. ## Path parameters The card's unique identifier. ## Response Returns the canceled card object. Unique identifier for the card, prefixed with `card_`. [ISO 8601](/docs/api-reference/timestamps) timestamp of when the card was created. The ID of the entity that owns this card. The bank account this card draws from. The human-readable label for this card. The last 4 digits of the card number. The card's status. After a successful `DELETE` this is `canceled`. The card can be used for payments. The card is temporarily disabled. The card is permanently canceled. Every control restricting how this card can be used, including the ones Lemma applies to every card it issues. How many times this card can be used, and its controls. Whether the card is for a single use or multiple uses. The card can be used for multiple authorizations. The only category issuable today. Controls for multi-use cards. Every spending limit enforced on this card, including the ones Lemma applies automatically. The window this limit is enforced over. Applies over the lifetime of the card. Applies to each individual transaction. Resets nightly at midnight UTC. Resets weekly on Mondays at midnight UTC. Resets on the first of the month at midnight UTC. Cap in cents. Merchant category codes this limit applies to. `null` applies to all merchants. Restricts which Merchant Acceptor IDs this card may transact with. `null` when this dimension is unrestricted. The only Merchant Acceptor IDs this card may transact with. `null` when this dimension is not an allow list. Merchant Acceptor IDs this card may never transact with. `null` when this dimension is not a block list. Restricts which merchant categories this card may transact with, including the categories Lemma blocks on every card it issues. `null` when this dimension is unrestricted. The only merchant category codes this card may transact with. `null` when this dimension is not an allow list. Merchant category codes this card may never transact with. `null` when this dimension is not a block list. Restricts which merchant countries this card may transact with, as [ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2) codes. `null` when this dimension is unrestricted. The only merchant countries this card may transact with. `null` when this dimension is not an allow list. Merchant countries this card may never transact with. `null` when this dimension is not a block list. ```json 200 theme={null} { "id": "card_Bx5nTm8hKw3pVd7c", "created_at": "2026-07-28T18:45:00Z", "entity_id": "entity_k7mXp2vR9nTfBw4s", "bank_account_id": "account_maple_ridge_cigna_01", "nickname": "Acme ops card", "last_4": "4242", "status": "canceled", "authorization_controls": { "usage": { "category": "multi_use", "multi_use": { "spending_limits": [ { "interval": "per_transaction", "amount": 25000, "merchant_category_codes": null }, { "interval": "per_day", "amount": 100000, "merchant_category_codes": null } ] } }, "merchant_acceptor_identifier": null, "merchant_category_code": { "allowed": null, "blocked": ["7995", "6051"] }, "merchant_country": null } } ``` ```json 403 theme={null} { "statusCode": 403, "error": "Forbidden", "message": "Insufficient permissions to cancel cards for this entity" } ``` ```json 404 theme={null} { "statusCode": 404, "error": "Not Found", "message": "Card not found" } ``` # Entities Source: https://getlemma.com/docs/api-reference/entities Legal entities that hold accounts on Lemma. An entity is a healthcare practice or legal entity that holds accounts on Lemma. Every account, transfer, check, and external account in Lemma belongs to an entity. Entities are the top-level organizational unit in the API — most endpoints require an `entity_id` or are scoped to a single entity. The Lemma dashboard URLs include the entity ID (e.g. `app.getlemma.com/entity_abc123`). If you have dashboard access for an entity, paste their ID into the URL to jump straight to that entity. ## What Lemma tracks When an entity is onboarded, Lemma captures and verifies several pieces of information: * **Legal entity details** — the entity's legal name, structure (e.g., professional LLC, sole proprietorship), and state of incorporation. These determine which banking products the entity is eligible for. * **NPI number** — the entity's 10-digit [National Provider Identifier](https://www.cms.gov/medicare/enrollment-renewal/providers-suppliers/national-provider-identifier-standard), issued by CMS. Lemma uses the NPI to uniquely identify healthcare entities and to match incoming insurance payments to the correct account. * **KYC information** — Lemma collects Know Your Customer details (beneficial owners, EIN, address) as part of onboarding to satisfy regulatory requirements. This information is not exposed through the API. ## Legal structures Each entity has a `structure` field that reflects its legal entity type. Lemma supports: | Structure | Value | | ------------------------ | -------------------------- | | Corporation | `corporation` | | LLC | `llc` | | Nonprofit | `nonprofit` | | Partnership | `partnership` | | Professional association | `professional_association` | | Professional corporation | `professional_corporation` | | Professional LLC | `professional_llc` | | Sole proprietorship | `sole_prop` | ## Listing and finding entities The [List entities](/docs/api-reference/list-entities) endpoint returns all entities that have granted access to your platform. An entity can limit access to only certain bank accounts. To find a specific entity, pass the `npi` query parameter. NPI numbers are not guaranteed to be unique across entities — multiple legal entities can share the same NPI (e.g., when a group practice reorganizes or when separate entities bill under a shared organizational NPI), so the endpoint may return more than one result. ```bash theme={null} curl "https://api.getlemma.com/v0/entities?npi=1234567890" \ -H "Authorization: Bearer lm_key_your_api_key" ``` ## Lockbox address Every entity is assigned a lockbox mailing address. Payers send checks and correspondence to this address, and Lemma automatically scans and deposits them. Retrieve an entity's lockbox address with the [Get entity lockbox](/docs/api-reference/get-entity-lockbox) endpoint. # Get settlement instructions Source: https://getlemma.com/docs/api-reference/get-account-settlement-instructions GET /v0/accounts/{account_id}/settlement-instructions Download a bank account's settlement instructions as a PDF. Downloads a PDF containing the settlement instructions for a bank account: the account and routing numbers, beneficiary name and address, and the receiving bank's details. The response body is the raw file, not a JSON object. Share this PDF with a payer who needs to send funds to the account — for example, a payer setting up a wire or ACH credit. ## Path parameters The unique identifier of the bank account. ## Response Returns the file as `application/pdf`, downloaded with a `Content-Disposition: attachment` header. The filename is `{account_id}_settlement_instructions.pdf`. ```bash 200 theme={null} GET /v0/accounts/account_Rv4nBt8xKw2pMh6s/settlement-instructions Content-Type: application/pdf Content-Disposition: attachment; filename="account_Rv4nBt8xKw2pMh6s_settlement_instructions.pdf" Cache-Control: private, no-store ``` ```json 404 theme={null} { "statusCode": 404, "error": "Not found", "message": "Account not found" } ``` # Get ACH transfer Source: https://getlemma.com/docs/api-reference/get-ach-transfer GET /v0/ach-transfer/{ach_transfer_id} Retrieve a single ACH transfer by its ID. Returns a single ACH transfer object. ## Path parameters The unique identifier of the ACH transfer to retrieve. ## Response Unique identifier for the ACH transfer. The Lemma account the transfer moves money from or to. The [external account](/docs/api-reference/saved-recipients) on the other side of the transfer. The transfer amount in cents. A positive amount indicates a credit transfer pushing funds to the receiving account. A negative amount indicates a debit transfer pulling funds from the receiving account (an ACH pull). Current status of the ACH transfer. * `pending` — in flight. * `submitted` — sent to the ACH network. When the Federal Reserve settles the transfer, the status stays `submitted` and `settled_at` is populated. * `canceled` — we canceled the transfer after holding it for manual review. * `rejected` — the ACH network rejected the transfer. * `returned` — the transfer was returned. The statement descriptor shown to the counterparty. The settled transaction, once the transfer posts. [ISO 8601](/docs/api-reference/timestamps) timestamp of when the transfer settled. Submission details, once the transfer reaches the ACH network. [ISO 8601](/docs/api-reference/timestamps) timestamp of when the transfer was submitted to the ACH network. [ISO 8601](/docs/api-reference/timestamps) timestamp of when the funds are expected to settle. Return details, if the transfer was returned. The raw ACH return reason code. The transaction created when the transfer was returned. ```json 200 theme={null} { "id": "ach_transfer_Lk7nQx4mVp9bRt3d", "account_id": "account_Rv4nBt8xKw2pMh6s", "external_account_id": "external_account_Bx5nTm8hKw3pVd7c", "amount": -150000, "status": "submitted", "statement_descriptor": "Acme payroll", "transaction_id": null, "settled_at": null, "submission": { "submitted_at": "2026-03-15T14:30:00Z", "expected_funds_settlement_at": "2026-03-17T14:30:00Z" }, "return": null } ``` ```json 404 theme={null} { "statusCode": 404, "error": "Not Found", "message": "ACH transfer not found" } ``` # Get bank account Source: https://getlemma.com/docs/api-reference/get-bank-account GET /v0/accounts/{account_id} Retrieve a single bank account by its ID. Returns a single bank account. ## Path parameters The unique identifier of the bank account to retrieve. ## Response Unique identifier for the account, prefixed with `account_`. The ID of the entity that owns this account. The name of the account. The bank account number. The ABA routing number. The total balance of the account in cents, including funds that are not yet available. The balance available for use in cents. This excludes any held funds from pending transactions. The timestamp when the account was opened, in ISO 8601 format. ```json 200 theme={null} { "id": "account_Rv4nBt8xKw2pMh6s", "entity_id": "entity_k7mXp2vR9nTfBw4s", "name": "Operating Account", "account_number": "987654321", "routing_number": "101050001", "total_balance": 2450000, "available_balance": 2350000, "opened_at": "2026-01-15T09:30:00Z" } ``` ```json 404 theme={null} { "statusCode": 404, "error": "Not found", "message": "Account not found" } ``` # Get book transfer Source: https://getlemma.com/docs/api-reference/get-book-transfer GET /v0/book-transfer/{book_transfer_id} Retrieve a single book transfer by its ID. Returns a single book transfer object. ## Path parameters The unique identifier of the book transfer to retrieve. ## Response Unique identifier for the book transfer. [ISO 8601](/docs/api-reference/timestamps) timestamp of when the book transfer was created. The Lemma account money moves from. The Lemma account money moves to. The transfer amount in cents. Current status of the book transfer. * `complete` — settled. Most book transfers are complete the moment they're created. * `pending_approval` — held for manual review by our team for fraud prevention. * `canceled` — blocked after that manual review. Description of the transfer. The settled transaction on the source account, once the transfer posts. The settled transaction on the destination account, once the transfer posts. ```json 200 theme={null} { "id": "book_transfer_Hm3pWx9nKv4bQt7d", "created_at": "2026-03-15T14:30:00Z", "source_account_id": "account_Rv4nBt8xKw2pMh6s", "destination_account_id": "account_Tz8mKp3xLw5nVh9c", "amount": 250000, "status": "complete", "description": "Quarterly intercompany settlement", "source_transaction_id": "transaction_Wp5mRx3nKv8bTh2d", "destination_transaction_id": "transaction_Qk2nJx7mLv9bRt4c" } ``` ```json 404 theme={null} { "statusCode": 404, "error": "Not Found", "message": "Book transfer not found" } ``` # Get card Source: https://getlemma.com/docs/api-reference/get-card GET /v0/cards/{card_id} Retrieve a card and its spending limits. Returns a card, the spending limits set on it, and the merchants it may transact with. Only cards your platform issued over the API are visible here. A card issued by the entity's staff in the Lemma app returns a 404. ## Path parameters The card's unique identifier. ## Response Unique identifier for the card, prefixed with `card_`. [ISO 8601](/docs/api-reference/timestamps) timestamp of when the card was created. The ID of the entity that owns this card. The bank account this card draws from. The human-readable label for this card. The last 4 digits of the card number. The card's status. The card can be used for payments. The card is temporarily disabled. The card is permanently canceled. Every control restricting how this card can be used, including the ones Lemma applies to every card it issues. How many times this card can be used, and its controls. Whether the card is for a single use or multiple uses. The card can be used for multiple authorizations. The only category issuable today. Controls for multi-use cards. Every spending limit enforced on this card, including the ones Lemma applies automatically. The window this limit is enforced over. Applies over the lifetime of the card. Applies to each individual transaction. Resets nightly at midnight UTC. Resets weekly on Mondays at midnight UTC. Resets on the first of the month at midnight UTC. Cap in cents. Merchant category codes this limit applies to. `null` applies to all merchants. Restricts which Merchant Acceptor IDs this card may transact with. `null` when this dimension is unrestricted. The only Merchant Acceptor IDs this card may transact with. `null` when this dimension is not an allow list. Merchant Acceptor IDs this card may never transact with. `null` when this dimension is not a block list. Restricts which merchant categories this card may transact with, including the categories Lemma blocks on every card it issues. `null` when this dimension is unrestricted. The only merchant category codes this card may transact with. `null` when this dimension is not an allow list. Merchant category codes this card may never transact with. `null` when this dimension is not a block list. Restricts which merchant countries this card may transact with, as [ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2) codes. `null` when this dimension is unrestricted. The only merchant countries this card may transact with. `null` when this dimension is not an allow list. Merchant countries this card may never transact with. `null` when this dimension is not a block list. ```json 200 theme={null} { "id": "card_Bx5nTm8hKw3pVd7c", "created_at": "2026-07-28T18:45:00Z", "entity_id": "entity_k7mXp2vR9nTfBw4s", "bank_account_id": "account_maple_ridge_cigna_01", "nickname": "Acme ops card", "last_4": "4242", "status": "active", "authorization_controls": { "usage": { "category": "multi_use", "multi_use": { "spending_limits": [ { "interval": "per_transaction", "amount": 25000, "merchant_category_codes": null }, { "interval": "per_day", "amount": 100000, "merchant_category_codes": null }, { "interval": "per_day", "amount": 300000, "merchant_category_codes": ["6010", "6011"] } ] } }, "merchant_acceptor_identifier": null, "merchant_category_code": { "allowed": null, "blocked": ["7995", "6051"] }, "merchant_country": null } } ``` ```json 404 theme={null} { "statusCode": 404, "error": "Not found", "message": "Card not found" } ``` # Get a card iframe Source: https://getlemma.com/docs/api-reference/get-card-iframe GET /v0/cards/{card_id}/iframe Get a short-lived iframe URL for displaying a card's sensitive details. Returns a PCI-compliant URL that can be embedded in an `