> ## Documentation Index
> Fetch the complete documentation index at: https://docs.trycactus.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Download the populated Excel model

> A short-lived link to the workbook behind the report — the same
file the in-app export produces, with every input the run settled
already populated.

The link is minted per request rather than stored, so fetch it when
you are ready to download rather than caching it.




## OpenAPI

````yaml /api-reference/openapi.yaml get /v1/underwritings/{underwriting_id}/model
openapi: 3.1.0
info:
  title: Cactus Partner API
  version: 1.0.0-draft.1
  summary: Document extraction and automated underwriting for CRE.
  description: |
    # Overview

    The Cactus Partner API provides two products:

    - **Extraction** — upload commercial real estate documents (offering
      memoranda, rent rolls, T-12 / operating statements, and other business
      documents) and receive structured, validated JSON with per-field
      confidence.
    - **Underwriting** — provide a property address, asset class, and
      notification email (documents optional) to run a full automated
      underwriting; results are delivered as a hosted financial-analysis
      report link plus a machine-readable summary.

    ## Authentication

    Every request carries an API key:
    `Authorization: Bearer ck_live_...` (or `ck_sandbox_...`).
    Keys are issued by Cactus at kickoff and can be rotated or revoked at
    any time.

    ## Products and access

    Accounts are enabled per product, so not every endpoint below is
    available to every account:

    | Product | Endpoints |
    | --- | --- |
    | Extraction | `/v1/extractions` |
    | Underwriting | `/v1/underwritings` |
    | Usage reporting | `/v1/usage` |

    `/v1/documents` and `/v1/webhook-endpoints` are available to every
    account — uploads and webhook delivery underpin both products.

    Calling an endpoint your account is not enabled for returns `403`
    with code `product_not_enabled`; contact api@trycactus.com to add a
    product. A `403` with code `missing_scope` means the account *is*
    enabled but this particular key was issued without that scope — use a
    key that carries it. The MCP server advertises only the tools your key
    can use, so the same rules apply there.

    ## Sandbox

    `ck_sandbox_` keys hit the same endpoints but never debit your usage
    pool: uploads are accepted, and jobs return deterministic fixture output
    within seconds. Use sandbox keys for integration development and CI.

    Registering a sandbox document under a documented example filename
    (e.g. `example-rent-roll-1.xlsx`) returns the real extracted output of
    that reference document — see the Sandbox guide for the full list.

    ## Asynchronous jobs

    Extractions and underwritings are asynchronous. Create the job (`202
    Accepted`), then either poll the job resource or register a webhook
    endpoint to receive signed events (recommended). Typical extraction
    turnaround is minutes.

    ## Billing semantics

    A document is **accepted** when it passes validation (size caps, page/row
    counts, type resolution). Acceptance debits your usage pool at the fixed
    rate-card price for the document type — before processing, so pricing is
    deterministic. Rejected documents are never charged. Documents exceeding
    their type's size cap bill as multiple units of the same type; the accept
    response discloses `billed.units`. Files over 500 pages or 100 MB are
    rejected outright.

    ## Idempotency

    All `POST` endpoints accept an `Idempotency-Key` header (any unique
    string, e.g. a UUID). Retrying a request with the same key returns the
    original response instead of creating a duplicate.

    ## Errors

    Errors follow RFC 9457 (`application/problem+json`) and always include a
    stable machine-readable `code` and the `request_id` to quote in support
    requests.

    ## Versioning

    The path major version (`/v1`) changes only for breaking API changes.
    Extraction output schemas are versioned independently per document type
    (e.g. `rent_roll.v1`) and declared in every result; breaking output
    changes ship as a new schema version with advance notice and an overlap
    window.

    ---
    All field-level output schemas — `RentRollData` (`rent_roll.v1`),
    `T12Data` (`t12.v1`), `OfferingMemorandumData`
    (`offering_memorandum.v1`), and `GenericDocumentData` (`facts.v1`) —
    are finalized against the extraction engine's real output.
  contact:
    name: Cactus API Support
    email: api@trycactus.com
  license:
    name: Proprietary — Cactus API License Agreement
    identifier: LicenseRef-Cactus-Partner-Agreement
servers:
  - url: https://api.trycactus.com
    description: Production (live and sandbox keys)
security:
  - apiKey: []
tags:
  - name: Documents
    description: Upload and manage documents via presigned URLs.
  - name: Extractions
    description: Structured data extraction jobs and results.
  - name: Underwritings
    description: Automated underwriting runs.
  - name: Usage
    description: Usage pool balance and metered activity.
  - name: Webhook Endpoints
    description: Manage endpoints that receive signed event notifications.
paths:
  /v1/underwritings/{underwriting_id}/model:
    parameters:
      - name: underwriting_id
        in: path
        required: true
        schema:
          type: string
        example: uw_01J9ZK3M
    get:
      tags:
        - Underwritings
      summary: Download the populated Excel model
      description: |
        A short-lived link to the workbook behind the report — the same
        file the in-app export produces, with every input the run settled
        already populated.

        The link is minted per request rather than stored, so fetch it when
        you are ready to download rather than caching it.
      operationId: getUnderwritingModel
      responses:
        '200':
          description: Download link.
          content:
            application/json:
              schema:
                type: object
                required:
                  - url
                properties:
                  url:
                    type: string
                    format: uri
                  expires_at:
                    type: string
                    format: date-time
                    nullable: true
                    description: >-
                      Null for sandbox runs, whose link is a deterministic
                      placeholder rather than a signed URL.
        '403':
          $ref: '#/components/responses/Forbidden'
        '404':
          $ref: '#/components/responses/NotFound'
        '409':
          description: The run has not completed, or produced no workbook.
          content:
            application/problem+json:
              schema:
                $ref: '#/components/schemas/Problem'
components:
  responses:
    Forbidden:
      description: >
        The key authenticated, but this product is not available to it.
        `product_not_enabled` — your account has not been enabled for this
        product; contact api@trycactus.com. `missing_scope` — your account has
        the product but this particular key was issued without it; use a key
        that carries the scope.
      content:
        application/problem+json:
          schema:
            $ref: '#/components/schemas/Problem'
          examples:
            product_not_enabled:
              summary: Account not enabled for the product
              value:
                type: https://docs.trycactus.com/errors#product_not_enabled
                title: Product not enabled for this account
                status: 403
                detail: >-
                  Your account is not enabled for underwriting. Contact
                  api@trycactus.com to enable it.
                code: product_not_enabled
                request_id: req_01J9Z6X2QK8N4M
            missing_scope:
              summary: Key narrower than the account
              value:
                type: https://docs.trycactus.com/errors#missing_scope
                title: API key lacks the required scope
                status: 403
                detail: >-
                  This API key does not have the 'underwriting' scope. Use a key
                  with underwriting access.
                code: missing_scope
                request_id: req_01J9Z6X2QK8N4M
    NotFound:
      description: Resource does not exist (or belongs to another partner).
      content:
        application/problem+json:
          schema:
            $ref: '#/components/schemas/Problem'
  schemas:
    Problem:
      type: object
      description: RFC 9457 problem details.
      required:
        - title
        - status
        - code
        - request_id
      properties:
        type:
          type: string
          format: uri
          description: >
            Link to this code's entry on the errors page. An anchor, not a path
            — every code lives on the one page.
          example: https://docs.trycactus.com/errors#document_over_size_cap
        title:
          type: string
          example: Document exceeds the size limit
        status:
          type: integer
          example: 422
        detail:
          type: string
          example: Files over 500 pages or 100 MB are rejected and not charged.
        code:
          type: string
          description: Stable machine-readable error code.
          example: document_over_size_cap
        request_id:
          type: string
        errors:
          type: array
          description: Field-level validation errors, when applicable.
          items:
            type: object
            properties:
              field:
                type: string
              code:
                type: string
              message:
                type: string
  securitySchemes:
    apiKey:
      type: http
      scheme: bearer
      bearerFormat: ck_live_* or ck_sandbox_*
      description: Partner API key issued by Cactus.

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.