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

# List the products you can offer, at your prices

> Your catalog with your wholesale price on each line - your override where you have one, the default otherwise. These keys are what you pass as `product_key` when you attach a service order.



## OpenAPI

````yaml /partner/openapi.yaml get /products
openapi: 3.1.0
info:
  title: Clemta Partner API
  description: |
    The Clemta partner surface. Authenticate with your API key as a bearer
    token (`Authorization: Bearer clmt_live_` or `clmt_test_`). Keys with
    the `clmt_test_` prefix operate in sandbox mode (`livemode: false`): test
    data never reaches fulfillment or billing.

    Versioning is date-based: pass `Clemta-Version` to pin a
    version, omit it to run on your account's pinned default. The effective
    version is echoed back on every response.
  version: '2026-08-13'
servers:
  - url: https://api.clemta.com/v1
    description: >
      Single host for both modes: `clmt_test_` keys operate in sandbox mode,
      `clmt_live_` keys in live mode.
security:
  - apiKey: []
tags:
  - name: Identity
    description: Identify the calling API key.
  - name: Accounts
    description: >-
      Create and read customer accounts - the incorporators companies are
      created under.
  - name: Companies
    description: Create and read client companies.
  - name: Service orders
    description: Order services against a company and follow their fulfilment.
  - name: Products
    description: The catalog you can offer, at your wholesale prices.
  - name: Tax filings
    description: >-
      Federal and state tax filings on your companies, opened by your client
      against the company's entitlements and worked by Clemta. Read-only. Follow
      them with the tax_filing.* events.
  - name: Files
    description: >-
      Documents Clemta publishes on your companies - formation deliverables,
      filed forms, letters. Read-only. Client KYC uploads are write-only and
      never listed.
  - name: Requirements
    description: >-
      Everything needed from you or your client - identity documents,
      service-order forms, Clemta's asks - as one resolvable resource. Fulfill
      over the API or hand your client a hosted link.
  - name: Status tracking
    description: >-
      End-customer status links - keyless, read-only access to a company's live
      status.
  - name: Events
    description: Poll the partner event stream.
  - name: Webhooks
    description: >-
      Events we deliver to your endpoint, and how to verify them. Each webhook
      below is a request WE send to you. Respond 2xx to acknowledge. Deliveries
      are signed and retried with exponential backoff over multiple days until
      acknowledged. Answer `410 Gone` to have the endpoint disabled and
      deliveries stopped. A `Retry-After` header on a `429` or `503` pushes the
      next attempt back. An endpoint that fails continuously for days is
      disabled automatically and the workspace owner is emailed - no events are
      lost, the stream stays available on `GET /v1/events`.


      ## Verifying a delivery


      Deliveries are signed per the [Standard
      Webhooks](https://www.standardwebhooks.com) specification, carrying BOTH
      schemes in one header: a symmetric `v1` HMAC (verify with your endpoint
      secret and any standardwebhooks library) and an asymmetric `v1a` ed25519
      signature (verify with the endpoint's public key, no shared secret held).
      Use whichever suits your setup.


      Every endpoint has its OWN signing secret (`whsec_...`), shown once when
      you create the endpoint. Each delivery carries three headers:


      - `Clemta-Webhook-Id` - the event id. Stable across retries: use it as an
      idempotency key so a redelivered event is processed once.

      - `Clemta-Webhook-Timestamp` - unix seconds of THIS attempt (a retry
      carries a fresh one).

      - `Clemta-Webhook-Signature` - a space-delimited list of `v1,<base64>`
      signatures. More than one while a secret rotation's overlap window is
      open, one per active secret.


      Each is also sent under its bare Standard Webhooks name (`webhook-id`,
      `webhook-timestamp`, `webhook-signature`) with the same value, which is
      what off-the-shelf standardwebhooks libraries look up.


      To verify by hand:


      1. Build the signed content by joining the id, the timestamp, and the raw
      request body with literal `.` separators: `{id}.{timestamp}.{body}`. Use
      the body exactly as received - do not re-serialize the JSON.

      2. Base64-decode your endpoint secret after the `whsec_` prefix. That is
      the HMAC key.

      3. Compute HMAC-SHA256 over the signed content, base64 encode it, and
      compare it against each `v1,` entry in constant time. Accept if any
      matches, otherwise reject.

      4. Check the timestamp is within 5 minutes of now, to reject replays.


      Because the secret is unique to your endpoint, a signature can only be
      verified by you - a delivery meant for another endpoint cannot be made to
      verify here. Keep the secret confidential. If it leaks, roll the
      endpoint's secret from the Webhooks page of your partner dashboard.
  - name: Sandbox
    description: >-
      Test-key-only endpoints for rehearsing event flows. Trigger a lifecycle
      transition on a test company and receive the matching webhook, without
      waiting for a real formation to progress.
paths:
  /products:
    get:
      tags:
        - Products
      summary: List the products you can offer, at your prices
      description: >-
        Your catalog with your wholesale price on each line - your override
        where you have one, the default otherwise. These keys are what you pass
        as `product_key` when you attach a service order.
      operationId: listProducts
      parameters:
        - $ref: '#/components/parameters/ClemtaVersion'
      responses:
        '200':
          description: Your catalog.
          headers:
            Clemta-Version:
              $ref: '#/components/headers/ClemtaVersion'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ProductList'
        '401':
          $ref: '#/components/responses/Unauthorized'
        '429':
          $ref: '#/components/responses/RateLimited'
components:
  parameters:
    ClemtaVersion:
      name: Clemta-Version
      in: header
      required: false
      description: Date-based API version to run this request against.
      schema:
        type: string
        example: '2026-08-13'
  headers:
    ClemtaVersion:
      description: The API version the request was executed against.
      schema:
        type: string
  schemas:
    ProductList:
      type: object
      description: Your catalog. Unpaginated - the set is small and bounded.
      required:
        - object
        - items
      properties:
        object:
          type: string
          enum:
            - list
          description: Entity name.
        items:
          type: array
          items:
            $ref: '#/components/schemas/Product'
    Product:
      type: object
      description: A product you can offer, priced at your wholesale rate.
      required:
        - object
        - key
        - display_name
        - unit_amount
        - currency
      properties:
        object:
          type: string
          enum:
            - product
          description: Entity name.
        key:
          type: string
          description: >-
            The identifier you order by - pass it as `product_key` on a service
            order.
          example: formation_llc
        display_name:
          type: string
          example: Company Formation (LLC)
        unit_amount:
          type: integer
          format: int64
          minimum: 0
          description: >-
            Your wholesale price in the currency's smallest unit (cents) - your
            override if you have one, otherwise the default.
          example: 14900
        currency:
          type: string
          example: usd
        interval:
          type: string
          enum:
            - one_time
            - monthly
            - yearly
          description: Billing cadence - one_time, or recurring monthly/yearly.
        trial_periods:
          type: integer
          description: >-
            How many opening billing intervals are free on this product - for
            example 1 on a yearly service whose first year is included, or 12 on
            a monthly fee that starts billing after a year. An order created for
            it carries no charge until the first paid period arrives. Absent or
            0 means billing starts at creation.
        billing:
          type: string
          enum:
            - advance
            - arrears
          description: >-
            When a recurring period is billed. `advance` bills the first period
            at order creation and every later one at its start. `arrears` bills
            each period at its end instead - the order is created with no charge
            and the first invoice line lands one interval later. Absent means
            advance.
        includes:
          type: array
          items:
            type: string
          description: >-
            Products an order for this one attaches automatically at no extra
            charge - each appears as its own order marked `included_in`, with
            its own status and events. The formation's bundle (registered agent,
            business address, EIN, bank application) is the live case.
        description:
          type: string
          description: >-
            What the product is, expected timelines, and any disclaimers - shown
            to you verbatim. Carry the disclaimers into your own client-facing
            copy (e.g. a business mailing address is not proof of physical
            presence, bank approval is the institution's decision).
        quote:
          type: boolean
          description: >-
            Priced per order: the order opens unbilled in `quote_pending`,
            Clemta reviews the work and sets the price (`service_order.quoted`),
            and billing happens when you accept it. `unit_amount` on this
            product is indicative only.
        on_complete:
          type: string
          description: >-
            A company-level effect the order's completion fires. Today only
            `dissolve_company` - the dissolution product: completing it closes
            the company (terminal `dissolved` status, renewals ended, open
            requirements closed).
        repeat:
          type: string
          description: >-
            The product's repeatability. Absent means one order per company.
            `per_order` means every purchase is its own instance.
            `per_option:<key>` means one order per value of that option (a
            filing per tax_year, a registration per state). `per_shareholder`
            means one order per company owner, named by `shareholder` on the
            order.
        conflicts_with:
          type: array
          items:
            type: string
          description: >-
            Products this one cannot be held together with - ordering it while
            the company holds one of these (or the same creation basket carries
            one) is refused.
        depends_on:
          type: array
          items:
            type: string
          description: >-
            Products that must already be ordered on the company before this one
            can be - a missing prerequisite is refused naming the key.
        defer_first_charge:
          type: string
          enum:
            - first_anniversary
          description: >-
            When present, an order created before the stated anchor bills
            nothing at creation: for first_anniversary the first charge lands
            one interval after the company's incorporation date. Ordered after
            the anniversary, it bills at creation as usual.
        pass_through_fees:
          type: string
          enum:
            - annual_state_filing
            - trademark_government
            - sales_tax_government
            - amendment_government
            - dissolution_government
            - cogs_government
          description: >-
            When present, an order for this product also bills government or
            state fee lines beside the product price, at the amounts current at
            order time. annual_state_filing adds the state's own annual report /
            franchise charge and the processing fee. The others add that
            filing's government fee. Each appears as its own line on your
            statement and on the order's `fees`.
        required_for:
          type: array
          items:
            type: string
            enum:
              - formation
              - existing
          description: >-
            Which companies this product is mandatory on: `formation` (companies
            Clemta forms) and/or `existing` (pre-existing companies you bring
            in). Creating such a company attaches and bills it automatically -
            include it in your own pricing.
        options:
          type: array
          maxItems: 10
          items:
            $ref: '#/components/schemas/ProductOption'
          description: >-
            The product's variants, when it has any. Each is a choice made at
            order time. A `required` one must be sent in `options` on the
            service order.
        price_rules:
          type: array
          items:
            $ref: '#/components/schemas/PriceRule'
          description: >-
            Conditional amounts for this product, applied automatically from the
            company the order is for - nothing extra to send. Evaluated in
            order, first match wins. No match pays `unit_amount`.
        fulfillment:
          type: string
          enum:
            - workflow
            - entitlement
          default: workflow
          description: >-
            What the fulfilment is. `workflow` - Clemta fulfils the order step
            by step, possibly asking for forms (follow `status` / requirements).
            `entitlement` - the order grants the company a right (a tax-filing
            credit, for instance) that is then exercised in the company's own
            flow. An entitlement order completes at provisioning and never asks
            for a form.
        available_when:
          type: object
          additionalProperties: true
          description: >-
            Who this product can be ordered to, as a match condition over the
            company attributes entity_type, state, pre_existing and
            owners_count. Empty or absent means every company. An order for a
            company outside it is refused.
          example:
            entity_type: llc
    Error:
      type: object
      description: >-
        Error response: a stable machine-readable `code`, human-readable
        `title`/`detail`, and for validation failures an `errors` array naming
        every violating field.
      required:
        - type
        - title
        - status
        - code
      additionalProperties: false
      properties:
        type:
          type: string
          description: Link to the error reference entry for this code.
          example: https://docs.clemta.com/partner/errors#resource_already_exists
        title:
          type: string
          description: Short human summary of the error class.
        status:
          type: integer
          format: int32
          minimum: 100
          maximum: 599
          description: HTTP status code, also included in the body.
        code:
          type: string
          enum:
            - api_key_invalid
            - api_key_expired
            - insufficient_scope
            - ip_address_not_allowed
            - invalid_request
            - invalid_api_version
            - resource_missing
            - method_not_allowed
            - test_mode_only
            - resource_already_exists
            - idempotency_key_mismatch
            - idempotency_key_in_use
            - request_too_large
            - billing_account_inactive
            - entitlement_required
            - rate_limit
            - api_error
          description: Stable machine-readable code - branch on this, never on `detail`.
        detail:
          type: string
          description: Human-readable specifics of this occurrence, wording may change.
        request_id:
          type: string
          description: >-
            Identifier of this request. Quote it in a support request so we can
            trace the failure.
        errors:
          type: array
          description: 'Present on validation failures: one entry per violating field.'
          items:
            type: object
            required:
              - reason
            additionalProperties: false
            properties:
              reason:
                type: string
              location:
                type: string
                description: JSONPath of the failing field, e.g. `$.name`.
              validation_type:
                type: string
                description: Schema keyword that failed.
              how_to_fix:
                type: string
    ProductOption:
      type: object
      description: >-
        One variant axis of a product - a choice made at order time. Pass your
        choice as `options[<key>] = <value>` when creating a service order.
      required:
        - key
        - label
        - values
      properties:
        key:
          type: string
          pattern: ^[a-z][a-z0-9_]{1,48}$
          description: The option's identifier, the key you send in `options`.
          example: llc_members
        fixed:
          type: boolean
          description: >-
            A fixed option is chosen at order time and is never upgradable
            later. The options-upgrade endpoint refuses to change it.
        label:
          type: string
          description: Human-readable name of the choice.
          example: LLC membership
        required:
          type: boolean
          description: True when an order for this product must choose a value.
        values:
          type: array
          minItems: 1
          items:
            $ref: '#/components/schemas/ProductOptionValue'
    PriceRule:
      type: object
      description: >-
        One conditional price point. When `match` holds against the company the
        order is for, the order prices at `unit_amount` instead of the product
        default - rules are evaluated in order and the first match wins. The
        condition is answered by the company record itself, so there is nothing
        extra to send on the order.
      required:
        - key
        - match
        - unit_amount
      properties:
        key:
          type: string
          description: Stable identifier of the rule.
          example: de_filing
        label:
          type: string
          description: Display name, when one is set.
          example: Delaware filing
        match:
          type: object
          additionalProperties: true
          description: >-
            Condition over the company attributes `entity_type`, `state`,
            `pre_existing` and `owners_count`, in query-operator form - a plain
            value means equality, `$in`, `$gte`, `$and`, `$or` and friends are
            supported.
          example:
            state: DE
        unit_amount:
          type: integer
          format: int64
          minimum: 0
          description: >-
            Your price in the currency's smallest unit (cents) when the rule
            matches.
          example: 31500
    ProductOptionValue:
      type: object
      description: One choice on a product option.
      required:
        - value
        - label
      properties:
        value:
          type: string
          pattern: ^[a-z][a-z0-9_]{1,48}$
          description: The value you send in `options`.
          example: multi_member
        label:
          type: string
          example: Multi-member LLC
        available_when:
          type: object
          additionalProperties: true
          description: >-
            When present, this value may only be chosen for companies matching
            the condition - for example an expedited filing offered in certain
            states only. Choosing it elsewhere is refused naming the option.
        unit_amount:
          type: integer
          format: int64
          minimum: 0
          description: >-
            The wholesale price of the product when this value is chosen, in the
            currency's smallest unit. Absent means the product's own price
            applies. If Clemta set you an override on the product, the override
            applies whatever you choose.
          example: 24900
  responses:
    Unauthorized:
      description: Missing, invalid, revoked, or grace-expired API key.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
    RateLimited:
      description: Rate limit exceeded, retry after the `Retry-After` header.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
  securitySchemes:
    apiKey:
      type: http
      scheme: bearer
      description: >
        Your API key, e.g. `Authorization: Bearer clmt_test_`. Live keys use the
        `clmt_live_` prefix.

````