Returns metadata about the authenticated API key, the user it belongs to, the account it is scoped to, the key-level permissions, and (for regular user keys) the user's account_user role flags and accessible pipeline IDs. Useful for agents and integrations to introspect their own capabilities before making other calls. account is the account this request acted in (the one named by X-Account-Id, or the key's default account); token.cross_account says whether this is a user key that can act in any of its user's accounts, and token.default_account_id is the account it acts in when no header is sent. Legacy API keys are rejected with a 403.

Returns every account the key's user is a member of, with the roles the user holds in each, except accounts whose admins have blocked the user's keys from other accounts (the key's own default account is always listed). A user API key acts in its default account (the one it was created in) unless a request sends the X-Account-Id header; the id of any row here is a valid value for that header. The list is the same whichever account the request runs in. A key that stays in one account (issued through "Sign in with Hub", or carrying a privileged permission) ignores the header and is listed only that account.

Admin-only. Returns the Decile Hub accounts the calling admin user can reach — accounts that have opted in to decile-admin access plus any account the admin is directly a member of. Results are sorted by name and capped at 100 rows; pass search to filter by name or subdomain when the admin has access to many accounts. Non-admin keys receive 403. Requires X-Account-Id header set to any account this admin can access; the response then enumerates the full set including that seed account.

The Decile agreements you can review, the full text of one agreement (the first unless template names another) with its sample questions, and your current conversation on it: up to the last 10 questions, oldest first, with their answers. Available to Decile staff and members of the account; others get 404.

Reads the text of your own PDF or DOCX (up to 20 MB and 200,000 characters of text). Nothing is stored: pass the returned upload_text and upload_filename to ask_agreement_review_question. Scanned or password-protected files cannot be read.

Your earlier questions on the agreement leave the conversation get_agreement_review shows. It does not change your hourly question limit.

Asks about a Decile agreement (template_slug) or your own uploaded document (upload_text and upload_filename from upload_agreement_for_review), optionally about one passage (selected_text). The answer is written in the background: the question comes back with status pending (202); poll get_agreement_review_question until it is answered or failed. Each question counts toward your hourly limit; over it the call answers 429.

One of your questions: status pending, answered or failed; the answer in markdown when answered; and whether a failed question can be retried.

Asks a failed question again (up to 3 tries in all). For a question about an uploaded document, send its text again in upload_text. Counts toward your hourly limit; poll get_agreement_review_question for the answer.

Returns the current account's basic information

Returns the AccountUsers belonging to the authenticated API key's account.
Use to discover the assigned_id value for PATCH /api/v1/pipeline_prospects and
PATCH /api/v1/pipeline_prospects/{id} (the prospect-owner field).

id is the membership id. user_id is the user id — the value POST /api/v1/tasks
expects as assignee_id.

is_you marks the row for whoever this call is being made on behalf of, so
"assign it to me" needs no name-guessing. At most one row has it. When every
row is false the caller could not be identified (an unattended run, for
example) — ask who is meant rather than picking the likeliest person.

Pagination is zero-indexed; page size is 100.

Changes a teammate's title or permissions, as the Team page does. Only
the fields given change. Turning on admin turns on every permission.
The account owner's permissions, the caller's own admin, and the other
permissions of an admin cannot be changed; to take Admin away, send
admin: false alone first. title must be one of the account's
titles; an empty string clears it. Account admins only.

Removes a teammate from the account, as the Team page does. They lose
access to the account; this cannot be undone. The caller cannot remove
themselves. Account admins only.

Returns the pending teammate invitations on the account, as the Team
page shows them. delivery_status other than sent means the email was
not delivered. Account admins only.

Invites someone to join the account, as the Team page's Invite Teammate
form does, and emails them the invitation. They join with the given
permissions when they accept. Permissions not given are off; admin
gives every permission. Account admins only.

Revokes a pending invitation, as the Team page does. The link in the
invitation email stops working. Account admins only.

Returns the activity feed for the current account, newest first. Filter by
subject (entity), event type, actor, date range, or form.

Pagination is keyset — pass pagination.next_page_token from a response back
as page_token= to fetch the next page.

Returns one activity entry plus the full per-type entryable body —
audit change diffs, full email bodies and recipients, note bodies,
AML/KYC status, chat summaries, and so on. The list endpoint omits this detail.

Returns a paginated list of the firm-admin entities (funds, SPVs,
holdings, management companies, general partnerships) under the
authenticated API key's account. Identity-only payload — fund-specific
configuration (cutover dates, GP carry %, logo URL) is returned by
GET /api/v1/entities/{id} instead.

Pagination is 1-indexed (page 1 is the first page). per_page is
capped at 100; values <= 0 fall back to the default of 50.

Creates a new AccountOrganization plus a fresh Organization and (for
fund kinds) a FundDetail under the authenticated account.

Onboarding side effects are suppressed for API-created entities —
no LP closing pipeline is generated, no AccountOrganizationUser is
attached for the account owner, and no Accelerator client_product
touch fires. Callers that want the full onboarding workflow should
continue to use the firm-admin UI.

POST is not idempotent. To retry safely, GET /api/v1/entities and
check whether the desired entity already exists before retrying.

Requires a caller who is a full_access_account_admin? of the target account.

Returns identity + a details block for one entity. The details
block always includes currency, currency_symbol, fiscal_year_end,
entity_name, logo_url, is_active, and kind. When the entity is a fund
(kind=fund, spv, or holding) the details block additionally
includes gp_carry, new_management_fee_system_cutover_date, and
new_carry_system_cutover_date. For non-fund entities those keys are
omitted entirely.

For funds, details.minimum_investment is the LP minimum the GP
configured (null when none is set; Hub's own type floor is never
reported here). Hub's floors depend on fund type: a fund's PACT
amounts and LPA minimum can't be set below $25K, an SPV's below $10K.
The hard minimum, $10K for a fund and $1K for an SPV, is the lowest
commitment an LP can enter (through a custom PACT link, or on the LPA
when the fund sets no minimum). Only a Decile admin can set an LPA
minimum below $25K or $10K, never below the hard minimum; a fund
manager can't lower either floor.

details.gp_commit is the fund's GP commitment term from its fund
settings: percentage (of total fund size), floor and ceiling, plus
Hub's target and the GP commitment already recorded on GP capital
accounts. For "what should my GP commitment be", quote target: LP
commitments / (1 - percentage) x percentage, rounded, raised to
floor and capped at ceiling (a floor with no percentage is a flat
amount). When percentage and floor are both null, Hub doesn't
record the term: say so and ask for the LPA's GP commitment
percentage, never assume one. target and recorded are null on an
SPV. details.management_fee states the fund's fee terms
(frequency plus a tiers array) only when its single active
schedule can be stated without losing anything; otherwise it is null
and details.management_fee_unavailable_reason says why. Treat a null
management_fee as "not stated", never as "no fee": a fee that exists
but cannot be stated here (several schedules, conditions such as a fee
holiday, per-class rates, flat or one-time charges, date bands, an
amended or ended schedule, an unresolved rate) must not be inferred or filled in from elsewhere.

Pass ?include=team to embed a team array of the people the account
shows on its team page, in page order (name, title, position,
gp_signatory). Funds only; non-fund entities get an empty array.

Pass ?include=calculations to embed a calculations block of
fund-level dashboard values. ?window=now (default) returns
as-of-today values and includes capital_activity.invested plus
fees.reserved_for_fees; ?window=lifetime returns forecast values
and omits those two fields entirely. calculations is only supported
on fund-kind entities (kind=fund, spv, or holding); requesting
it on a non-fund entity returns 404. Numeric values serialize as
2-decimal-place decimal strings (currency) or 4-decimal-place
decimal strings (ratios such as performance.net_irr); investor
counts are integers.

calculations.performance holds the fund's own ratios to date, the
figures its Dashboard and Performance page show, LPs only. Only account
admins can read them: for anyone else restricted is true and every
figure is null. A null ratio means unavailable, never zero. Relay
warnings and the valuation fields with the ratios, since they qualify
them. When valuation_status is not_tracked the fund has no fund-level
valuation date, which does not mean it has no approved valuations.

ALWAYS branch on calculations.available rather than assuming the
figure groups are present. It is false, with reason and message
and no figure groups, for SPV entities whose computed fund-level figures
do not reconcile with their actual deal economics; those entities return
200, not 404. No computed fund-level figure is reported for such an
entity, and none may be estimated or reconstructed from other endpoints
and presented as one. The details block is unaffected by this
suppression and still carries that entity's own configured values,
including target_fund_size, gp_carry, fund_life_years and
first_close_date — those are reported inputs, not computed figures, so
they may be quoted as what they are (a target, a rate, a date) and must
never be presented as this entity's ACTUAL capital, performance or fee
figures. Every entity of kind=spv is suppressed — both legacy SPVs and
Start SPVs — so a kind=spv entity never carries computed fund-level
figures. Still branch on the flag rather than on kind; the flag is the
contract.

Fee semantics, read fees.note and fees.basis in the response before
answering any fee question. Nothing in the fees group is cash: no
value there is money disbursed to the GP. fees.basis gives each
field's recognition basis SEPARATELY (it is an object, not one label),
and ONLY fields marked accrued_to_date are expense already incurred;
forecast_lifetime, next_12_months_fee_reserve and
projected_lifetime_other_fees are forward-looking projections or
reserves and must never be described as fees charged, recognized, or
owed. On a start fund with window=now, management_fees and
admin_fees are lifetime forecasts while other_fees is to date, and
fees.basis.total_fees is then mixed. No outstanding or unpaid fee
balance can be derived from the fees group; it is in
details.management_fee_position instead.
fees.reserved_for_fees is a forward-looking reserve, never an amount
owed or unpaid, and is excluded from fees.total_fees;
fees.basis.reserved_for_fees says what it measures for this fund
(next 12 months of fees on a standard fund, a projected lifetime
other-fees figure on a start fund).
fees.total_fees covers management plus admin plus other fees, so a
management-fee-only figure must be compared against
fees.management_fees, not against fees.total_fees.

details.management_fee_position holds the fund's management-fee
ledger balances today, the figures its Fee Summary page shows, plus a
note to read and relay with them (account
admins only, as that page is: for anyone else restricted is true and
every figure is null; null on an SPV). payable_balance is Management
Fees Payable (GL 2205, under Liabilities on the Balance Sheet): fees
booked and owed to the management company and not yet paid, so,
unless conflicted is true, it is what is still available to move. Posted or booked means owed, not
paid. prepaid_balance (GL 1609) is fees drawn ahead of accrual, that
is overdrawn: Hub books a fee wire larger than the payable as prepaid,
not as a negative payable, and later quarters' fees pay it down. net
is payable_balance less prepaid_balance; when it is negative the
fee is overdrawn by that amount. fees_accrued_to_date is GL 6000
Management Fees, every fee booked since inception; 0 means no
management fee has been recorded in Hub: say that plainly, with the
payable. conflicted is true when the fund holds both a prepaid and a
payable balance, which the Fee Summary flags as an earlier entry that
needs correcting: the figures don't tie out, so say so, give no amount
to move (not the payable, not net), and refer it to Fund Accounting
(offer a Decile support ticket). When asked how much fee is left to
move or what is payable, give the figures and say what they mean, even
when every one is 0: a positive payable is still to move, a prepaid or
a negative net means the fee is overdrawn, and posted means booked
and owed, not paid. These are current inception-to-date balances, not
per-quarter figures, so for "this quarter" quote the current balance
and say what it covers. Quote only these returned figures, never one
derived from fees, and link the fund's Fee Summary page
(find_hub_page with this entity_id), which also shows Fees Drawn
to ManCo ITD and Fees Still to Draw.

calculations.investable_capital with window=now is what the fund
can invest today, the Back Office dashboard's figure. On a standard
fund it is contributed capital from admitted LPs, less capital
invested and investment wires pending position review, less fees to
date, less fees.reserved_for_fees (the next 12 months of fees, at
least $10,000). A start fund deducts its lifetime management and admin
fees instead of that reserve. With window=lifetime it is total
commitments less lifetime fees, so it assumes every commitment is
called. Explain why it is below fund size with these terms and the
returned figures.

Returns 404 (not 403) when the id refers to an entity in a different
account.

Updates writable fields on an existing entity within the authenticated
account. All fields optional — only sent fields are applied.

kind is immutable. Sending a matching kind is a no-op; sending a
differing kind returns 422.

Renaming guard: if the entity's Organization is shared with sibling
AccountOrganization rows (an edge case for entities created before this
endpoint existed, or via paths that don't use the API's two-step create),
PATCH refuses with 409 organization_shared_with_siblings and includes
the sibling entity ids in error.details.sibling_entity_ids so callers
can fall back to the firm-admin UI.

Additional rename guard at the model level:
Organization#prevent_name_change_if_accounting_transactions_exist
returns 422 if the Organization has associated accounting transactions.

PATCH is_active=false is the v1 stopgap for hiding an entity, since
DELETE is not yet supported.

Requires a caller who is a full_access_account_admin? of the target account.

Returns the same canonical Schedule of Investments calculations used by
Hub's CSV, XLSX, PDF, and UI reporting as machine-readable JSON. The
response groups positions by portfolio company and includes position
marks, security and funding-round details, valuation provenance,
company subtotals, and report-wide totals.

This is a synchronous, read-only reconciliation endpoint. Use
generate_financial_report when a downloadable report file is needed.
Pagination applies to company groups; metadata and grand totals always
describe the complete report.

Fund-level capital figures for one entity, summed across its capital
accounts. Returns NO per-capital-account rows and NO performance ratios.

nav is the sum of ending balances across the entity's capital
accounts, i.e. the fund's partners' capital (assets less liabilities).
ending_capital_balance carries the identical figure under the other
name. Quote either verbatim.

partner_type is REQUIRED and has no default: limited_partner,
general_partner, or all. An unfiltered blend of GP and LP capital
overstates the LP figure, so the caller must say which one it wants.
LP-only and GP-only NAV are both meaningful and both supported.

capital_accounts_counted vs capital_accounts_in_entity tells you
whether these totals span the whole fund. Fund-wide amounts (unrealized
and realized gain, fees) are allocated to each capital account by its
commitment share, so a filtered set carries only that set's slice. When
the two counts differ, say so rather than presenting a subset as the
fund total.

IRR, TVPI, DPI, RVPI and MOIC are deliberately absent here. Never
compute them from these figures. The fund's own net IRR, TVPI, DPI and
RVPI to date come only from get_entity with include=calculations, in
its admin-only calculations.performance block. That block's
funded_nav deducts unpaid partner debits, so it can differ from nav
here. MOIC is not available from any agent-reachable endpoint.

Identity-plus-commitments list. Each row is the shared identity
block plus committed_capital — the account's commitment tranches
summed as a decimal string ("0.0" when it has none). Other
per-account calculation values (contributions, balances) are
intentionally NOT included here — they come from the per-record
/calculations endpoint and the bulk
/entities/{entity_id}/capital_accounts/calculations endpoint.
The response's top-level total_committed_capital_all_matches
sums commitment tranches across EVERY account matching the
current filters (not just the page), so commitment totals are
answerable without paging. "All matches" means every page of results for the filters you passed; it includes disabled accounts only when you passed active=false or active=all.

Optional filters: fuzzy q (LP name, fund entity name, or primary
contact email), partner_type, boolean flags
(kyc_passed/aml_passed/transferred), an admitted_on window
(admitted_after/admitted_before), and a total-commitment range
(min_total_commitment/max_total_commitment). Sort with
sort_by/sort_order (default: ascending id).

Each row's lpa_closing_state is the LPA state the fund's Closing
Summary shows for that LP: signed (a recorded signature or an
admitted LP, while lpa_signed is true only for a recorded
signature), not_started (not signed yet:
the LPA may not have been sent, or the LP has it and hasn't signed),
or generation_failed. generation_failed means Hub could not
generate the LP's LPA from the fund's agreement, so the LP has nothing
to sign. Always point the manager to the fund's Closing Summary, where
that LP's Status reads Needs attention and its LPA reads Generation
failed. It is a document problem, not something the LP did, so never tell the
manager to nudge or remind the LP. Say what it means and offer to file
a Decile support ticket (create_support_ticket): only Decile can fix
the agreement, and Hub asks the manager to contact Decile before
resetting the LP's onboarding link. To check an LP stuck
on Sign LPA, pass active=all (and q with the LP's name when given).

Returns 404 when entity_id resolves to an entity in a different
account (cross-account requests are not distinguished from missing).

Identity block + commitments + primary_contact + contacts + entity
ref. contacts is the full list of contacts on the capital account
(joint signatories, spouses, trustees, entity owners/signatories,
trust beneficiaries); each entry carries role flags plus
contact_status_type (none/primary/additional). Returns 404
when the capital account belongs to a different account. Use
?include=transfers to embed an ordered list of capital-account
transfers oriented at the requested CA (kind=outbound when the
requested CA is the from_capital_account, inbound otherwise);
effective_at is aliased from the underlying transferred_at
column. Use ?include=investor_profile for the profile captured at
subscription (legal name, addresses, citizenship, formation). This is
where an investor's address lives: address on a Person is the
directory record and is usually blank for LPs. It never carries tax
ids or birth dates, and is 403 for a caller who is not an account
admin.

Computes a single capital account's period figures. Response groups:

- commitments — 12 commitment + paid-in fields.
- period_activity — 15 ledger movements within the window.
- performance — dpi, rvpi, tvpi.
- meta — period_start, period_end, currency,
management_fee_system, carry_system, ownership_basis,
cutover_dates. The
*_system keys are legacy (window ends before the cutover),
new (window starts on/after the cutover), or hybrid (window
straddles the cutover).

All numeric values are returned as decimal strings (currency 2
decimal places, ratios 4 decimal places). Nil values are returned
as null. Returning decimal strings is intentional so callers
don't lose precision via JS number parsing.

Period semantics: pass both period_start and period_end (ISO
YYYY-MM-DD). Both are required together — supplying one without
the other returns a 400. period_end must be on or after
period_start. When neither is supplied, the window defaults to
the current fiscal-year-to-date for the parent entity.

In a hybrid window the API uses the new-system carry calculation
directly even for GP-carry capital accounts, which can differ from
calculating each side of the cutover separately. Request explicit
pre/post cutover windows if you need each side calculated on its own.

Returns side_letter — the LP's live (not withdrawn) side letter, or
null when they have none — together with standard_terms, the fund
terms a letter may undercut.

standard_terms.fee_bands is the read to make BEFORE
start_side_letter: its position values are the keys of that
operation's fee_rates, and fund_rate_percent is the ceiling for
each band (a negotiated rate above the fund's own is refused). A
management_fee_schedule of null means the fund has no active
tiered schedule, so it cannot offer fee terms at all.

All percentages are decimal strings ("1.5" is 1.5%, not 150%).
stage tracks progress through signing: awaiting_lp,
awaiting_countersignature, awaiting_approval, executed,
withdrawn. Returns 404 when the capital account belongs to a
different account, or to a management company or general partnership
rather than a fund.

Requires an account admin of the fund's account (or a permitted Decile
admin) and the side letters feature enabled for the account; otherwise
403. Side letters are offered on SPVs (an SPV or a Start SPV) only for
now: this read answers for any fund, but start_side_letter refuses an
LP of a traditional fund, a Start Fund or a fund of funds.

Offers this LP a side letter: records the negotiated carry, writes the
negotiated fee bands as an own-rate management fee schedule assigned to
them, opens their side letter questionnaire with the terms prefilled,
and adds the row to their onboarding checklist. Set carry_percentage,
fee_rates, or both.

carry_percentage is a percent string ("15" is 15%) at or below
standard_terms.carry_percentage from get_side_letter. It is booked
on the fund's carry schedule as this LP's promote override once legal
ops execute the letter, so the fund needs a standard carry and an
active carry schedule before a carry term is accepted.

fee_rates is keyed by the position values of
standard_terms.fee_bands from get_side_letter, whose
fund_rate_percent is each band's ceiling. Values are percent
strings ("1.5" is 1.5%). Bands left out keep the fund rate. Read
get_side_letter first: the positions and ceilings are fund state
and cannot be guessed.

send_email defaults to FALSE, so the letter waits on the LP's
onboarding checklist and no mail goes out. Pass true only when the
LP is meant to receive the signing link now — that email cannot be
unsent.

Returns 422 when the LP has withdrawn or is withdrawing from the fund,
when the LP already has a live side letter, when neither a carry nor a
band rate was set, when a rate is above the fund's own, when the fund
has no active tiered fee schedule, no standard carry or no active
carry schedule for the term offered, or when send_email is true and
the LP has no contact email.
Side letters are offered on SPVs (an SPV or a Start SPV) only for now.
An LP of a traditional fund, a Start Fund or a fund of funds gets 403:
tell the user side letters are not available for that fund yet, not
that they lack permission.

Takes the offer back before legal ops approve it: the questionnaire
link stops resolving, the onboarding checklist row goes, and the LP
returns to the fund's standard fee terms. The cancelled record stays
for the audit trail and does not block a fresh offer.

Returns 422 for a letter legal ops already approved — an executed
side letter is a signed agreement and cannot be withdrawn through the
API. Returns 404 when the LP has no live side letter. Like the other
side letter operations, it is refused with 403 while the side letters
feature is not enabled for the account.

Adds a Person in this account as a contact on the capital account, as
the Hub capital account Contacts tab does: joint signatories, spouses,
trustees, trust beneficiaries, entity owners and signatories, or plain
CC contacts.

contact_status_type sets the mailing role: primary (the one primary
contact; the previous primary becomes additional), additional
(CC'd) or none (not contacted). Left out, the contact is primary
when the account has none yet, otherwise additional. The is_*
flags set the legal role; is_primary_individual and is_spouse are
each allowed on one contact per account and never together. Adding a
signer, owner, trustee or beneficiary who has not been verified can
reopen the LP's KYC check.

Returns the new contact and the account's full contacts list,
since the write can change another contact's contact_status_type.
Requires an account admin of the fund's account (or a permitted Decile
admin); otherwise 403.

Changes the fields given and leaves the rest. id is a
contacts[].id from the capital account read, not a person id. The
person cannot be changed: remove the contact and add the other person.
contact_status_type: primary demotes the previous primary to
additional. A blank title clears it. Returns the contact and the
account's full contacts list.

Takes the contact off the capital account; the Person record is kept.
Removing the primary contact promotes the next additional contact to
primary. Returns the remaining contacts.

Returns commitment_increase: where this LP stands on increasing their
commitment, as the fund manager's capital account slideover shows it.

state is available (the LP could be asked now), underway (an
increase is mid-signature) or blocked (a check fails). can_request
is true only when the state is available AND the caller may request
(a read-only key never may).
reasons says why not in plain English; checks lists every fund and
LP gate with passed, label, detail and scope (fund or
capital_account). current_commitment is the LP's commitment today
(decimal string), increase_bounds the min and max the increase
must fall within (whole currency units), and latest_increase the
newest increase response (amounts, signatories, signatures_outstanding,
complete) or null when the LP never started one.

Read this before request_commitment_increase. A GP commitment reads
as blocked (not_gp fails) rather than 403, so the caller learns why.
Returns 404 when the capital account belongs to a different account, or
to a management company or general partnership rather than a fund.

Requires an account admin of the fund's account (or a permitted Decile
admin) and the commitment increase requests feature enabled for the
account; otherwise 403.

Asks this LP to increase their commitment, as the Hub "Request increase"
button does: opens the fund's commitment increase questionnaire for the
LP with the amounts prefilled and EMAILS the LP a link to it at once,
with replies going to the caller. The email cannot be unsent, so confirm
the LP, the amount and the note with the user first.

increase_amount is a whole number of the fund's currency, added to
the current commitment; it must fall within the increase_bounds that
get_commitment_increase reports (5,000 to 10,000,000). message is
an optional personal note of at most 2000 characters, shown in the
email above the link.

Offered only to an LP who could start the increase themselves. Returns
422 when a check fails (details names them), when an increase is
already in progress, when the LP has no email, when the fund has no
commitment increase questionnaire, or when the amount is out of bounds.
400 for an amount that is not a whole number, an over-long message or
an unknown field. 403 for a GP commitment, a caller who is not an
account admin, a read-only token, or the feature off for the account.

Returns 201 with the same commitment_increase payload as the read,
now with state underway and latest_increase set.

Lists every limited partner of the fund with where each stands on a
commitment increase, as the Investor Agreements "Request commitment
increase" picker lists them. GP capital accounts are never listed.

The fund's own gates come first: fund_enabled false means no LP can
be asked right now, fund_checks says which gate fails, and
capital_accounts is empty with total 0. Otherwise each row carries
state (available / underway / blocked), reasons in the
picker's words, committed_capital (decimal string), email,
admitted_on and latest_increase. Use it to find who can be asked,
then get_commitment_increase or request_commitment_increase on one
LP.

Paginated in name order (page, per_page max 100). Returns 404 for
an entity outside the account, or one that is not a fund. Requires an
account admin of the fund's account (or a permitted Decile admin) and
the commitment increase requests feature enabled for the account;
otherwise 403.

Returns lp_withdrawal: where this LP stands on withdrawing from their
fund (an admitted LP who has not contributed capital leaving the fund
and giving up their whole commitment), as the fund manager's capital
account slideover shows it.

state is available (a withdrawal can be started now), disabled
(a start check fails, such as capital already received from the LP or
a commitment increase in progress), in_progress (a withdrawal is
under way) or ineligible (a fund or LP check fails, such as an LP
who is not admitted or has already withdrawn). can_start is true only
when the state is available AND the caller may start one (a read-only
key never may). reasons says why not in plain English; checks lists
every gate with passed, label, detail and scope (fund,
capital_account or start).

current_commitment is what the LP gives up (decimal string),
signing_contacts who signs for the LP and is emailed the agreement,
and signs_for_fund_on_start whether a saved signature signs for the
fund the moment a withdrawal starts (so starting emails the LP at once)
or the fund manager signs first at withdrawal.sign_url. withdrawal
is the open withdrawal, else the newest one, else null.

Read this before start_lp_withdrawal, send_lp_withdrawal or
void_lp_withdrawal. Returns 404 when the capital account belongs to a
different account, or to a management company or general partnership
rather than a fund. Requires an account admin of the fund's account (or
a permitted Decile admin); otherwise 403.

Starts withdrawing this LP, as the Hub "Withdraw LP" button does: the
LP gives up their whole commitment. Opens the fund's LP withdrawal
agreement with the fund manager and the LP's signing contacts as
signers.

When a saved signature signs for the fund (signs_for_fund_on_start
on the read), the agreement is signed for the fund and EMAILED to the
LP's signing contacts at once, and that email cannot be unsent.
Otherwise the fund manager signs at withdrawal.sign_url first and it
goes to the LP as soon as they do. Confirm the LP, their commitment and
the signers with the user first. Once the LP signs, Legal Ops and then
Accounting approve the withdrawal in the Hub.

Takes no fields (the agent runtime's idempotency_key aside, which
replays the first response for a repeated key). Returns 422 when the LP cannot be withdrawn (a check
fails, capital was received from the LP, a commitment increase or a
withdrawal is already in progress, no signing contact has an email, or
nobody can sign for the fund); 400 for any body field. 403 for a caller
who is not an account admin or a read-only token.

Returns 201 with the same lp_withdrawal payload as the read, now with
state in_progress and withdrawal set, and next_step saying what
happens next in words.

Voids this LP's withdrawal in progress, as the Hub "Void" button does:
the LP stays in the fund and the agreement can no longer be signed or
approved. The withdrawal itself is always kept, marked voided with the
reason. Its agreement (the questionnaire response) is kept too once it
was sent to the LP or signed by anyone; an agreement that never left
the fund manager is deleted. A new withdrawal can be started afterwards. Cannot be undone, so
confirm with the user first.

reason is required and recorded on the withdrawal. Returns 404 when
the LP has no withdrawal in progress, 422 once an LP signatory has
signed (withdrawal.can_void on the read is false), 400 for a missing
or over-long reason or an unknown field (idempotency_key is accepted).

Returns 200 with the lp_withdrawal payload, withdrawal.status
voided.

Sends this LP's withdrawal agreement to the LP, as the Hub "Send to LP"
button does: EMAILS each LP signatory who has not signed a signing
link, and the email cannot be unsent. Only for a withdrawal the fund
manager has signed that has not gone out yet (withdrawal.can_send on
the read): after the fund manager signed at the sign URL, after an
earlier send failed, or after a reviewer requested changes.

Takes no fields (the agent runtime's idempotency_key aside). Returns
404 when the LP has no withdrawal in progress;
422 when it was already sent, the fund manager has not signed, or the
email could not be delivered.

Returns 200 with the lp_withdrawal payload and sent_to, the emails
the request went to.

Lists every limited partner of the fund with where each stands on a
withdrawal, as the Investor Agreements "Withdraw LP" picker sees them.
GP capital accounts are never listed.

The fund's own gates come first: fund_enabled false means no LP can
be withdrawn right now, fund_checks says which gate fails, and
capital_accounts is empty with total 0. Otherwise each row carries
state (available / disabled / in_progress / ineligible, as on
get_lp_withdrawal), reasons, committed_capital (decimal string),
email, admitted_on, withdrawn_on and open_withdrawal. Use it to
find who can be withdrawn, then get_lp_withdrawal or
start_lp_withdrawal on one LP.

Paginated in name order (page, per_page max 100). Returns 404 for
an entity outside the account, or one that is not a fund. Requires an
account admin of the fund's account (or a permitted Decile admin);
otherwise 403.

Each LP's Schedule K-1 status for one tax year, as Hub records it.
k1_status is one of:
- notified: the K-1 is in the LP's folder in Files and the K-1
Ready email went out, at notification_sent_at.
- uploaded: the K-1 is in the LP's folder in Files; the LP has not
been emailed yet.
- no_k1_record: Hub has no K-1 record for that year: none came in
through the K-1 import. A K-1 put straight into the LP's Tax folder
in Files has no record, so say Hub has no K-1 recorded, never that
none exists. Hub can't see folder contents: never say the folder
is empty or that nothing was uploaded.
Hub stores nothing else: no hold, exclusion or IRS filing status, so
never state one.

Two modes:
- With entity_id (one fund, SPV or holding entity, a
list_entities row of kind fund, spv or holding): every LP on it.
The roster is every enabled capital account, plus a disabled one
that has a K-1 for the year, in name order. totals
(capital_accounts, notified, uploaded, no_k1_record) always count
that whole roster, whatever lp_query, capital_account_id,
k1_status or the page; coverage says how the returned rows
relate to them.
- Without entity_id: search all your funds, SPVs and holdings at
once for the LPs matching lp_query (or capital_account_id). Use
it whenever the user names an LP but not a fund. entities lists
each entity with a matching LP and those LPs' rows; coverage says
how many entities were searched, how many were skipped for access,
and whether the rows were truncated at row_cap. Say an LP has
no K-1 only when nothing was skipped or truncated.

tax_year defaults to each entity's latest year with a K-1
(tax_year_source says which). Account admins only (a member who is
not an admin gets 403). With entity_id, 404 for an entity outside
the account, or one that is not a fund, SPV or holding.

Paginated bulk variant of the single-CA calculations endpoint.
Each row in capital_accounts is the same shape as the single-CA
response (commitments/period_activity/performance/meta groups) but
with id+name pulled out of identity for easier table rendering.
Adds a fund-level totals block aggregated across the filtered
scope (NOT only the current page).

Totals semantics:
- Currency fields are summed across the filtered scope.
- Per-CA ratio fields (percentage_of_total_commitments,
percentage_of_lp_commitments, percentage_of_funds_called,
amount_paid_in_for_capital_accounts_percentage) are null in
totals — per-account ratios do not sum into a fund-level figure.
- Performance ratios (dpi, rvpi, tvpi) are null in totals
for the same reason.
- total_committed_capital, lp_committed_capital,
gp_committed_capital are fund-wide regardless of filters — the
per-row total_committed_capital denominator is a fund-level
value, not "total of the filtered list." These fund-wide fields
count commitment tranches whose capital account had a signed LPA
(timestamped by period_end, or carrying the Cornerstone signed flag
when no timestamp exists) or was enabled and admitted by period_end;
PACT-only and unconfirmed prospects remain available as separate rows
with active=all.

Keep fundraising stages separate. From /pipelines?kind=investor, collect
every row whose entity_id exactly matches the requested entity, then
pass each matching row's id as /pacts pipeline_id with
signed_before=period_end; an entity can have multiple investor
pipelines. Each total_pledged_amount_reportable is the gross reportable soft-
commitment total for one pipeline and must not be added to committed
capital. Reporting status alone does not remove PACT signers who later
signed an LPA or were admitted, so an outstanding non-binding PACT total
requires fetching every PACT page for every matching pipeline, retaining
only ignore_for_reporting=false rows, combining them, and calling the capital-account show
endpoint, and reconciling PACT person_id values against contact
person_id values before excluding overlaps. A null PACT person_id
cannot be reconciled deterministically from these APIs; resolve it
manually or report that an exact outstanding total is unavailable.
To split binding capital into signed-not-closed and closed/admitted,
fetch every page of /entities/{entity_id}/capital_accounts?active=all
for identity and every page of this calculation endpoint with
active=all for period-bounded amounts, then join by capital-account
id. Do not use the identity-list row's all-time committed_capital
for a historical window. Define signed_by_period as
lp_signature_at <= period_end, plus undated rows where lpa_signed
is true; define admitted_by_period as admitted_on <= period_end.
Binding rows satisfy signed_by_period OR (enabled AND admitted_by_period).
Split those rows into closed/admitted when admitted_by_period is true
and signed-not-closed otherwise; a currently disabled but signed/admitted
account remains in the closed bucket. Sum the joined calculation row's committed_capital for
each category, and use the complete identity set when reconciling PACT
overlaps. Capital currently
available to deploy comes from /entities/{entity_id}?include=calculations&window=now
as calculations.investable_capital; do not derive it by applying a
fixed percentage to committed capital. Branch on calculations.available
there: on an SPV it is false and investable_capital is absent
entirely, so no SPV has a computed fund-level investable-capital figure —
say so rather than falling back to a percentage of committed capital or
any other derived estimate. This holds for every kind=spv entity, both
legacy SPVs and Start SPVs; still read the flag rather than inferring the
outcome from the entity's kind.

Period and decimal-string semantics are identical to the single-CA
endpoint.

fields= projection: comma-separated whitelist of calculation
field names. When supplied, rows AND totals are narrowed to just
the requested fields. If zero requested fields fall within a
group, that entire group key is dropped from both rows and totals.
id and name are always present on each row. Unknown field
names are silently dropped.

Read-only discovery of imported bank transactions. The privacy-safe
response omits sensitive provider metadata, account and routing data,
external identifiers, GL preassignments, counterparties, and
supersession identifiers. Discarded records are excluded. This endpoint
cannot create, import, sync, update, reconcile, discard, or delete data.
Unknown and cross-account entity ids both return 404.

Read-only lookup using the same privacy-safe allowlist as the list
endpoint. Sensitive provider metadata, bank identifiers, and internal
matching fields are omitted. This endpoint performs no writes, imports,
synchronization, reconciliation, updates, discards, or deletion.
Unknown, discarded, and cross-account ids all return 404.

Returns the journal entries (general-ledger / accounting transactions —
double-entry GL postings) recorded under the given entity. Each row
carries the transaction date/amount, reconciled/pending flags, comment,
the debit and credit ledger accounts (code + name), and the polymorphic
counterparty (type, id, name; null when absent). Discarded entries are
excluded.

Filters (all optional): a transaction_at window via
transaction_at_start/transaction_at_end; debit_code/credit_code
(GL account codes — an unknown code returns no rows); reconciled and
pending (true/false); min_amount/max_amount; and
counterparty_type (+ optional counterparty_id).

Returns 404 when entity_id resolves to an entity in a different
account (cross-account requests are not distinguished from missing).

Creates a single journal entry (general-ledger / accounting transaction —
a double-entry GL posting) under the given entity. Posts one debit/credit
pair for the supplied amount and date. The entry is created unreconciled
(reconciled false, pending false). debit_code and credit_code are
GL account codes (see the chart-of-accounts endpoint) — they must differ
and both must resolve to a known accounting account. amount must be
numeric and greater than 0. transaction_at is an ISO date (YYYY-MM-DD).
An optional counterparty can be attached via counterparty_type +
counterparty_id; the counterparty must belong to the same account.

Returns 422 on invalid input (unknown code, equal debit/credit codes,
non-positive or non-numeric amount, malformed date, or a cross-account
counterparty), 403 for a read-only key, and 404 when entity_id
resolves to an entity in a different account.

Creates many journal entries (general-ledger / accounting transactions —
double-entry GL postings) under the given entity in a single atomic,
all-or-nothing batch. Each row in journal_entries is a full independent
entry validated by the same rules as the single-create endpoint:
debit_code and credit_code are GL account codes (see the
chart-of-accounts endpoint) that must differ and both resolve to a known
account, amount is numeric and greater than 0, transaction_at is an
ISO date (YYYY-MM-DD), and an optional counterparty may be attached via
counterparty_type + counterparty_id (same account).

Provide between 1 and 100 rows. EVERY row is validated first; if ANY row
is invalid the entire batch is rejected with 422 and a per-row errors
array ({index, field, message}) and NOTHING is created. When all rows
are valid they are created together inside one database transaction; any
unexpected failure rolls the whole batch back (never a partial commit).
All entries are created unreconciled (reconciled false, pending
false). Idempotency is the caller's responsibility — re-sending a batch
posts it again.

Returns 422 on validation failure or an out-of-range batch (empty or more
than 100 rows), 403 for a read-only key, and 404 when entity_id
resolves to an entity in a different account.

Returns a single journal entry (general-ledger / accounting transaction —
a double-entry GL posting): transaction date/amount, reconciled/pending
flags, comment, the debit and credit ledger accounts (code + name), and
the polymorphic counterparty (type, id, name; null when absent). Returns
404 when the entry is unknown, discarded, or belongs to a different
account (cross-account requests are not distinguished from missing).

Lists the Venture Partner Agreements (VPAs: grants of GP Class A units
from the Share Pool to a Venture Partner, with vesting and a Section
83(b) election) of the fund's general partner, newest first, as
Stakeholder Agreements in the Hub shows them, and says whether a new
one can be started. entity_id may be the fund or the GP itself.

state is available (a VPA can be started now), needs_setup (an
entity detail the Hub asks for first is missing, or no fund manager
has a saved signature to countersign with), disabled (a start check
fails, such as no first close yet or no units left in the Share Pool)
or unavailable (VPAs are not offered for this fund). checks lists
every gate with scope availability, start or setup; reasons
is the failing ones in plain English. Setup is fixed in the Hub at
hub_url. role_options are the role keys
create_venture_partner_agreement takes.

status filters the list to one or more statuses, comma-separated.
Requires an account admin of the account (or a permitted Decile admin)
with Venture Partner Agreements enabled for the account; otherwise
403. Returns 404 for an entity that is neither a fund nor a GP.

Starts a Venture Partner Agreement for the fund's GP as a draft, as
the Hub "Generate agreement" button does. Nothing is emailed: the
agreement waits for fund manager review (status generated) until
send_venture_partner_agreement, and void_venture_partner_agreement
discards it. It adds the Venture Partner to the GP cap table and
generates the agreement with the fund manager's saved signature as
countersigner.

When a Person in the account already has this email, that Person is
reused and RENAMED to the name given here (an omitted middle name is
cleared), and their AML screening is flagged for a re-check. Voiding
the draft does not undo the rename, so confirm the name and email with
the user first.

units must fit the Share Pool (pool.available on the list),
vesting_years is 2, 3 or 4 (default 4), cliff_months 0, 3, 6 or 12
(default 12), price_per_share defaults to 0.0001 and roles takes at
least one key from role_options.

Returns 201 with the agreement (a preview of its terms, including
venture_partner.limited_partner, which the Hub warns about without
blocking) and next_step. 422 with details when the Hub would
refuse it (setup missing, no saved signature, too many units, a VPA
already in progress for this person, an unknown role); 400 for a
missing or malformed field.

Returns one Venture Partner Agreement with its stage, terms, dates and
what the caller can do next (can_send, can_remind, can_void),
plus the countersigner, reminders sent, the Venture Partner's
signing_url while it is sent, and hub_url. 404 for an agreement in
another account.

Voids the agreement, as the Hub "Void" button does: it can no longer
be signed or approved, and a cap table seat or capital account created
for it is released. The agreement is kept, marked voided with the
reason. Cannot be undone, so confirm with the user first.

reason is required and recorded on the agreement. 422 once executed
or already ended (can_void false); 400 for a missing or over-long
reason or an unknown field (idempotency_key is accepted).

Sends a draft agreement to the Venture Partner, as the Hub "Send to
Venture Partner" button does: EMAILS them the signing link at once,
and the email cannot be unsent. They have 60 days to sign; Hub
countersigns with the fund manager's saved signature once they do,
then Legal Ops reviews it. Send only after the user has seen the terms
and confirmed it should go out.

Takes no fields (the agent runtime's idempotency_key aside). 422
when it is not a draft (can_send false), the Venture Partner has no
email, the Share Pool no longer holds its units, or the email could
not be delivered.

Returns 200 with the agreement, status sent, and sent_to.

Emails an unsigned agreement's signing link to the Venture Partner
again, as the Hub "Resend" button does (which asks for confirmation
first). The automatic reminders on days 21, 42 and 54 of the signing
window are unchanged.

Takes no fields (the agent runtime's idempotency_key aside). 422
when the agreement is not waiting on the Venture Partner's signature
(can_remind false).

Returns 200 with the agreement and sent_to.

Returns the chart of accounts (GL account codes) shared across the
account. Use this to discover valid account codes before posting
journal entries. Codes follow standard GL ranges: 1xxx=assets,
2xxx=liabilities, 3xxx=equity, 4xxx=revenue, 6xxx/7xxx=expenses. All
filters are optional and combine with AND. Results are paginated and
ordered by code.

Returns a single chart-of-accounts entry (GL account code) by its
integer id. Use after list_accounting_accounts to confirm a code
before posting a journal entry.

Returns the capital calls (draft/open/closed) issued from the given
entity's fund. Each row carries header fields: id, name, status,
percentage_to_call, notes, amount_being_called (sum of per-LP details),
created_at, closed_at, due_date, and the parent entity ref.

Filter by status and a date window via period_start /
period_end (both ISO dates; supply together). The window bounds
created_at by default; pass date_field=closed_at to bound close
dates instead (draft/open calls have no closed_at and drop out).

Per-LP wire line items: pass lp_query (partial LP name) to keep
ONLY calls containing a matching LP — the filter applies before
pagination, so an older matching call is never crowded out by newer
non-matching calls — and each returned row embeds lp_details for
the matching LPs (amount called, wired amount, wire date, variance,
payment_status). include_lp_details=true
embeds lp_details for every returned call without filtering.
Embedded line items cap at 25 per call; use
/api/v1/capital_calls/{id}/details for full per-LP paging.

Still owed: still_owed is what this LP still has to send the fund
now, across every call, net of prepaid; use it and the header's
total_still_owed to say who still owes and how much. A fund-wide
balance, so don't add total_still_owed across calls.
total_outstanding is called minus in-window wires, not what's owed.
wired_amount and payment_status miss payments made before the
call.

Ordering is deterministic: calls come back newest first
(created_at DESC, id DESC) and lp_details rows by id — both
total orders, so identical arguments always return identical rows in
an identical sequence.

The header money figures (amount_being_called, total_wired,
total_outstanding, total_variance, percentage_funded) ALWAYS
cover every LP on the call. They are NOT narrowed by lp_query and
NOT shrunk by the 25-row cap, so summing lp_details will not
reproduce them whenever the roster is filtered or truncated. Each row
carrying lp_details also carries lp_details_coverage
(returned, matched, call_total, truncated,
filtered_by_lp_query, totals_basis) which states exactly that
relationship — read it before describing the roster.

Starting a call: on the fund's Capital Calls page, Start a Call shows
once the fund has a capital account it can call (an active one, or a
not-enabled one when the fund allows calling those) and is not fully
called; a standing-call fund has none. A new call is a
draft that goes to Decile for review, and a Decile admin or a
full-access account admin approves it (Approve is blocked while
another call is open). Approval opens the call and runs the Send
Capital Call Notice stage's automations; LPs get no capital call
notice while the call is a draft.

Returns 404 when entity_id belongs to a different account or is
not a fund/SPV.

Returns the header block for a single capital call. Use
/api/v1/capital_calls/{id}/details for per-LP rows.

Returns the per-capital-account line items (LPs/GPs) attached to a
capital call: amount called, the LP's committed capital, wired amount
and wire date (from reconciled wire transactions on the period),
variance (wired − called) and a derived payment_status
(fully_paid/underpaid/overpaid/unpaid/prepaid/over_commitment/
any_variance/unknown).

Still owed: still_owed is what this LP still has to send the fund
now, across every call, net of prepaid; use it to say who still owes
and how much. wired_amount and payment_status miss payments made
before the call.

Returns a paginated list of financial report generation jobs that belong to the authenticated API key's account, regardless of which API key within that account created them. Sorted by created_at descending. Successful jobs include download URLs for the generated files.

Queues an asynchronous financial report generation job. The job includes every entity of the requested entity_type within the API key's account. Use the returned status_url to poll job status and download generated files after the job succeeds.

Returns the current status for a financial report generation job created by the authenticated API key. Successful jobs include download URLs for the generated files.

A pitch deck Dex drafted in one of your chats, as the deck card shows it: the fund
name, progress (written_count of slide_count slides written, open_gap_count
facts to fill), and every slide with its status (drafted, needs_input,
writing, not_drafted), copy and fact gaps. A gap's state is answered,
suggested (a suggested answer is waiting for a check) or open.
open_gap_ids lists the unanswered gaps in the order the card asks for them;
slides Dex is writing are left out. A deck in a chat you cannot write in is not found.

Save one slide as the deck card's Save does: the headline, the body or the
structured content, and answers to this slide's gaps, in one save. A field
you leave out or send as null keeps its value. A new body on a structured slide makes it free
text. content is checked against the slide's layout; errors come back as
validation_failed with field_errors. answer_not_in_copy is true when a new
answer is saved on a slide that already has copy, which Dex has not written in yet.

Answer gaps on any of the deck's slides, as the deck card's gaps form does. The
answers are saved only: Dex works them into the slides when asked in the chat.
If a slide Dex is rewriting holds one of the gaps, nothing is saved
(slide_locked, with the slide names).

The deck as a 16:9 PDF, the same file as the deck card's Download PDF. Open gaps
show in boxes on their slides, and a slide Dex is still writing says so.

Gets a paginated list of Events in your account. The response will have a data array with the events and a pagination object with the total count, current page, and total pages. Pages are 0-indexed, so the first page is page 0. The Events returned can be filtered and ordered. Order direction is ascending by default. The default Event shape is compact. Use fields= to request other editable fields and include=hosts or include=guests for nested records.

Creates a new Event in your account. A successful request will return the created event data with success status. The event will automatically have an associated pipeline and questionnaire created for guest management. Events start public: send access_type=private_access ONLY when the user asks for a private or password-protected Event. A private Event is gated by its registration_code, which the response returns - after creating one, tell the user the registration code so they can share it.