# Intuit Enterprise Suite — Accounting API: gotchas

> Canonical URL: https://developers.apideck.com/apis/accounting/intuit-enterprise-suite/gotchas

## GET /accounting/tax-rates

In Intuit Enterprise Suite, the tax rates resource does not support pagination. Intuit Enterprise Suite uses the same underlying QuickBooks API: `effective_tax_rate` is populated (as the sum of the code's component rates) but `total_tax_rate` is **not** returned — key on `effective_tax_rate`, not `total_tax_rate`, when reading a single percentage. When `effective_tax_rate` is unavailable, use `code` to reference the tax in invoice line items.

## GET /accounting/tax-rates

Intuit Enterprise Suite uses the same underlying QuickBooks API. The `QueryResponse.totalCount` field in list responses reflects the per-page count only. `meta.total_count` will not appear. Surfacing the true total requires a separate `SELECT COUNT(*) FROM {Entity}` query — an extra API call that is not currently implemented.

## POST /accounting/tax-rates

To create a tax rate, `effective_tax_rate`, `tax_payable_account_id`, `name` and a `component` is required. If `tax_payable_account_id` is unknown, make a proxy call to get list of TaxAgency. [TaxAgency doc](https://developer.intuit.com/app/developer/qbo/docs/api/accounting/all-entities/taxagency#query-a-taxagency)

## GET /accounting/bills

On bill line items, Intuit Enterprise Suite returns `ClassRef.name` as the `FullyQualifiedName`
(e.g. `"Fruit:Apple"`) rather than the leaf class name. Apideck normalises this by
extracting the last `:` segment, so `tracking_categories[].name` returns `"Apple"` and
`parent_name` returns `"Fruit"`. Expense line items are unaffected — Intuit Enterprise Suite returns
only the short name there.

## GET /accounting/bills

Intuit Enterprise Suite uses the same underlying QuickBooks API. The `QueryResponse.totalCount` field in list responses reflects the per-page count only. `meta.total_count` will not appear. Surfacing the true total requires a separate `SELECT COUNT(*) FROM {Entity}` query — an extra API call that is not currently implemented.

## POST /accounting/bills

When creating a bill in Intuit Enterprise Suite, each line item must be accompanied by a type designation. If the type is set to "expense_item," an item ID is required. Conversely, if the type is "expense_account," a ledger account ID must be provided.

`reference` and `notes` both map to the single `PrivateNote` field — Intuit Enterprise Suite's one reference-number slot (`DocNumber`) is taken by `bill_number` on bills, so `reference` shares the memo instead. Only one of the two survives a write (the other is dropped with no error), and on read both are populated from `PrivateNote` and are always identical. Send only one. Which of the two wins on write is currently under review — do not rely on it.

`bill_number` maps to `DocNumber`, limited to 21 characters; a longer value is rejected with `400 ValidationFault` (code `6000`), so a 36-character UUID does not fit.

Additionally, multicurrency needs to be enabled in your Intuit Enterprise Suite account. If creating a bill in your default currency, you do not need to send the currency value as long as the supplier uses the same currency. For bills with suppliers using a different currency than your default, you must include the currency value, matching the supplier's configured currency. To change the currency of a customer or vendor, a new one must be created with the desired currency. Foreign currencies can only be sent to suppliers configured with that currency.

## GET /accounting/bills/{id}

On bill line items, Intuit Enterprise Suite returns `ClassRef.name` as the `FullyQualifiedName`
(e.g. `"Fruit:Apple"`) rather than the leaf class name. Apideck normalises this by
extracting the last `:` segment, so `tracking_categories[].name` returns `"Apple"` and
`parent_name` returns `"Fruit"`. Expense line items are unaffected — Intuit Enterprise Suite returns
only the short name there.

## PATCH /accounting/bills/{id}

Intuit Enterprise Suite requires the supplier.id to be sent in order to make update operations.
## POST /accounting/bills/batch

The whole request is one call to the provider, so it counts as **one request**
against your plan however many records it carries.

At most 20 bills per request. A request carrying more is rejected before any
record is written.

Response time scales with the number of records rather than being a fixed cost:
a full request of 20 takes roughly 27 seconds. Set client timeouts accordingly.

A request that times out may still have written some or all of its records. When
that happens no ids are returned for them, so treat a timed-out batch as uncertain
rather than failed: list the records to find what was written before retrying, or a
retry will duplicate them.

## GET /accounting/invoices

Intuit Enterprise Suite uses tax codes rather than tax rates. The `tax_rate` on line items references a tax code, which may not include the actual percentage value. To get the actual rate, retrieve the full tax rate details via the tax-rates endpoint.

## GET /accounting/invoices

Intuit Enterprise Suite uses the same underlying QuickBooks API. The `QueryResponse.totalCount` field in list responses reflects the per-page count only. `meta.total_count` will not appear. Surfacing the true total requires a separate `SELECT COUNT(*) FROM {Entity}` query — an extra API call that is not currently implemented.

## POST /accounting/invoices

Intuit Enterprise Suite offers limited (regional) support for applying discount on a Line Item. Including discount_percentage or discount_amount applies to entire invoice. The default type for a Line Item is a sales item if no type has been provided.
Send an `Idempotency-Key` to make retrying a create safe: it reaches Intuit Enterprise Suite as its `requestid`. Intuit Enterprise Suite keeps a `requestid` for at least 24 hours and can keep it longer, so after the 24-hour window a key reused for a different invoice may get the original invoice back, with the new body ignored. Use a new key for every invoice. Your key can be 1-255 characters: Unify sends Intuit Enterprise Suite a 32-character `requestid` derived from it, so Intuit Enterprise Suite's 50-character `requestid` limit never applies.

## PATCH /accounting/invoices/{id}

Intuit Enterprise Suite offers limited (regional) support for applying discount on a Line Item. Including discount_percentage or discount_amount applies to entire invoice. The default type for a Line Item is a sales item if no type has been provided. When setting status to `void`, do not include any other fields in the request body. Send an `Idempotency-Key` to make retrying an update (including a void) safe: it reaches Intuit Enterprise Suite as its `requestid`. Intuit Enterprise Suite keeps a `requestid` for at least 24 hours and can keep it longer, so after the 24-hour window a key reused for a different update may get the original update's result back, with the new body ignored. Use a new key for every update. Your key can be 1-255 characters: Unify sends Intuit Enterprise Suite a 32-character `requestid` derived from it, so Intuit Enterprise Suite's 50-character `requestid` limit never applies.

## PATCH /accounting/invoices/{id}

When setting tax rates on line items, Intuit Enterprise Suite requires valid tax codes. The `tax_rate.id` must reference an existing tax code from the tax-rates endpoint. Intuit Enterprise Suite automatically calculates tax amounts based on the tax code's rate.

## POST /accounting/invoices/batch

The whole request is one call to the provider, so it counts as **one request**
against your plan however many records it carries.

At most 20 invoices per request. A request carrying more is rejected before any
invoice is created.

Response time scales with the number of records rather than being a fixed cost:
a full request of 20 takes roughly 27 seconds. Set client timeouts accordingly.

A request that times out may still have created some or all of its invoices. When
that happens no ids are returned for them, so treat a timed-out batch as uncertain
rather than failed: list invoices to find what was written before retrying, or a
retry will duplicate them.

## GET /accounting/ledger-accounts

Intuit Enterprise Suite uses the same underlying QuickBooks API. The `QueryResponse.totalCount` field in list responses reflects the per-page count only. `meta.total_count` will not appear. Surfacing the true total requires a separate `SELECT COUNT(*) FROM {Entity}` query — an extra API call that is not currently implemented.

## DELETE /accounting/ledger-accounts/{id}

This connector does not support deleting ledger accounts. Instead, it will update the ledger account to inactive.

## POST /accounting/ledger-accounts/batch

Records are written one at a time, so the request counts as **one request per
record** against your plan — batching saves you round trips, not quota.

Records are written one at a time rather than in a single batched call, so that a
Intuit Enterprise Suite plan usage-limit error is reported on the account it applies to. A request
of N records therefore takes about N times as long as a single write: a full request
of 10 takes about 16 seconds.

At most 10 records per request.

Each record succeeds or fails on its own; read the per-item `status` to see which
were written. If the request times out, the items it could not confirm come back
with `status: uncertain` rather than `failed` — some of them may well have been
written, and no ids are returned for those. Verify before retrying an `uncertain`
item: list the resource to find what exists, or a retry will duplicate it.

Results come back in the order the items were sent. Supply `_ref` on every item if
you need to tie an outcome back to your own record — it is echoed on every result,
including failures, and is never sent to the connector.

## GET /accounting/invoice-items

Intuit Enterprise Suite uses the same underlying QuickBooks API. `meta.total_count` will not appear. Surfacing the true total requires a separate `SELECT COUNT(*) FROM {Entity}` query — an extra API call that is not currently implemented.

## POST /accounting/invoice-items

The `taxable` field is applicable to US companies only and should be sent in the request body if your Intuit Enterprise Suite account is in the US region.

## PATCH /accounting/invoice-items/{id}

The `taxable` field is applicable to US companies only and should be sent in the request body if your Intuit Enterprise Suite account is in the US region.

## GET /accounting/credit-notes

Intuit Enterprise Suite uses the same underlying QuickBooks API. The `QueryResponse.totalCount` field in list responses reflects the per-page count only. `meta.total_count` will not appear. Surfacing the true total requires a separate `SELECT COUNT(*) FROM {Entity}` query — an extra API call that is not currently implemented.

`filter[updated_since]` and `filter[created_since]` are exclusive (`>`) and `Metadata.LastUpdatedTime` / `Metadata.CreateTime` have second granularity, so a record whose timestamp equals the cursor to the exact second is skipped. For incremental sync, set the cursor one second behind the highest `updated_at` seen in the previous run and de-duplicate by `id`.

## POST /accounting/credit-notes/batch

The whole request is one call to the provider, so it counts as **one request**
against your plan however many records it carries.

At most 20 credit notes per request. A request carrying more is rejected before any
record is written.

Response time scales with the number of records rather than being a fixed cost:
a full request of 20 takes roughly 27 seconds. Set client timeouts accordingly.

A request that times out may still have written some or all of its records. When
that happens no ids are returned for them, so treat a timed-out batch as uncertain
rather than failed: list the records to find what was written before retrying, or a
retry will duplicate them.

## POST /accounting/bill-credit-notes

Vendor credits have no draft/posted lifecycle: `status` is derived from the unapplied balance and is only ever `posted` (fully unapplied), `partially_paid`, or `paid` (fully applied), and `balance`/`remaining_credit` both report the unapplied amount.
Set tax with `line_items[].tax_rate.code`; the top-level `tax_code` is not honoured on automated-tax companies (e.g. UK), where tax is computed from the line rates.
`total_amount` is derived from the line items, so the value read back can differ from the one sent (a tax-exclusive line adds tax on top of the supplied amount).

## POST /accounting/bill-credit-notes/batch

The whole request is one call to the provider, so it counts as **one request**
against your plan however many records it carries.

At most 20 bill credit notes per request. A request carrying more is rejected before any
record is written.

Response time scales with the number of records rather than being a fixed cost:
a full request of 20 takes roughly 27 seconds. Set client timeouts accordingly.

A request that times out may still have written some or all of its records. When
that happens no ids are returned for them, so treat a timed-out batch as uncertain
rather than failed: list the records to find what was written before retrying, or a
retry will duplicate them.

## GET /accounting/customers

Intuit Enterprise Suite uses the same underlying QuickBooks API. The `QueryResponse.totalCount` field in list responses reflects the per-page count only. `meta.total_count` will not appear. Surfacing the true total requires a separate `SELECT COUNT(*) FROM {Entity}` query — an extra API call that is not currently implemented.

## GET /accounting/customers

`balance` reflects only the customer's own outstanding balance — it excludes the balances
of any sub-customers or jobs, which are returned as separate customer records linked
through `parent.id`. The value is denominated in the customer's own `currency`, which may
differ from the company's home currency. It can be negative when the customer holds
unapplied credits or overpayments.

## POST /accounting/customers

Intuit Enterprise Suite supports only billing and shipping addresses. Therefore, when creating addresses, it is required to specify the type as 'billing' or 'shipping' in the address object within the addresses array.
## PATCH /accounting/customers/{id}

Intuit Enterprise Suite supports only billing and shipping addresses. Therefore, when creating or updating addresses, it is required to specify the type as 'billing' or 'shipping' in the address object within the addresses array.
## POST /accounting/customers/batch

The whole request is one call to the provider, so it counts as **one request**
against your plan however many records it carries.

At most 20 customers per request. A request carrying more is rejected before any
record is written.

Response time scales with the number of records rather than being a fixed cost,
so set client timeouts for the size of request you send.

A request that times out may still have written some or all of its records. When
that happens no ids are returned for them, so treat a timed-out batch as uncertain
rather than failed: list the records to find what was written before retrying, or a
retry will duplicate them.

## GET /accounting/suppliers

Intuit Enterprise Suite uses the same underlying QuickBooks API. The `QueryResponse.totalCount` field in list responses reflects the per-page count only. `meta.total_count` will not appear. Surfacing the true total requires a separate `SELECT COUNT(*) FROM {Entity}` query — an extra API call that is not currently implemented.

## POST /accounting/suppliers

Intuit Enterprise Suite only supports a single billing address. Therefore, the first item in the addresses array will always be mapped as the billing address, regardless of its original type.
## PATCH /accounting/suppliers/{id}

Intuit Enterprise Suite only supports a single billing address. Therefore, the first item in the addresses array will always be mapped as the billing address, regardless of its original type.
## POST /accounting/suppliers/batch

The whole request is one call to the provider, so it counts as **one request**
against your plan however many records it carries.

At most 20 suppliers per request. A request carrying more is rejected before any
record is written.

Response time scales with the number of records rather than being a fixed cost,
so set client timeouts for the size of request you send.

A request that times out may still have written some or all of its records. When
that happens no ids are returned for them, so treat a timed-out batch as uncertain
rather than failed: list the records to find what was written before retrying, or a
retry will duplicate them.

## GET /accounting/payments

Intuit Enterprise Suite uses the same underlying QuickBooks API. The `QueryResponse.totalCount` field in list responses reflects the per-page count only. `meta.total_count` will not appear. Surfacing the true total requires a separate `SELECT COUNT(*) FROM {Entity}` query — an extra API call that is not currently implemented.

## POST /accounting/payments

Payment allocations in Intuit Enterprise Suite are processed asynchronously. While the allocations are included in the request, they may not appear in the immediate response. The allocations will be applied and become visible in subsequent list or get calls.

## PATCH /accounting/payments/{id}

To clear the payment method on an existing payment, send `payment_method_id: null` explicitly
in the PATCH body. Omitting the field preserves the existing payment method (sparse update
semantics). Sending `null` triggers `PaymentMethodRef: { value: null }` in the Intuit Enterprise Suite
sparse POST, which removes the payment method reference from the payment.

## POST /accounting/payments/batch

The whole request is one call to the provider, so it counts as **one request**
against your plan however many records it carries.

At most 20 payments per request. A request carrying more is rejected before any
record is written.

Response time scales with the number of records rather than being a fixed cost:
a full request of 20 takes roughly 27 seconds. Set client timeouts accordingly.

A request that times out may still have written some or all of its records. When
that happens no ids are returned for them, so treat a timed-out batch as uncertain
rather than failed: list the records to find what was written before retrying, or a
retry will duplicate them.

## GET /accounting/refunds

tax_inclusive only applies to UK, AU, IN, and CA editions. US companies ignore this field silently.

## POST /accounting/refunds

tax_inclusive only applies to UK, AU, IN, and CA editions. US companies ignore this field silently. payment_method_id is required to set the payment method. Provide the ID of a payment method record configured in Intuit Enterprise Suite. total_amount is required on each line item. If not provided, it is computed from quantity * unit_price. tracking_categories behavior depends on company settings. "One to entire transaction" uses top-level tracking_categories. "One to each row" requires tracking_categories on each line item.

## GET /accounting/refunds/{id}

tax_inclusive only applies to UK, AU, IN, and CA editions. US companies will not have this field in responses. payment_method returns the name of the payment method record, not the payment type category.

## PATCH /accounting/refunds/{id}

row_version is required for updates. tracking_categories behavior depends on company settings. "One to each row" requires tracking_categories on each line item.

## GET /accounting/balance-sheet

When using start and end date filters, Intuit Enterprise Suite requires both to be sent. However, the report only reflects the balance sheet situation as of the end date.
## GET /accounting/journal-entries

Intuit Enterprise Suite only returns journal entries that were explicitly created as `JournalEntry` records.
System-generated GL postings from invoices, bills, payments, deposits, transfers, and other
transaction types post to the general ledger but are not exposed by Intuit Enterprise Suite as journal entries
and will not appear in this response. To reconstruct full GL activity, fetch the underlying
transaction resources (invoices, bills, payments, etc.) in addition to journal entries.

Look up a specific journal entry by its number with `filter[number]` (for example
`?filter[number]=JE-0001`). The number is limited to 21 characters.

## GET /accounting/journal-entries

Intuit Enterprise Suite uses the same underlying QuickBooks API. The `QueryResponse.totalCount` field in list responses reflects the per-page count only. `meta.total_count` will not appear. Surfacing the true total requires a separate `SELECT COUNT(*) FROM {Entity}` query — an extra API call that is not currently implemented.

## POST /accounting/journal-entries

Intuit Enterprise Suite only supports one tracking category at a time so only the first item in the tracking_categories list will be used.
Line-level tax fields (tax_rate, tax_amount, tax_type) on journal entries are only supported for non-US Intuit Enterprise Suite companies (UK, CA, AU, etc.). US-based Intuit Enterprise Suite companies silently discard all tax fields — the request succeeds but no tax data is persisted.
For US companies that need to reflect tax in journal entries, add a separate line item posting the tax amount to a tax liability ledger account (e.g., "Sales Tax Payable"). This keeps the journal entry balanced in the general ledger, but will not populate Intuit Enterprise Suite Sales Tax reports — for that, use invoices or sales receipts instead.
When line_items[].tax_type is not set, Intuit Enterprise Suite requires knowing whether the tax applies to a sales or purchase transaction. Unify infers this from line_items[].type: credit lines are treated as sales (TaxApplicableOn: Sales) and debit lines as purchases (TaxApplicableOn: Purchase). This covers the common case of sales summary journal entries. For atypical entries (e.g. a credit to an AP account, or a debit for a sales return), set tax_type explicitly on each line to override the default.
When a line item has `tax_rate` but no `tax_amount`, Unify calculates `tax_amount` as the line's `total_amount` multiplied by the tax rate's percentage, rounded to the cent. For tax rates made up of several components (for example Québec GST + QST), send the combined tax for the line in `tax_amount`, or omit it; Unify splits the line's tax across the components.
Creating a journal entry with a `number` that already exists is accepted and produces a second, separate entry — the number is not enforced as unique. Use a unique `number`, and if a create's result never arrives (a timeout or a 5xx), look the entry up with `filter[number]` before retrying so you do not create a duplicate.
Send an `Idempotency-Key` to make retrying a create safe: it reaches Intuit Enterprise Suite as its `requestid`. Intuit Enterprise Suite keeps a `requestid` for at least 24 hours and can keep it longer, so after the 24-hour window a key reused for a different journal entry may get the original journal entry back, with the new body ignored. Use a new key for every journal entry. Your key can be 1-255 characters: Unify sends Intuit Enterprise Suite a 32-character `requestid` derived from it, so Intuit Enterprise Suite's 50-character `requestid` limit never applies.

## PATCH /accounting/journal-entries/{id}

Intuit Enterprise Suite only supports one tracking category at a time so only the first item in the tracking_categories list will be used.
When line_items[].tax_type is not set, Intuit Enterprise Suite requires knowing whether the tax applies to a sales or purchase transaction. Unify infers this from line_items[].type: credit lines are treated as sales (TaxApplicableOn: Sales) and debit lines as purchases (TaxApplicableOn: Purchase). This covers the common case of sales summary journal entries. For atypical entries (e.g. a credit to an AP account, or a debit for a sales return), set tax_type explicitly on each line to override the default.

## POST /accounting/journal-entries/batch

The whole request is one call to the provider, so it counts as **one request**
against your plan however many records it carries.

At most 20 journal entries per request. A request carrying more is rejected before any
record is written.

Response time scales with the number of records rather than being a fixed cost,
so set client timeouts for the size of request you send.

A request that times out may still have written some or all of its records. When
that happens no ids are returned for them, so treat a timed-out batch as uncertain
rather than failed: list the records to find what was written before retrying, or a
retry will duplicate them.

## POST /accounting/sales-receipts

tax_inclusive only applies to UK, AU, IN, and CA editions. US companies ignore this field
silently.

payment_method_id is required to set the payment method. Provide the ID of a payment
method record configured in Intuit Enterprise Suite.

total_amount is required on each line item. If not provided, it is computed from
quantity * unit_price.

tracking_categories behavior depends on company settings. "One to entire transaction"
uses top-level tracking_categories. "One to each row" requires tracking_categories on
each line item.

The deposit destination is controlled via account. Omit account to deposit to
Undeposited Funds (Intuit Enterprise Suite's default).

Tax handling depends on the company's country edition. US companies with Automated Sales
Tax calculate tax automatically by location: a submitted tax_code or total_tax overrides
the automatic calculation, so omit both to accept it. Line item tax_rate values must be
the pseudo-codes TAX or NON for US companies (other values are rejected with a validation
error).

Non-US editions require real Intuit Enterprise Suite tax code IDs for tax_rate instead of the US
pseudo-codes, and total_tax is recalculated from the line tax codes and cannot be
overridden.

With multicurrency enabled, currency must match the customer's currency, and
currency_rate is required when it differs from the company's home currency.

## PATCH /accounting/sales-receipts/{id}

row_version submitted in the request body is ignored. The connector always fetches the
latest version immediately before writing, so there is no optimistic-concurrency
protection — concurrent updates are last-write-wins.

tax_inclusive only applies to UK, AU, IN, and CA editions. US companies ignore this field
silently.

payment_method_id is required to set the payment method. Provide the ID of a payment
method record configured in Intuit Enterprise Suite.

total_amount is required on each line item. If not provided, it is computed from
quantity * unit_price.

tracking_categories behavior depends on company settings. "One to each row" requires
tracking_categories on each line item.

The deposit destination is controlled via account. Omit account to deposit to
Undeposited Funds (Intuit Enterprise Suite's default).

Tax handling depends on the company's country edition. US companies with Automated Sales
Tax calculate tax automatically by location: a submitted tax_code or total_tax overrides
the automatic calculation, so omit both to accept it. Line item tax_rate values must be
the pseudo-codes TAX or NON for US companies (other values are rejected with a validation
error).

Non-US editions require real Intuit Enterprise Suite tax code IDs for tax_rate instead of the US
pseudo-codes, and total_tax is recalculated from the line tax codes and cannot be
overridden.

With multicurrency enabled, currency must match the customer's currency, and
currency_rate is required when it differs from the company's home currency.

## GET /accounting/purchase-orders

Intuit Enterprise Suite uses the same underlying QuickBooks API. The `QueryResponse.totalCount` field in list responses reflects the per-page count only. `meta.total_count` will not appear. Surfacing the true total requires a separate `SELECT COUNT(*) FROM {Entity}` query — an extra API call that is not currently implemented.

## GET /accounting/locations

Intuit Enterprise Suite uses the same underlying QuickBooks API. `meta.total_count` will not appear. Surfacing the true total requires a separate `SELECT COUNT(*) FROM {Entity}` query — an extra API call that is not currently implemented.

## GET /accounting/departments

Intuit Enterprise Suite uses the same underlying QuickBooks API. `meta.total_count` will not appear. Surfacing the true total requires a separate `SELECT COUNT(*) FROM {Entity}` query — an extra API call that is not currently implemented.

## GET /accounting/attachments/{reference_type}/{reference_id}

Intuit Enterprise Suite uses the same underlying QuickBooks API. `meta.total_count` will not appear. Surfacing the true total requires a separate `SELECT COUNT(*) FROM {Entity}` query — an extra API call that is not currently implemented.

## POST /accounting/attachments/{reference_type}/{reference_id}

Intuit Enterprise Suite limits attachment uploads to 100MB.
## GET /accounting/trial-balance

Built from the `TrialBalance` report. It reports income and expense accounts for the report period only, so Apideck sets the period start to the first day of the fiscal year that contains `end_date` (from the company's fiscal year start month, one extra CompanyInfo call); balance sheet accounts are cumulative to `end_date`. `end_date` defaults to today (UTC). Accounts with a zero balance are left out, so a company with no data returns an empty list. `account_id` is the QuickBooks account id, the id ledger accounts use; a balance the report shows without an account id is returned with `line_type` `unmapped` and no `account_id`. Account numbers are not in the report, so `code` is not returned. Amounts are in the company's home currency. A report whose debits and credits do not balance returns a `502`. The company is the connection's.
## GET /accounting/tracking-categories

Intuit Enterprise Suite uses the same underlying QuickBooks API. `meta.total_count` will not appear. Surfacing the true total requires a separate `SELECT COUNT(*) FROM {Entity}` query — an extra API call that is not currently implemented.

## POST /accounting/tracking-categories/batch

The whole request is one call to the provider, so it counts as **one request**
against your plan however many records it carries.

At most 20 tracking categories per request. A request carrying more is rejected before any
record is written.

Response time scales with the number of records rather than being a fixed cost,
so set client timeouts for the size of request you send.

A request that times out may still have written some or all of its records. When
that happens no ids are returned for them, so treat a timed-out batch as uncertain
rather than failed: list the records to find what was written before retrying, or a
retry will duplicate them.

## GET /accounting/bill-payments

Intuit Enterprise Suite uses the same underlying QuickBooks API. The `QueryResponse.totalCount` field in list responses reflects the per-page count only. `meta.total_count` will not appear. Surfacing the true total requires a separate `SELECT COUNT(*) FROM {Entity}` query — an extra API call that is not currently implemented.

## POST /accounting/bill-payments

Payment method is required and must be `Check` or `CreditCard`.

## POST /accounting/bill-payments/batch

The whole request is one call to the provider, so it counts as **one request**
against your plan however many records it carries.

At most 20 bill payments per request. A request carrying more is rejected before any
record is written.

Response time scales with the number of records rather than being a fixed cost:
a full request of 20 takes roughly 27 seconds. Set client timeouts accordingly.

A request that times out may still have written some or all of its records. When
that happens no ids are returned for them, so treat a timed-out batch as uncertain
rather than failed: list the records to find what was written before retrying, or a
retry will duplicate them.

## GET /accounting/expenses

Intuit Enterprise Suite uses the same underlying QuickBooks API. The `QueryResponse.totalCount` field in list responses reflects the per-page count only. `meta.total_count` will not appear. Surfacing the true total requires a separate `SELECT COUNT(*) FROM {Entity}` query — an extra API call that is not currently implemented.

## POST /accounting/expenses

The top-level `account` must be a bank or credit-card account — the payment source the money left from — not an expense account; the expense account goes on `line_items[].account`. Sending an expense account at the top level fails with `400 "Invalid account type used"` (code `6430`), an error that names neither the field nor the type it expected.

`reference` and `memo` both map to the single `PrivateNote` field: only one survives a write (the other is dropped with no error), and on read both are populated from it and are always identical. Send only one. Which of the two wins on write is currently under review — do not rely on it.

## GET /accounting/categories

Intuit Enterprise Suite uses the same underlying QuickBooks API. `meta.total_count` will not appear. Surfacing the true total requires a separate `SELECT COUNT(*) FROM {Entity}` query — an extra API call that is not currently implemented.

## GET /accounting/quotes

Intuit Enterprise Suite uses the same underlying QuickBooks API. The `QueryResponse.totalCount` field in list responses reflects the per-page count only. `meta.total_count` will not appear. Surfacing the true total requires a separate `SELECT COUNT(*) FROM {Entity}` query — an extra API call that is not currently implemented.

## GET /accounting/projects

The `priority` field is mapped from Intuit Enterprise Suite integer values (0-9) to unified enum values using ranges: 0-2 → "low", 3-5 → "medium", 6-7 → "high", 8-9 → "critical".

## POST /accounting/projects

The `priority` field accepts enum values ("low", "medium", "high", "critical") which are converted to Intuit Enterprise Suite integer values: "low" → 2, "medium" → 5, "high" → 7, "critical" → 9.

## GET /accounting/projects/{id}

The `priority` field is mapped from Intuit Enterprise Suite integer values (0-9) to unified enum values using ranges: 0-2 → "low", 3-5 → "medium", 6-7 → "high", 8-9 → "critical".

## PATCH /accounting/projects/{id}

The `priority` field accepts enum values ("low", "medium", "high", "critical") which are converted to Intuit Enterprise Suite integer values: "low" → 2, "medium" → 5, "high" → 7, "critical" → 9.


[API reference](https://developers.apideck.com/apis/accounting/reference.md) · [Coverage matrix](https://developers.apideck.com/apis/accounting/coverage)