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

# An event's per-customer ticket limit (null when it has none) and how many of its tickets the limit can count against a customer (API token, merchant:read)



## OpenAPI

````yaml https://app.alytegen.com/openapi.public.json get /v1/integration/events/{id}/purchase-limit
openapi: 3.1.0
info:
  title: Alyte API
  description: >-
    Secure agentic checkout for live-events ticketing. REST is the canonical
    surface; MCP/A2A are adapters over the same orchestrator.
  version: 1.0.0
servers:
  - url: /
    description: this instance
security:
  - bearerAuth: []
tags:
  - name: catalog
    description: Shop / event / tier discovery
  - name: ticketing
    description: 'The purchase spine: quote → reserve → confirm'
  - name: payments
    description: One-shot authorize + result reads
  - name: acp
    description: Agentic Commerce Protocol — checkout sessions (OpenAI ACP conformance)
  - name: vic
    description: >-
      Visa Intelligent Commerce — mandate-governed purchase-initiate (the VIC
      mandate is the spend authority)
  - name: signed-mandate
    description: >-
      Network signed-mandate (VIC / Mastercard Agent Pay shape) — a detached
      network signature over the mandate artefact is verified with real crypto
      before the spend authority is granted
  - name: ap2
    description: Legacy AP2 purchase — unsupported pending verified checkout authorization
  - name: buyer
    description: >-
      Buyer surface — magic-link identity, bring/create agents, card capture
      (PSP iframe), and mandates whose scope is locked server-side to the shop
      the session is for
  - name: discovery
    description: >-
      PUBLIC discovery (no auth) — the opt-in shop window + the ACP product
      feed. Only shops that flipped `discoverable` appear; everything else 404s.
  - name: protocols
    description: Protocol adapters (MCP / A2A) over the same orchestrator as REST
  - name: integration
    description: >-
      Server-to-server merchant integration (API token) — e.g. minting buyer
      sessions for users the MERCHANT'S own auth has already verified
paths:
  /v1/integration/events/{id}/purchase-limit:
    get:
      tags:
        - integration
      summary: >-
        An event's per-customer ticket limit (null when it has none) and how
        many of its tickets the limit can count against a customer (API token,
        merchant:read)
      parameters:
        - schema:
            type: string
          in: path
          name: id
          required: true
      responses:
        '200':
          description: Default Response
          content:
            application/json:
              schema:
                type: object
                additionalProperties: true
                properties:
                  purchaseLimit:
                    anyOf:
                      - type: object
                        additionalProperties: true
                        properties:
                          eventId:
                            type: string
                          merchantId:
                            type: string
                          maxPerCustomer:
                            type: integer
                          maxHeldPerCustomer:
                            type: integer
                          countWaitingWatches:
                            type:
                              - 'null'
                              - boolean
                            description: >-
                              Whether queued purchases count toward the limit
                              while they wait; null when the merchant has not
                              chosen, which counts.
                          revision:
                            type: integer
                          updatedAt:
                            type: string
                        required:
                          - eventId
                          - maxPerCustomer
                          - countWaitingWatches
                          - revision
                      - type: 'null'
                  readiness:
                    type: object
                    additionalProperties: true
                    properties:
                      identifiers:
                        type: array
                        items:
                          type: string
                        description: >-
                          What a customer is recognised by: account (the buyer
                          behind the agent) and card (Stripe's card fingerprint,
                          or Adyen's card alias when the merchant's Adyen
                          account returns it). Cards saved before card
                          recognition, Adyen cards saved without an alias, and
                          delegated payment tokens count by account only.
                      ticketsCounted:
                        type: integer
                        description: >-
                          Held or sold tickets the limit counts against a
                          customer.
                      ticketsNotCounted:
                        type: integer
                        description: >-
                          Held or sold tickets it cannot tie to a customer, e.g.
                          bought before the buyer could be identified.
                    required:
                      - identifiers
                      - ticketsCounted
                      - ticketsNotCounted
                required:
                  - purchaseLimit
                  - readiness
components:
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      bearerFormat: JWT

````

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