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

# Get Activity operation result

> Returns the saved response of a settled prepaid operation. Results are kept 24 hours, and each can be transferred three times in total, including the original response. While the operation is pending the answer is 202 with Retry-After 5; after expiry it is 410. [Idempotency and recovery](/guides/idempotency).



## OpenAPI

````yaml /api-reference/activity.json get /operations/{id}/result
openapi: 3.0.3
info:
  title: Lumeus Activity API
  version: '2026-09-15'
  description: >-
    Lumeus Activity API on Stellar. Sign up at https://app.lumeus.dev: Free,
    Starter, Growth and Scale plans are self-serve, Enterprise by agreement.


    - **Pricing.** Testnet is free: Testnet requests cost no credits and are
    never billed. Each organization can make 10,000 Testnet requests a day
    across Activity, Assets and RPC (unlimited on Enterprise); the count resets
    at 00:00 UTC, and a request over it answers 429 rate_limited with
    Retry-After set to the seconds until then. Mainnet requests draw from the
    plan's monthly credits. Plans, limits and credit weights: `GET
    https://api.lumeus.dev/v1/plans`.

    - **Authentication.** Send `Authorization: Bearer <key>`. Testnet:
    `lum_test_…`; Mainnet: `lum_live_…`. A key works only on its own network, so
    pick the server that matches it (the other network answers 401). Publishable
    `lum_pub_…` keys call the GET data routes only, from an allowed browser
    origin. Webhook keys (`whk_…`) are not accepted here.

    - **Headers.** Every response except `GET /readyz` carries X-Request-Id;
    authenticated responses carry RateLimit-Limit, RateLimit-Remaining and
    RateLimit-Reset; 429 and 503 carry Retry-After.

    - **Errors.** JSON with a machine-readable code (see
    [errors](/guides/errors)). A path with an empty, `.` or `..` segment answers
    400 invalid_request, a trailing slash answers 404 not_found, and a method
    the path does not accept answers 405 with an Allow header.

    - **CORS.** Browser calls (CORS) are allowed from https://docs.lumeus.dev
    (the Try it playground of this reference) and https://app.lumeus.dev only,
    without cookies; responses expose ETag, Link, Location, Retry-After,
    X-Request-Id, X-Lumeus-Operation-Id, X-Lumeus-Idempotency and
    RateLimit-Limit, RateLimit-Remaining and RateLimit-Reset (errors included).
    Other websites cannot read responses made with a server key: use a
    publishable key with your own allowed origins ([browser
    keys](/guides/browser-keys)).
  license:
    name: Lumeus API contract
servers:
  - url: https://api-testnet.lumeus.dev
    description: Testnet (default)
  - url: https://api.lumeus.dev
    description: Mainnet
security:
  - Bearer: []
tags:
  - name: Queries
    description: >-
      Decoded Stellar history: the token movements and contract events of an
      account, asset, contract or transaction, the network feed, contract-event
      topic search and transaction headers.
  - name: Results
    description: >-
      Recover the saved result of a long prepaid request without running it
      again. Only prepaid accounts receive operation IDs; every other account
      gets 404 here.
  - name: Workspace
    description: >-
      Your workspace (organization): its name, plan, current period usage and
      API base URLs. Served by the Activity host for every product.
  - name: API keys
    description: >-
      Create, list, update, rotate and revoke the `lum_` keys used by the
      Activity API, the Assets API and RPC.
  - name: Usage
    description: >-
      Credits and requests used, the free Testnet daily count, per-route
      breakdowns, time series and the request log of your keys.
  - name: Billing
    description: >-
      The public plan catalog, plan subscriptions through Stripe Checkout, the
      billing portal and payment status.
  - name: Retired
    description: >-
      Routes kept only so old clients get a clear answer. Do not use them in new
      code.
  - name: Health
    description: Liveness and readiness probes for monitoring. No authentication.
paths:
  /operations/{id}/result:
    get:
      tags:
        - Results
      summary: Get Activity operation result
      description: >-
        Returns the saved response of a settled prepaid operation. Results are
        kept 24 hours, and each can be transferred three times in total,
        including the original response. While the operation is pending the
        answer is 202 with Retry-After 5; after expiry it is 410. [Idempotency
        and recovery](/guides/idempotency).
      operationId: getActivityOperationResult
      parameters:
        - name: id
          in: path
          required: true
          description: >-
            The operation ID from the X-Lumeus-Operation-ID header (or Location)
            of the original 202 response. The example ID is a placeholder and
            answers 404.
          schema:
            type: string
            example: aho_ue_00000000000000000000000000000000
            x-default: aho_ue_00000000000000000000000000000000
          example: aho_ue_00000000000000000000000000000000
      responses:
        '200':
          description: The saved response, with its original status and body.
          content:
            application/json:
              schema:
                oneOf:
                  - $ref: '#/components/schemas/Page'
                  - $ref: '#/components/schemas/Transaction'
              example:
                _links:
                  activity:
                    href: >-
                      /transactions/1ae3b48681d8b27f31ee8f1893281e9a56fd7c45cf9909cf6a0599949079c2ce/activity
                  self:
                    href: >-
                      /transactions/1ae3b48681d8b27f31ee8f1893281e9a56fd7c45cf9909cf6a0599949079c2ce
                created_at: '2026-10-22T14:51:32Z'
                fee_charged: 100
                hash: >-
                  1ae3b48681d8b27f31ee8f1893281e9a56fd7c45cf9909cf6a0599949079c2ce
                id: >-
                  1ae3b48681d8b27f31ee8f1893281e9a56fd7c45cf9909cf6a0599949079c2ce
                ledger: 5331421
                memo: ''
                memo_type: none
                memo_xdr: ''
                network: testnet
                operation_count: 1
                paging_token: 0022898278836224000-0000000000
                successful: true
          headers:
            X-Request-Id:
              description: >-
                Identifier of this request: req_ followed by 24 hex characters.
                Error bodies repeat it as request_id. Quote it when contacting
                support.
              schema:
                type: string
                pattern: ^req_[0-9a-f]{24}$
            RateLimit-Limit:
              description: >-
                Requests per minute of the bucket that answered: the plan rate,
                the dashboard session floor of 120, or a publishable key's
                per-IP rate.
              schema:
                type: integer
            RateLimit-Remaining:
              description: Whole requests left in the bucket after this one.
              schema:
                type: integer
            RateLimit-Reset:
              description: Seconds until the bucket is full again.
              schema:
                type: integer
        '202':
          description: Pending; retry after Retry-After (5) seconds.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Operation'
              example:
                id: aho_ue_00000000000000000000000000000000
                state: pending_billing
                network: testnet
                generation: testnet-2025-12-18-v3
                result_url: /operations/aho_ue_00000000000000000000000000000000/result
                result_expires_at: null
                dedup_until: '2026-10-23T09:15:04Z'
                max_result_transfers: 3
          headers:
            X-Request-Id:
              description: >-
                Identifier of this request: req_ followed by 24 hex characters.
                Error bodies repeat it as request_id. Quote it when contacting
                support.
              schema:
                type: string
                pattern: ^req_[0-9a-f]{24}$
            RateLimit-Limit:
              description: >-
                Requests per minute of the bucket that answered: the plan rate,
                the dashboard session floor of 120, or a publishable key's
                per-IP rate.
              schema:
                type: integer
            RateLimit-Remaining:
              description: Whole requests left in the bucket after this one.
              schema:
                type: integer
            RateLimit-Reset:
              description: Seconds until the bucket is full again.
              schema:
                type: integer
            Retry-After:
              description: Seconds to wait before retrying.
              schema:
                type: integer
        '401':
          $ref: '#/components/responses/HTTP401'
        '403':
          $ref: '#/components/responses/HTTP403_2'
        '404':
          $ref: '#/components/responses/HTTP404_4'
        '405':
          $ref: '#/components/responses/HTTP405_9'
        '410':
          $ref: '#/components/responses/HTTP410'
        '429':
          $ref: '#/components/responses/HTTP429_2'
        '503':
          $ref: '#/components/responses/HTTP503_5'
      x-codeSamples:
        - lang: bash
          label: cURL
          source: >-
            # Use the operation ID from the X-Lumeus-Operation-ID header of your
            202 response; the placeholder answers 404.

            curl --fail-with-body -sS
            'https://api-testnet.lumeus.dev/operations/aho_ue_00000000000000000000000000000000/result'
            \
              -H "Authorization: Bearer $LUMEUS_API_KEY"
        - lang: javascript
          label: JavaScript
          source: >-
            // Node 18+ (ES module)

            // Use the operation ID from the X-Lumeus-Operation-ID header of
            your 202 response; the placeholder answers 404.

            const res = await
            fetch('https://api-testnet.lumeus.dev/operations/aho_ue_00000000000000000000000000000000/result',
            {
              method: 'GET',
              headers: {
                Authorization: `Bearer ${process.env.LUMEUS_API_KEY}`,
              },
            });

            console.log(res.status, JSON.stringify(await res.json(), null, 2));
        - lang: python
          label: Python
          source: >-
            # Use the operation ID from the X-Lumeus-Operation-ID header of your
            202 response; the placeholder answers 404.

            import json

            import os


            import requests


            res = requests.get(
                "https://api-testnet.lumeus.dev/operations/aho_ue_00000000000000000000000000000000/result",
                headers={"Authorization": f"Bearer {os.environ['LUMEUS_API_KEY']}"},
                timeout=30,
            )

            print(res.status_code, json.dumps(res.json(), indent=2))
components:
  schemas:
    Page:
      type: object
      properties:
        read_view:
          $ref: '#/components/schemas/ReadView'
        range_complete:
          type: boolean
          description: >-
            True when no matching record remains after this page in the
            requested range (until_ledger, else the snapshot). An exactly full
            final page is already complete. Follow _links.next only while this
            is false.
        scanned_through_ledger:
          type: integer
          description: >-
            Last ledger of the range whose matching records this walk has
            delivered. On every complete page, in both orders, it is the last
            ledger of the effective range: until_ledger - 1, or snapshot_ledger
            when until_ledger is absent or later; for a descending walk that
            holds only if the walk started at the top of its range. On an
            ascending page stopped early by the scan budget it is the last fully
            scanned ledger. When since_ledger is beyond snapshot_ledger (past
            the published tip) the page is empty and complete, has no next link,
            and reports snapshot_ledger, in both orders, so a sync loop can
            checkpoint it. Absent on other incomplete pages and on an empty
            range that ends before first_ledger.
        limit:
          type: integer
          description: >-
            Effective page size after clamping to the plan maximum:
            max_page_size, or account_max_page_size for account activity.
        _links:
          type: object
          properties:
            self:
              type: object
              properties:
                href:
                  type: string
                  description: Relative URL; resolve against this product host.
              required:
                - href
            next:
              type: object
              properties:
                href:
                  type: string
                  description: Relative URL; resolve against this product host.
              required:
                - href
              description: >-
                Present only while range_complete is false; absent on the last
                page. Its cursor always advances: past the last record or, when
                the scan budget stopped the page early (possibly with no
                records), past the last fully scanned ledger.
            prev:
              type: object
              properties:
                href:
                  type: string
                  description: Relative URL; resolve against this product host.
              required:
                - href
          required:
            - self
            - prev
        _embedded:
          type: object
          properties:
            records:
              type: array
              items:
                $ref: '#/components/schemas/Event'
          required:
            - records
      required:
        - range_complete
        - limit
        - _links
        - _embedded
        - read_view
    Transaction:
      type: object
      properties:
        id:
          type: string
          pattern: ^[0-9a-fA-F]{64}$
        hash:
          type: string
          pattern: ^[0-9a-fA-F]{64}$
        paging_token:
          type: string
        network:
          type: string
          enum:
            - pubnet
            - testnet
        ledger:
          type: integer
        created_at:
          type: string
          format: date-time
        successful:
          type: boolean
        fee_charged:
          type: integer
          description: Charged fee in stroops, currently encoded as an integer.
        operation_count:
          type: integer
        memo_type:
          type: string
        memo:
          type: string
        memo_xdr:
          type: string
        _links:
          type: object
          properties:
            self:
              type: object
              properties:
                href:
                  type: string
            activity:
              type: object
              properties:
                href:
                  type: string
      required:
        - id
        - hash
        - paging_token
        - network
        - ledger
        - created_at
        - successful
        - fee_charged
        - operation_count
        - memo_type
        - memo
        - memo_xdr
        - _links
    Operation:
      type: object
      properties:
        id:
          type: string
        state:
          type: string
          description: >-
            Lifecycle state; completed means the result has settled, not
            necessarily a successful transaction.
        network:
          type: string
          enum:
            - mainnet
            - testnet
        generation:
          type: string
        result_url:
          type: string
          description: Relative URL on this product host.
        result_expires_at:
          type: string
          format: date-time
          nullable: true
        dedup_until:
          type: string
          format: date-time
          nullable: true
        error_code:
          type: string
        max_result_transfers:
          type: integer
          description: Three total transfers including the initial response.
          enum:
            - 3
      required:
        - id
        - state
        - network
        - generation
        - result_url
        - max_result_transfers
    ReadView:
      type: object
      properties:
        network:
          type: string
          enum:
            - pubnet
            - testnet
        generation:
          type: string
        decoder_version:
          type: string
        first_ledger:
          type: integer
        snapshot_ledger:
          type: integer
        published_through:
          type: integer
          description: The frozen snapshot watermark, not the current moving tip.
      required:
        - network
        - generation
        - decoder_version
        - first_ledger
        - snapshot_ledger
        - published_through
    Event:
      type: object
      properties:
        id:
          type: string
          description: >-
            Deterministic event identity: `{network}:{ledger}:{n}` for
            token_transfer, `{network}:{ledger}:ce:{tx}:{op}:{event}` for
            contract_event. Activity and Webhooks give the same on-chain event
            the same id (same decoder release), so deduplicate on (network, id);
            after a Testnet reset ledger numbers repeat, so start a new store.
        kind:
          type: string
          enum:
            - token_transfer
            - contract_event
        type:
          type: string
          description: >-
            transfer, mint, burn, clawback, fee, or a custom contract event
            name.
        network:
          type: string
          description: 'Canonical payload vocabulary: pubnet is Mainnet.'
          enum:
            - pubnet
            - testnet
        ledger:
          type: integer
          minimum: 3
        closed_at:
          type: string
          format: date-time
        tx_hash:
          type: string
          pattern: ^[0-9a-fA-F]{64}$
        tx_index:
          type: integer
          description: One-based position within the ledger.
        operation_index:
          type: integer
          description: One-based operation index; absent for transaction-level fee events.
        asset:
          type: string
          description: native or CODE:ISSUER. May be absent for custom contract tokens.
        contract_address:
          type: string
        from:
          type: string
        to:
          type: string
        issuer:
          type: string
        to_muxed_id:
          type: string
          description: Unsigned integer string, never a JavaScript number.
        to_muxed_address:
          type: string
        to_muxed_text:
          type: string
        to_muxed_hash:
          type: string
        memo_type:
          type: string
        memo:
          type: string
        memo_xdr:
          type: string
        amount:
          type: string
          description: Decimal string; seven decimal places for Classic/SAC assets.
        amount_raw:
          type: string
          description: Exact signed integer string.
        topics:
          type: array
          items: {}
        data: {}
        topics_xdr:
          type: array
          items:
            type: string
            description: Base64 ScVal XDR.
        data_xdr:
          type: string
          description: Base64 ScVal XDR; authoritative typed representation.
        paging_token:
          type: string
          description: Activity collections only; opaque keyset cursor.
        rpc_event_id:
          type: string
          description: >-
            Activity collections only, contract_event records only: the Stellar
            RPC getEvents id of the same event (%019d-%010d). It differs from
            paging_token, which counts operations from one and orders token
            transfers and contract events together. Absent on token_transfer
            records, which do not map one-to-one onto RPC events.
      required:
        - id
        - kind
        - type
        - network
        - ledger
        - closed_at
        - tx_hash
        - tx_index
    Error:
      type: object
      properties:
        error:
          type: string
          description: Human-readable message. It may change; branch on code.
        code:
          type: string
          description: >-
            Machine-readable error code. Branch on code, not on the error text,
            which may change. RPC carries the same codes as the string
            error.data of a JSON-RPC error. invalid_request: 400: invalid input,
            including a malformed Idempotency-Key or an unknown or repeated
            query parameter (Webhooks also uses it for an oversized request
            body, 413). Fix the request; do not retry unchanged. unauthorized:
            401: missing, revoked, invalid or wrong-network credential.
            payment_required: 402 (Mainnet): monthly credit quota exhausted on a
            hard-capped plan. forbidden: 403: the key or account policy does not
            allow this action. not_found: 404 (Webhooks also 410): the resource
            does not exist in this organization and network.
            topic_search_disabled: 404: contract-event topic search is not
            enabled on this network. method_not_allowed: 405: the route does not
            accept this method. conflict: 409: conflicting request identity,
            idempotency key, funding or recovery state. generation_changed: 409:
            the index generation or network changed since the snapshot was
            taken; restart the walk without generation and snapshot_ledger.
            history_unavailable: 409 (Assets): as_of_ledger is not answered from
            the balance history; start a snapshot job (POST /snapshots) or retry
            later. precondition_failed: 412 (Webhooks): the subscription version
            changed; fetch the current ETag. response_too_large: 413: the result
            exceeds the response budget; lower limit or narrow the request.
            precondition_required: 428 (Webhooks): If-Match with the
            subscription ETag is required. rate_limited: 429: a rate,
            concurrency or credit-cap limit was reached, or (Activity, Assets
            and RPC on Testnet) the daily Testnet request cap (message `daily
            Testnet request cap of 10000 reached; resets at 00:00 UTC`,
            Retry-After until 00:00 UTC). Wait Retry-After seconds (a refused
            request consumes nothing). A Retry-After greater than 60 means the
            daily Testnet cap: wait until 00:00 UTC or switch to Mainnet. RPC
            carries it as the string error.data. internal_error: 500 or another
            unexpected 5xx; quote request_id when contacting support.
            not_implemented: 501: the feature is not enabled on this host. busy:
            503: reads are saturated (the queue wait expired or the database
            refused another query or ran short of memory). Retry the same
            request after Retry-After (2) seconds. query_timeout: 503: the read
            ran out of time. Do not retry unchanged right away: narrow the
            ledger range (since_ledger/until_ledger) or lower limit; Retry-After
            is 30. index_not_ready: 503: the index or snapshot is not ready yet
            or is rebuilding; retry after Retry-After seconds. topic_coverage:
            503: the effective range is outside the contract-event topic index
            coverage (the message states it); pass a range inside it or retry
            after Retry-After (60) seconds. unavailable: 503: another temporary
            failure (billing, rate limiter, queue); retry after Retry-After
            seconds.
          enum:
            - invalid_request
            - unauthorized
            - payment_required
            - forbidden
            - not_found
            - topic_search_disabled
            - method_not_allowed
            - conflict
            - generation_changed
            - history_unavailable
            - precondition_failed
            - response_too_large
            - precondition_required
            - rate_limited
            - internal_error
            - not_implemented
            - busy
            - query_timeout
            - index_not_ready
            - topic_coverage
            - unavailable
        request_id:
          type: string
          description: >-
            Identifier of this request, the same value as the X-Request-Id
            header. Quote it when contacting support.
      required:
        - error
  responses:
    HTTP401:
      description: >-
        Missing, invalid, revoked or expired key, or a key for the other network
        (code unauthorized). Keys work only on the network they were created
        for.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            code: unauthorized
            error: missing credentials
            request_id: req_6f1c2a9b0e4d4c7a8b3f5e21
      headers:
        X-Request-Id:
          description: >-
            Identifier of this request: req_ followed by 24 hex characters.
            Error bodies repeat it as request_id. Quote it when contacting
            support.
          schema:
            type: string
            pattern: ^req_[0-9a-f]{24}$
    HTTP403_2:
      description: >-
        This key or account cannot call this route (code forbidden): for example
        a read-only key on a workspace route, or a publishable key on a route or
        from an origin it does not allow.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            code: forbidden
            error: >-
              publishable keys can only read Activity data; use a secret key on
              your server
            request_id: req_6f1c2a9b0e4d4c7a8b3f5e21
      headers:
        X-Request-Id:
          description: >-
            Identifier of this request: req_ followed by 24 hex characters.
            Error bodies repeat it as request_id. Quote it when contacting
            support.
          schema:
            type: string
            pattern: ^req_[0-9a-f]{24}$
    HTTP404_4:
      description: Not found in this organization and network (code not_found).
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            code: not_found
            error: Activity operation not found
            request_id: req_6f1c2a9b0e4d4c7a8b3f5e21
      headers:
        X-Request-Id:
          description: >-
            Identifier of this request: req_ followed by 24 hex characters.
            Error bodies repeat it as request_id. Quote it when contacting
            support.
          schema:
            type: string
            pattern: ^req_[0-9a-f]{24}$
    HTTP405_9:
      description: >-
        This path does not accept the HTTP method you sent (code
        method_not_allowed). The Allow header lists the methods it accepts.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            code: method_not_allowed
            error: >-
              method POST is not allowed on
              /operations/aho_ue_00000000000000000000000000000000/result;
              allowed: GET, HEAD
            request_id: req_6f1c2a9b0e4d4c7a8b3f5e21
      headers:
        X-Request-Id:
          description: >-
            Identifier of this request: req_ followed by 24 hex characters.
            Error bodies repeat it as request_id. Quote it when contacting
            support.
          schema:
            type: string
            pattern: ^req_[0-9a-f]{24}$
    HTTP410:
      description: The result expired or was deleted.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Operation'
          example:
            id: aho_ue_00000000000000000000000000000000
            state: expired
            network: testnet
            generation: testnet-2025-12-18-v3
            result_url: /operations/aho_ue_00000000000000000000000000000000/result
            result_expires_at: '2026-10-23T09:15:04Z'
            dedup_until: '2026-10-23T09:15:04Z'
            max_result_transfers: 3
      headers:
        X-Request-Id:
          description: >-
            Identifier of this request: req_ followed by 24 hex characters.
            Error bodies repeat it as request_id. Quote it when contacting
            support.
          schema:
            type: string
            pattern: ^req_[0-9a-f]{24}$
    HTTP429_2:
      description: >-
        The rate limit of this route was reached (code rate_limited). Wait
        Retry-After seconds. This route does not count toward the daily Testnet
        request cap, so its Retry-After is never the time until 00:00 UTC.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            code: rate_limited
            error: Activity recovery rate limit exceeded
            request_id: req_6f1c2a9b0e4d4c7a8b3f5e21
      headers:
        X-Request-Id:
          description: >-
            Identifier of this request: req_ followed by 24 hex characters.
            Error bodies repeat it as request_id. Quote it when contacting
            support.
          schema:
            type: string
            pattern: ^req_[0-9a-f]{24}$
        RateLimit-Limit:
          description: >-
            Requests per minute of the bucket that answered: the plan rate, the
            dashboard session floor of 120, or a publishable key's per-IP rate.
          schema:
            type: integer
        RateLimit-Remaining:
          description: Whole requests left in the bucket after this one.
          schema:
            type: integer
        RateLimit-Reset:
          description: Seconds until the bucket is full again.
          schema:
            type: integer
        Retry-After:
          description: Seconds to wait before retrying.
          schema:
            type: integer
    HTTP503_5:
      description: >-
        Temporarily unavailable (code unavailable). Wait Retry-After seconds and
        retry; do not assume the request failed permanently.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            code: unavailable
            error: Activity result unavailable
            request_id: req_6f1c2a9b0e4d4c7a8b3f5e21
      headers:
        X-Request-Id:
          description: >-
            Identifier of this request: req_ followed by 24 hex characters.
            Error bodies repeat it as request_id. Quote it when contacting
            support.
          schema:
            type: string
            pattern: ^req_[0-9a-f]{24}$
        Retry-After:
          description: Seconds to wait before retrying.
          schema:
            type: integer
  securitySchemes:
    Bearer:
      type: http
      scheme: bearer
      description: >-
        Send `Authorization: Bearer <key>`. Testnet: `lum_test_…`; Mainnet:
        `lum_live_…`. A key works only on its own network, so pick the server
        that matches it (the other network answers 401). Publishable `lum_pub_…`
        keys call the GET data routes only, from an allowed browser origin.
        Webhook keys (`whk_…`) are not accepted here.

````

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