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

# Create a form

> **Beta** — this endpoint may change before general availability.



## OpenAPI

````yaml /api-reference/openapi.json post /forms
openapi: 3.1.0
info:
  title: Replo Public API
  version: '2026-11-10'
servers:
  - url: https://api.replo.app/v1
security: []
paths:
  /forms:
    post:
      tags:
        - Forms
      summary: Create a form
      description: '**Beta** — this endpoint may change before general availability.'
      operationId: forms.create
      parameters:
        - name: Replo-Api-Version
          in: header
          required: true
          schema:
            type: string
            enum:
              - '2026-11-10'
          description: The public API version to use for this request.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              properties:
                projectId:
                  type: string
                  format: uuid
                  description: The project that owns the forms, from list_projects
                key:
                  type: string
                  pattern: ^[a-z0-9][a-z0-9-]{0,119}$
                  description: >-
                    Stable identifier the site code uses, such as contact or
                    quote-request
                name:
                  type: string
                  minLength: 1
                  maxLength: 255
                status:
                  type: string
                  enum:
                    - draft
                    - live
                    - archived
                  description: live takes responses, draft doesn't; live if left out
                fields:
                  type: array
                  items:
                    oneOf:
                      - type: object
                        properties:
                          type:
                            type: string
                            enum:
                              - text
                          key:
                            type: string
                            pattern: ^[a-z][a-z0-9_-]{0,63}$
                            description: Stable identifier of the field within its form
                          label:
                            type: string
                            minLength: 1
                            maxLength: 255
                          required:
                            type: boolean
                          showIf:
                            type: object
                            properties:
                              fieldKey:
                                type: string
                                pattern: ^[a-z][a-z0-9_-]{0,63}$
                                description: >-
                                  An earlier question whose answer decides
                                  whether this one is asked
                              anyOf:
                                type: array
                                items:
                                  type: string
                                  maxLength: 255
                                minItems: 1
                                maxItems: 100
                                description: >-
                                  Ask this question when the answer is one of
                                  these. Checkbox and consent answers compare as
                                  "true" or "false", numbers and ratings as
                                  their digits, and a pick-several answer
                                  matches when any choice is listed
                            required:
                              - fieldKey
                              - anyOf
                            description: >-
                              Ask this question only after a matching answer;
                              otherwise it is skipped, never required, and its
                              answer is dropped
                          placeholder:
                            type:
                              - string
                              - 'null'
                            maxLength: 255
                        required:
                          - type
                          - key
                          - label
                          - required
                          - placeholder
                      - type: object
                        properties:
                          type:
                            type: string
                            enum:
                              - textarea
                          key:
                            type: string
                            pattern: ^[a-z][a-z0-9_-]{0,63}$
                            description: Stable identifier of the field within its form
                          label:
                            type: string
                            minLength: 1
                            maxLength: 255
                          required:
                            type: boolean
                          showIf:
                            type: object
                            properties:
                              fieldKey:
                                type: string
                                pattern: ^[a-z][a-z0-9_-]{0,63}$
                                description: >-
                                  An earlier question whose answer decides
                                  whether this one is asked
                              anyOf:
                                type: array
                                items:
                                  type: string
                                  maxLength: 255
                                minItems: 1
                                maxItems: 100
                                description: >-
                                  Ask this question when the answer is one of
                                  these. Checkbox and consent answers compare as
                                  "true" or "false", numbers and ratings as
                                  their digits, and a pick-several answer
                                  matches when any choice is listed
                            required:
                              - fieldKey
                              - anyOf
                            description: >-
                              Ask this question only after a matching answer;
                              otherwise it is skipped, never required, and its
                              answer is dropped
                          placeholder:
                            type:
                              - string
                              - 'null'
                            maxLength: 255
                        required:
                          - type
                          - key
                          - label
                          - required
                          - placeholder
                      - type: object
                        properties:
                          type:
                            type: string
                            enum:
                              - email
                          key:
                            type: string
                            pattern: ^[a-z][a-z0-9_-]{0,63}$
                            description: Stable identifier of the field within its form
                          label:
                            type: string
                            minLength: 1
                            maxLength: 255
                          required:
                            type: boolean
                          showIf:
                            type: object
                            properties:
                              fieldKey:
                                type: string
                                pattern: ^[a-z][a-z0-9_-]{0,63}$
                                description: >-
                                  An earlier question whose answer decides
                                  whether this one is asked
                              anyOf:
                                type: array
                                items:
                                  type: string
                                  maxLength: 255
                                minItems: 1
                                maxItems: 100
                                description: >-
                                  Ask this question when the answer is one of
                                  these. Checkbox and consent answers compare as
                                  "true" or "false", numbers and ratings as
                                  their digits, and a pick-several answer
                                  matches when any choice is listed
                            required:
                              - fieldKey
                              - anyOf
                            description: >-
                              Ask this question only after a matching answer;
                              otherwise it is skipped, never required, and its
                              answer is dropped
                          placeholder:
                            type:
                              - string
                              - 'null'
                            maxLength: 255
                        required:
                          - type
                          - key
                          - label
                          - required
                          - placeholder
                      - type: object
                        properties:
                          type:
                            type: string
                            enum:
                              - phone
                          key:
                            type: string
                            pattern: ^[a-z][a-z0-9_-]{0,63}$
                            description: Stable identifier of the field within its form
                          label:
                            type: string
                            minLength: 1
                            maxLength: 255
                          required:
                            type: boolean
                          showIf:
                            type: object
                            properties:
                              fieldKey:
                                type: string
                                pattern: ^[a-z][a-z0-9_-]{0,63}$
                                description: >-
                                  An earlier question whose answer decides
                                  whether this one is asked
                              anyOf:
                                type: array
                                items:
                                  type: string
                                  maxLength: 255
                                minItems: 1
                                maxItems: 100
                                description: >-
                                  Ask this question when the answer is one of
                                  these. Checkbox and consent answers compare as
                                  "true" or "false", numbers and ratings as
                                  their digits, and a pick-several answer
                                  matches when any choice is listed
                            required:
                              - fieldKey
                              - anyOf
                            description: >-
                              Ask this question only after a matching answer;
                              otherwise it is skipped, never required, and its
                              answer is dropped
                          placeholder:
                            type:
                              - string
                              - 'null'
                            maxLength: 255
                        required:
                          - type
                          - key
                          - label
                          - required
                          - placeholder
                      - type: object
                        properties:
                          type:
                            type: string
                            enum:
                              - number
                          key:
                            type: string
                            pattern: ^[a-z][a-z0-9_-]{0,63}$
                            description: Stable identifier of the field within its form
                          label:
                            type: string
                            minLength: 1
                            maxLength: 255
                          required:
                            type: boolean
                          showIf:
                            type: object
                            properties:
                              fieldKey:
                                type: string
                                pattern: ^[a-z][a-z0-9_-]{0,63}$
                                description: >-
                                  An earlier question whose answer decides
                                  whether this one is asked
                              anyOf:
                                type: array
                                items:
                                  type: string
                                  maxLength: 255
                                minItems: 1
                                maxItems: 100
                                description: >-
                                  Ask this question when the answer is one of
                                  these. Checkbox and consent answers compare as
                                  "true" or "false", numbers and ratings as
                                  their digits, and a pick-several answer
                                  matches when any choice is listed
                            required:
                              - fieldKey
                              - anyOf
                            description: >-
                              Ask this question only after a matching answer;
                              otherwise it is skipped, never required, and its
                              answer is dropped
                          placeholder:
                            type:
                              - string
                              - 'null'
                            maxLength: 255
                          min:
                            type:
                              - number
                              - 'null'
                            description: Smallest accepted answer
                          max:
                            type:
                              - number
                              - 'null'
                            description: Largest accepted answer
                        required:
                          - type
                          - key
                          - label
                          - required
                          - placeholder
                          - min
                          - max
                      - type: object
                        properties:
                          type:
                            type: string
                            enum:
                              - date
                          key:
                            type: string
                            pattern: ^[a-z][a-z0-9_-]{0,63}$
                            description: Stable identifier of the field within its form
                          label:
                            type: string
                            minLength: 1
                            maxLength: 255
                          required:
                            type: boolean
                          showIf:
                            type: object
                            properties:
                              fieldKey:
                                type: string
                                pattern: ^[a-z][a-z0-9_-]{0,63}$
                                description: >-
                                  An earlier question whose answer decides
                                  whether this one is asked
                              anyOf:
                                type: array
                                items:
                                  type: string
                                  maxLength: 255
                                minItems: 1
                                maxItems: 100
                                description: >-
                                  Ask this question when the answer is one of
                                  these. Checkbox and consent answers compare as
                                  "true" or "false", numbers and ratings as
                                  their digits, and a pick-several answer
                                  matches when any choice is listed
                            required:
                              - fieldKey
                              - anyOf
                            description: >-
                              Ask this question only after a matching answer;
                              otherwise it is skipped, never required, and its
                              answer is dropped
                        required:
                          - type
                          - key
                          - label
                          - required
                      - type: object
                        properties:
                          type:
                            type: string
                            enum:
                              - rating
                          key:
                            type: string
                            pattern: ^[a-z][a-z0-9_-]{0,63}$
                            description: Stable identifier of the field within its form
                          label:
                            type: string
                            minLength: 1
                            maxLength: 255
                          required:
                            type: boolean
                          showIf:
                            type: object
                            properties:
                              fieldKey:
                                type: string
                                pattern: ^[a-z][a-z0-9_-]{0,63}$
                                description: >-
                                  An earlier question whose answer decides
                                  whether this one is asked
                              anyOf:
                                type: array
                                items:
                                  type: string
                                  maxLength: 255
                                minItems: 1
                                maxItems: 100
                                description: >-
                                  Ask this question when the answer is one of
                                  these. Checkbox and consent answers compare as
                                  "true" or "false", numbers and ratings as
                                  their digits, and a pick-several answer
                                  matches when any choice is listed
                            required:
                              - fieldKey
                              - anyOf
                            description: >-
                              Ask this question only after a matching answer;
                              otherwise it is skipped, never required, and its
                              answer is dropped
                          scale:
                            anyOf:
                              - type: number
                                enum:
                                  - 5
                              - type: number
                                enum:
                                  - 10
                            description: The answer is a whole number from 1 to this
                        required:
                          - type
                          - key
                          - label
                          - required
                          - scale
                      - type: object
                        properties:
                          type:
                            type: string
                            enum:
                              - select
                          key:
                            type: string
                            pattern: ^[a-z][a-z0-9_-]{0,63}$
                            description: Stable identifier of the field within its form
                          label:
                            type: string
                            minLength: 1
                            maxLength: 255
                          required:
                            type: boolean
                          showIf:
                            type: object
                            properties:
                              fieldKey:
                                type: string
                                pattern: ^[a-z][a-z0-9_-]{0,63}$
                                description: >-
                                  An earlier question whose answer decides
                                  whether this one is asked
                              anyOf:
                                type: array
                                items:
                                  type: string
                                  maxLength: 255
                                minItems: 1
                                maxItems: 100
                                description: >-
                                  Ask this question when the answer is one of
                                  these. Checkbox and consent answers compare as
                                  "true" or "false", numbers and ratings as
                                  their digits, and a pick-several answer
                                  matches when any choice is listed
                            required:
                              - fieldKey
                              - anyOf
                            description: >-
                              Ask this question only after a matching answer;
                              otherwise it is skipped, never required, and its
                              answer is dropped
                          options:
                            type: array
                            items:
                              type: string
                              minLength: 1
                              maxLength: 255
                            minItems: 1
                            maxItems: 100
                          multiple:
                            type: boolean
                            description: >-
                              Lets the visitor pick several; the answer is then
                              a list
                          optionImageUrls:
                            type: object
                            additionalProperties:
                              type: string
                              format: uri
                            description: >-
                              A picture to show on each choice, keyed by option
                              text
                        required:
                          - type
                          - key
                          - label
                          - required
                          - options
                      - type: object
                        properties:
                          type:
                            type: string
                            enum:
                              - checkbox
                          key:
                            type: string
                            pattern: ^[a-z][a-z0-9_-]{0,63}$
                            description: Stable identifier of the field within its form
                          label:
                            type: string
                            minLength: 1
                            maxLength: 255
                          required:
                            type: boolean
                          showIf:
                            type: object
                            properties:
                              fieldKey:
                                type: string
                                pattern: ^[a-z][a-z0-9_-]{0,63}$
                                description: >-
                                  An earlier question whose answer decides
                                  whether this one is asked
                              anyOf:
                                type: array
                                items:
                                  type: string
                                  maxLength: 255
                                minItems: 1
                                maxItems: 100
                                description: >-
                                  Ask this question when the answer is one of
                                  these. Checkbox and consent answers compare as
                                  "true" or "false", numbers and ratings as
                                  their digits, and a pick-several answer
                                  matches when any choice is listed
                            required:
                              - fieldKey
                              - anyOf
                            description: >-
                              Ask this question only after a matching answer;
                              otherwise it is skipped, never required, and its
                              answer is dropped
                        required:
                          - type
                          - key
                          - label
                          - required
                      - type: object
                        properties:
                          type:
                            type: string
                            enum:
                              - consent
                          key:
                            type: string
                            pattern: ^[a-z][a-z0-9_-]{0,63}$
                            description: Stable identifier of the field within its form
                          label:
                            type: string
                            minLength: 1
                            maxLength: 255
                          required:
                            type: boolean
                          showIf:
                            type: object
                            properties:
                              fieldKey:
                                type: string
                                pattern: ^[a-z][a-z0-9_-]{0,63}$
                                description: >-
                                  An earlier question whose answer decides
                                  whether this one is asked
                              anyOf:
                                type: array
                                items:
                                  type: string
                                  maxLength: 255
                                minItems: 1
                                maxItems: 100
                                description: >-
                                  Ask this question when the answer is one of
                                  these. Checkbox and consent answers compare as
                                  "true" or "false", numbers and ratings as
                                  their digits, and a pick-several answer
                                  matches when any choice is listed
                            required:
                              - fieldKey
                              - anyOf
                            description: >-
                              Ask this question only after a matching answer;
                              otherwise it is skipped, never required, and its
                              answer is dropped
                        required:
                          - type
                          - key
                          - label
                          - required
                      - type: object
                        properties:
                          type:
                            type: string
                            enum:
                              - file
                          key:
                            type: string
                            pattern: ^[a-z][a-z0-9_-]{0,63}$
                            description: Stable identifier of the field within its form
                          label:
                            type: string
                            minLength: 1
                            maxLength: 255
                          required:
                            type: boolean
                          showIf:
                            type: object
                            properties:
                              fieldKey:
                                type: string
                                pattern: ^[a-z][a-z0-9_-]{0,63}$
                                description: >-
                                  An earlier question whose answer decides
                                  whether this one is asked
                              anyOf:
                                type: array
                                items:
                                  type: string
                                  maxLength: 255
                                minItems: 1
                                maxItems: 100
                                description: >-
                                  Ask this question when the answer is one of
                                  these. Checkbox and consent answers compare as
                                  "true" or "false", numbers and ratings as
                                  their digits, and a pick-several answer
                                  matches when any choice is listed
                            required:
                              - fieldKey
                              - anyOf
                            description: >-
                              Ask this question only after a matching answer;
                              otherwise it is skipped, never required, and its
                              answer is dropped
                        required:
                          - type
                          - key
                          - label
                          - required
                      - type: object
                        properties:
                          type:
                            type: string
                            enum:
                              - hidden
                          key:
                            type: string
                            pattern: ^[a-z][a-z0-9_-]{0,63}$
                            description: Stable identifier of the field within its form
                          label:
                            type: string
                            minLength: 1
                            maxLength: 255
                          required:
                            type: boolean
                          showIf:
                            type: object
                            properties:
                              fieldKey:
                                type: string
                                pattern: ^[a-z][a-z0-9_-]{0,63}$
                                description: >-
                                  An earlier question whose answer decides
                                  whether this one is asked
                              anyOf:
                                type: array
                                items:
                                  type: string
                                  maxLength: 255
                                minItems: 1
                                maxItems: 100
                                description: >-
                                  Ask this question when the answer is one of
                                  these. Checkbox and consent answers compare as
                                  "true" or "false", numbers and ratings as
                                  their digits, and a pick-several answer
                                  matches when any choice is listed
                            required:
                              - fieldKey
                              - anyOf
                            description: >-
                              Ask this question only after a matching answer;
                              otherwise it is skipped, never required, and its
                              answer is dropped
                        required:
                          - type
                          - key
                          - label
                          - required
                        description: >-
                          Never shown; filled from a link parameter with the
                          field's key, or from code
                      - type: object
                        properties:
                          type:
                            type: string
                            enum:
                              - section
                          key:
                            type: string
                            pattern: ^[a-z][a-z0-9_-]{0,63}$
                            description: Stable identifier of the field within its form
                          label:
                            type: string
                            minLength: 1
                            maxLength: 255
                            description: The step's title
                          required:
                            type: boolean
                            enum:
                              - false
                        required:
                          - type
                          - key
                          - label
                          - required
                        description: >-
                          Starts a new step; every question up to the next
                          section is one step. Never answered
                      - type: object
                        properties:
                          type:
                            type: string
                            enum:
                              - slot
                          key:
                            type: string
                            pattern: ^[a-z][a-z0-9_-]{0,63}$
                            description: Stable identifier of the field within its form
                          label:
                            type: string
                            minLength: 1
                            maxLength: 255
                          required:
                            type: boolean
                          showIf:
                            type: object
                            properties:
                              fieldKey:
                                type: string
                                pattern: ^[a-z][a-z0-9_-]{0,63}$
                                description: >-
                                  An earlier question whose answer decides
                                  whether this one is asked
                              anyOf:
                                type: array
                                items:
                                  type: string
                                  maxLength: 255
                                minItems: 1
                                maxItems: 100
                                description: >-
                                  Ask this question when the answer is one of
                                  these. Checkbox and consent answers compare as
                                  "true" or "false", numbers and ratings as
                                  their digits, and a pick-several answer
                                  matches when any choice is listed
                            required:
                              - fieldKey
                              - anyOf
                            description: >-
                              Ask this question only after a matching answer;
                              otherwise it is skipped, never required, and its
                              answer is dropped
                          bookableKey:
                            type: string
                            minLength: 1
                            maxLength: 120
                          routing:
                            type: object
                            properties:
                              fieldKey:
                                type: string
                                pattern: ^[a-z][a-z0-9_-]{0,63}$
                                description: An earlier one-answer multiple-choice question
                              bookableKeys:
                                type: object
                                additionalProperties:
                                  type: string
                                  minLength: 1
                                  maxLength: 120
                                description: >-
                                  The service to book for each choice; a choice
                                  not listed books the field's own bookableKey
                            required:
                              - fieldKey
                              - bookableKeys
                            description: >-
                              Book a different service depending on an earlier
                              answer
                        required:
                          - type
                          - key
                          - label
                          - required
                          - bookableKey
                    description: One input on a form
                  maxItems: 50
                  description: The questions, in order; up to 50
                notifyEmails:
                  type: array
                  items:
                    type: string
                    format: email
                  maxItems: 20
                  description: >-
                    People on the project who get an email for each new
                    response; you if left out
                uniqueFieldKeys:
                  type: array
                  items:
                    type: string
                  maxItems: 5
                  description: >-
                    Fields that identify a repeat entry, such as email; a repeat
                    returns the first entry and sends nothing
                destinations:
                  type: object
                  properties:
                    klaviyoMetricName:
                      type:
                        - string
                        - 'null'
                      minLength: 1
                      maxLength: 120
                    webhookUrl:
                      type:
                        - string
                        - 'null'
                      format: uri
                  description: >-
                    Where responses are forwarded; set webhookUrl, then call
                    replo_forms_webhook_secret_rotate to get the signing secret
                closesAt:
                  type:
                    - string
                    - 'null'
                  format: date-time
                  description: When the form stops taking responses; null never closes
                responseLimit:
                  type:
                    - integer
                    - 'null'
                  minimum: 1
                  maximum: 1000000
                  description: How many responses the form takes; null has no limit
                successMessage:
                  type:
                    - string
                    - 'null'
                  maxLength: 2000
                  description: >-
                    The thank-you message; {field_key} is replaced with that
                    answer, null uses the site's own
              required:
                - projectId
                - key
                - name
                - fields
              additionalProperties: false
      responses:
        '201':
          description: Create a form
          content:
            application/json:
              schema:
                type: object
                properties:
                  object:
                    type: string
                    enum:
                      - form
                  id:
                    type: string
                    format: uuid
                  projectId:
                    type: string
                    format: uuid
                  key:
                    type: string
                  name:
                    type: string
                  status:
                    type: string
                    enum:
                      - draft
                      - live
                      - archived
                  fields:
                    type: array
                    items:
                      oneOf:
                        - type: object
                          properties:
                            type:
                              type: string
                              enum:
                                - text
                            key:
                              type: string
                              pattern: ^[a-z][a-z0-9_-]{0,63}$
                              description: Stable identifier of the field within its form
                            label:
                              type: string
                              minLength: 1
                              maxLength: 255
                            required:
                              type: boolean
                            showIf:
                              type: object
                              properties:
                                fieldKey:
                                  type: string
                                  pattern: ^[a-z][a-z0-9_-]{0,63}$
                                  description: >-
                                    An earlier question whose answer decides
                                    whether this one is asked
                                anyOf:
                                  type: array
                                  items:
                                    type: string
                                    maxLength: 255
                                  minItems: 1
                                  maxItems: 100
                                  description: >-
                                    Ask this question when the answer is one of
                                    these. Checkbox and consent answers compare
                                    as "true" or "false", numbers and ratings as
                                    their digits, and a pick-several answer
                                    matches when any choice is listed
                              required:
                                - fieldKey
                                - anyOf
                              description: >-
                                Ask this question only after a matching answer;
                                otherwise it is skipped, never required, and its
                                answer is dropped
                            placeholder:
                              type:
                                - string
                                - 'null'
                              maxLength: 255
                          required:
                            - type
                            - key
                            - label
                            - required
                            - placeholder
                        - type: object
                          properties:
                            type:
                              type: string
                              enum:
                                - textarea
                            key:
                              type: string
                              pattern: ^[a-z][a-z0-9_-]{0,63}$
                              description: Stable identifier of the field within its form
                            label:
                              type: string
                              minLength: 1
                              maxLength: 255
                            required:
                              type: boolean
                            showIf:
                              type: object
                              properties:
                                fieldKey:
                                  type: string
                                  pattern: ^[a-z][a-z0-9_-]{0,63}$
                                  description: >-
                                    An earlier question whose answer decides
                                    whether this one is asked
                                anyOf:
                                  type: array
                                  items:
                                    type: string
                                    maxLength: 255
                                  minItems: 1
                                  maxItems: 100
                                  description: >-
                                    Ask this question when the answer is one of
                                    these. Checkbox and consent answers compare
                                    as "true" or "false", numbers and ratings as
                                    their digits, and a pick-several answer
                                    matches when any choice is listed
                              required:
                                - fieldKey
                                - anyOf
                              description: >-
                                Ask this question only after a matching answer;
                                otherwise it is skipped, never required, and its
                                answer is dropped
                            placeholder:
                              type:
                                - string
                                - 'null'
                              maxLength: 255
                          required:
                            - type
                            - key
                            - label
                            - required
                            - placeholder
                        - type: object
                          properties:
                            type:
                              type: string
                              enum:
                                - email
                            key:
                              type: string
                              pattern: ^[a-z][a-z0-9_-]{0,63}$
                              description: Stable identifier of the field within its form
                            label:
                              type: string
                              minLength: 1
                              maxLength: 255
                            required:
                              type: boolean
                            showIf:
                              type: object
                              properties:
                                fieldKey:
                                  type: string
                                  pattern: ^[a-z][a-z0-9_-]{0,63}$
                                  description: >-
                                    An earlier question whose answer decides
                                    whether this one is asked
                                anyOf:
                                  type: array
                                  items:
                                    type: string
                                    maxLength: 255
                                  minItems: 1
                                  maxItems: 100
                                  description: >-
                                    Ask this question when the answer is one of
                                    these. Checkbox and consent answers compare
                                    as "true" or "false", numbers and ratings as
                                    their digits, and a pick-several answer
                                    matches when any choice is listed
                              required:
                                - fieldKey
                                - anyOf
                              description: >-
                                Ask this question only after a matching answer;
                                otherwise it is skipped, never required, and its
                                answer is dropped
                            placeholder:
                              type:
                                - string
                                - 'null'
                              maxLength: 255
                          required:
                            - type
                            - key
                            - label
                            - required
                            - placeholder
                        - type: object
                          properties:
                            type:
                              type: string
                              enum:
                                - phone
                            key:
                              type: string
                              pattern: ^[a-z][a-z0-9_-]{0,63}$
                              description: Stable identifier of the field within its form
                            label:
                              type: string
                              minLength: 1
                              maxLength: 255
                            required:
                              type: boolean
                            showIf:
                              type: object
                              properties:
                                fieldKey:
                                  type: string
                                  pattern: ^[a-z][a-z0-9_-]{0,63}$
                                  description: >-
                                    An earlier question whose answer decides
                                    whether this one is asked
                                anyOf:
                                  type: array
                                  items:
                                    type: string
                                    maxLength: 255
                                  minItems: 1
                                  maxItems: 100
                                  description: >-
                                    Ask this question when the answer is one of
                                    these. Checkbox and consent answers compare
                                    as "true" or "false", numbers and ratings as
                                    their digits, and a pick-several answer
                                    matches when any choice is listed
                              required:
                                - fieldKey
                                - anyOf
                              description: >-
                                Ask this question only after a matching answer;
                                otherwise it is skipped, never required, and its
                                answer is dropped
                            placeholder:
                              type:
                                - string
                                - 'null'
                              maxLength: 255
                          required:
                            - type
                            - key
                            - label
                            - required
                            - placeholder
                        - type: object
                          properties:
                            type:
                              type: string
                              enum:
                                - number
                            key:
                              type: string
                              pattern: ^[a-z][a-z0-9_-]{0,63}$
                              description: Stable identifier of the field within its form
                            label:
                              type: string
                              minLength: 1
                              maxLength: 255
                            required:
                              type: boolean
                            showIf:
                              type: object
                              properties:
                                fieldKey:
                                  type: string
                                  pattern: ^[a-z][a-z0-9_-]{0,63}$
                                  description: >-
                                    An earlier question whose answer decides
                                    whether this one is asked
                                anyOf:
                                  type: array
                                  items:
                                    type: string
                                    maxLength: 255
                                  minItems: 1
                                  maxItems: 100
                                  description: >-
                                    Ask this question when the answer is one of
                                    these. Checkbox and consent answers compare
                                    as "true" or "false", numbers and ratings as
                                    their digits, and a pick-several answer
                                    matches when any choice is listed
                              required:
                                - fieldKey
                                - anyOf
                              description: >-
                                Ask this question only after a matching answer;
                                otherwise it is skipped, never required, and its
                                answer is dropped
                            placeholder:
                              type:
                                - string
                                - 'null'
                              maxLength: 255
                            min:
                              type:
                                - number
                                - 'null'
                              description: Smallest accepted answer
                            max:
                              type:
                                - number
                                - 'null'
                              description: Largest accepted answer
                          required:
                            - type
                            - key
                            - label
                            - required
                            - placeholder
                            - min
                            - max
                        - type: object
                          properties:
                            type:
                              type: string
                              enum:
                                - date
                            key:
                              type: string
                              pattern: ^[a-z][a-z0-9_-]{0,63}$
                              description: Stable identifier of the field within its form
                            label:
                              type: string
                              minLength: 1
                              maxLength: 255
                            required:
                              type: boolean
                            showIf:
                              type: object
                              properties:
                                fieldKey:
                                  type: string
                                  pattern: ^[a-z][a-z0-9_-]{0,63}$
                                  description: >-
                                    An earlier question whose answer decides
                                    whether this one is asked
                                anyOf:
                                  type: array
                                  items:
                                    type: string
                                    maxLength: 255
                                  minItems: 1
                                  maxItems: 100
                                  description: >-
                                    Ask this question when the answer is one of
                                    these. Checkbox and consent answers compare
                                    as "true" or "false", numbers and ratings as
                                    their digits, and a pick-several answer
                                    matches when any choice is listed
                              required:
                                - fieldKey
                                - anyOf
                              description: >-
                                Ask this question only after a matching answer;
                                otherwise it is skipped, never required, and its
                                answer is dropped
                          required:
                            - type
                            - key
                            - label
                            - required
                        - type: object
                          properties:
                            type:
                              type: string
                              enum:
                                - rating
                            key:
                              type: string
                              pattern: ^[a-z][a-z0-9_-]{0,63}$
                              description: Stable identifier of the field within its form
                            label:
                              type: string
                              minLength: 1
                              maxLength: 255
                            required:
                              type: boolean
                            showIf:
                              type: object
                              properties:
                                fieldKey:
                                  type: string
                                  pattern: ^[a-z][a-z0-9_-]{0,63}$
                                  description: >-
                                    An earlier question whose answer decides
                                    whether this one is asked
                                anyOf:
                                  type: array
                                  items:
                                    type: string
                                    maxLength: 255
                                  minItems: 1
                                  maxItems: 100
                                  description: >-
                                    Ask this question when the answer is one of
                                    these. Checkbox and consent answers compare
                                    as "true" or "false", numbers and ratings as
                                    their digits, and a pick-several answer
                                    matches when any choice is listed
                              required:
                                - fieldKey
                                - anyOf
                              description: >-
                                Ask this question only after a matching answer;
                                otherwise it is skipped, never required, and its
                                answer is dropped
                            scale:
                              anyOf:
                                - type: number
                                  enum:
                                    - 5
                                - type: number
                                  enum:
                                    - 10
                              description: The answer is a whole number from 1 to this
                          required:
                            - type
                            - key
                            - label
                            - required
                            - scale
                        - type: object
                          properties:
                            type:
                              type: string
                              enum:
                                - select
                            key:
                              type: string
                              pattern: ^[a-z][a-z0-9_-]{0,63}$
                              description: Stable identifier of the field within its form
                            label:
                              type: string
                              minLength: 1
                              maxLength: 255
                            required:
                              type: boolean
                            showIf:
                              type: object
                              properties:
                                fieldKey:
                                  type: string
                                  pattern: ^[a-z][a-z0-9_-]{0,63}$
                                  description: >-
                                    An earlier question whose answer decides
                                    whether this one is asked
                                anyOf:
                                  type: array
                                  items:
                                    type: string
                                    maxLength: 255
                                  minItems: 1
                                  maxItems: 100
                                  description: >-
                                    Ask this question when the answer is one of
                                    these. Checkbox and consent answers compare
                                    as "true" or "false", numbers and ratings as
                                    their digits, and a pick-several answer
                                    matches when any choice is listed
                              required:
                                - fieldKey
                                - anyOf
                              description: >-
                                Ask this question only after a matching answer;
                                otherwise it is skipped, never required, and its
                                answer is dropped
                            options:
                              type: array
                              items:
                                type: string
                                minLength: 1
                                maxLength: 255
                              minItems: 1
                              maxItems: 100
                            multiple:
                              type: boolean
                              description: >-
                                Lets the visitor pick several; the answer is
                                then a list
                            optionImageUrls:
                              type: object
                              additionalProperties:
                                type: string
                                format: uri
                              description: >-
                                A picture to show on each choice, keyed by
                                option text
                          required:
                            - type
                            - key
                            - label
                            - required
                            - options
                        - type: object
                          properties:
                            type:
                              type: string
                              enum:
                                - checkbox
                            key:
                              type: string
                              pattern: ^[a-z][a-z0-9_-]{0,63}$
                              description: Stable identifier of the field within its form
                            label:
                              type: string
                              minLength: 1
                              maxLength: 255
                            required:
                              type: boolean
                            showIf:
                              type: object
                              properties:
                                fieldKey:
                                  type: string
                                  pattern: ^[a-z][a-z0-9_-]{0,63}$
                                  description: >-
                                    An earlier question whose answer decides
                                    whether this one is asked
                                anyOf:
                                  type: array
                                  items:
                                    type: string
                                    maxLength: 255
                                  minItems: 1
                                  maxItems: 100
                                  description: >-
                                    Ask this question when the answer is one of
                                    these. Checkbox and consent answers compare
                                    as "true" or "false", numbers and ratings as
                                    their digits, and a pick-several answer
                                    matches when any choice is listed
                              required:
                                - fieldKey
                                - anyOf
                              description: >-
                                Ask this question only after a matching answer;
                                otherwise it is skipped, never required, and its
                                answer is dropped
                          required:
                            - type
                            - key
                            - label
                            - required
                        - type: object
                          properties:
                            type:
                              type: string
                              enum:
                                - consent
                            key:
                              type: string
                              pattern: ^[a-z][a-z0-9_-]{0,63}$
                              description: Stable identifier of the field within its form
                            label:
                              type: string
                              minLength: 1
                              maxLength: 255
                            required:
                              type: boolean
                            showIf:
                              type: object
                              properties:
                                fieldKey:
                                  type: string
                                  pattern: ^[a-z][a-z0-9_-]{0,63}$
                                  description: >-
                                    An earlier question whose answer decides
                                    whether this one is asked
                                anyOf:
                                  type: array
                                  items:
                                    type: string
                                    maxLength: 255
                                  minItems: 1
                                  maxItems: 100
                                  description: >-
                                    Ask this question when the answer is one of
                                    these. Checkbox and consent answers compare
                                    as "true" or "false", numbers and ratings as
                                    their digits, and a pick-several answer
                                    matches when any choice is listed
                              required:
                                - fieldKey
                                - anyOf
                              description: >-
                                Ask this question only after a matching answer;
                                otherwise it is skipped, never required, and its
                                answer is dropped
                          required:
                            - type
                            - key
                            - label
                            - required
                        - type: object
                          properties:
                            type:
                              type: string
                              enum:
                                - file
                            key:
                              type: string
                              pattern: ^[a-z][a-z0-9_-]{0,63}$
                              description: Stable identifier of the field within its form
                            label:
                              type: string
                              minLength: 1
                              maxLength: 255
                            required:
                              type: boolean
                            showIf:
                              type: object
                              properties:
                                fieldKey:
                                  type: string
                                  pattern: ^[a-z][a-z0-9_-]{0,63}$
                                  description: >-
                                    An earlier question whose answer decides
                                    whether this one is asked
                                anyOf:
                                  type: array
                                  items:
                                    type: string
                                    maxLength: 255
                                  minItems: 1
                                  maxItems: 100
                                  description: >-
                                    Ask this question when the answer is one of
                                    these. Checkbox and consent answers compare
                                    as "true" or "false", numbers and ratings as
                                    their digits, and a pick-several answer
                                    matches when any choice is listed
                              required:
                                - fieldKey
                                - anyOf
                              description: >-
                                Ask this question only after a matching answer;
                                otherwise it is skipped, never required, and its
                                answer is dropped
                          required:
                            - type
                            - key
                            - label
                            - required
                        - type: object
                          properties:
                            type:
                              type: string
                              enum:
                                - hidden
                            key:
                              type: string
                              pattern: ^[a-z][a-z0-9_-]{0,63}$
                              description: Stable identifier of the field within its form
                            label:
                              type: string
                              minLength: 1
                              maxLength: 255
                            required:
                              type: boolean
                            showIf:
                              type: object
                              properties:
                                fieldKey:
                                  type: string
                                  pattern: ^[a-z][a-z0-9_-]{0,63}$
                                  description: >-
                                    An earlier question whose answer decides
                                    whether this one is asked
                                anyOf:
                                  type: array
                                  items:
                                    type: string
                                    maxLength: 255
                                  minItems: 1
                                  maxItems: 100
                                  description: >-
                                    Ask this question when the answer is one of
                                    these. Checkbox and consent answers compare
                                    as "true" or "false", numbers and ratings as
                                    their digits, and a pick-several answer
                                    matches when any choice is listed
                              required:
                                - fieldKey
                                - anyOf
                              description: >-
                                Ask this question only after a matching answer;
                                otherwise it is skipped, never required, and its
                                answer is dropped
                          required:
                            - type
                            - key
                            - label
                            - required
                          description: >-
                            Never shown; filled from a link parameter with the
                            field's key, or from code
                        - type: object
                          properties:
                            type:
                              type: string
                              enum:
                                - section
                            key:
                              type: string
                              pattern: ^[a-z][a-z0-9_-]{0,63}$
                              description: Stable identifier of the field within its form
                            label:
                              type: string
                              minLength: 1
                              maxLength: 255
                              description: The step's title
                            required:
                              type: boolean
                              enum:
                                - false
                          required:
                            - type
                            - key
                            - label
                            - required
                          description: >-
                            Starts a new step; every question up to the next
                            section is one step. Never answered
                        - type: object
                          properties:
                            type:
                              type: string
                              enum:
                                - slot
                            key:
                              type: string
                              pattern: ^[a-z][a-z0-9_-]{0,63}$
                              description: Stable identifier of the field within its form
                            label:
                              type: string
                              minLength: 1
                              maxLength: 255
                            required:
                              type: boolean
                            showIf:
                              type: object
                              properties:
                                fieldKey:
                                  type: string
                                  pattern: ^[a-z][a-z0-9_-]{0,63}$
                                  description: >-
                                    An earlier question whose answer decides
                                    whether this one is asked
                                anyOf:
                                  type: array
                                  items:
                                    type: string
                                    maxLength: 255
                                  minItems: 1
                                  maxItems: 100
                                  description: >-
                                    Ask this question when the answer is one of
                                    these. Checkbox and consent answers compare
                                    as "true" or "false", numbers and ratings as
                                    their digits, and a pick-several answer
                                    matches when any choice is listed
                              required:
                                - fieldKey
                                - anyOf
                              description: >-
                                Ask this question only after a matching answer;
                                otherwise it is skipped, never required, and its
                                answer is dropped
                            bookableKey:
                              type: string
                              minLength: 1
                              maxLength: 120
                            routing:
                              type: object
                              properties:
                                fieldKey:
                                  type: string
                                  pattern: ^[a-z][a-z0-9_-]{0,63}$
                                  description: >-
                                    An earlier one-answer multiple-choice
                                    question
                                bookableKeys:
                                  type: object
                                  additionalProperties:
                                    type: string
                                    minLength: 1
                                    maxLength: 120
                                  description: >-
                                    The service to book for each choice; a
                                    choice not listed books the field's own
                                    bookableKey
                              required:
                                - fieldKey
                                - bookableKeys
                              description: >-
                                Book a different service depending on an earlier
                                answer
                          required:
                            - type
                            - key
                            - label
                            - required
                            - bookableKey
                      description: One input on a form
                  notifyEmails:
                    type: array
                    items:
                      type: string
                    description: People who get an email for each new response
                  uniqueFieldKeys:
                    type: array
                    items:
                      type: string
                  closesAt:
                    type:
                      - string
                      - 'null'
                    description: Responses after this time are refused; null never closes
                  responseLimit:
                    type:
                      - integer
                      - 'null'
                    description: Responses past this count are refused; null has no limit
                  successMessage:
                    type:
                      - string
                      - 'null'
                    description: >-
                      The thank-you message; {field_key} is replaced with that
                      answer
                  destinations:
                    type: object
                    properties:
                      klaviyoMetricName:
                        type:
                          - string
                          - 'null'
                        minLength: 1
                        maxLength: 120
                      webhookUrl:
                        type:
                          - string
                          - 'null'
                        format: uri
                      webhookSecretPreview:
                        type:
                          - string
                          - 'null'
                        description: >-
                          The webhook signing secret's last characters, such as
                          whsec_…a1b2; the full secret is shown only in the
                          Forms app
                    required:
                      - webhookSecretPreview
                  createdAt:
                    type: string
                  updatedAt:
                    type: string
                required:
                  - object
                  - id
                  - projectId
                  - key
                  - name
                  - status
                  - fields
                  - notifyEmails
                  - uniqueFieldKeys
                  - closesAt
                  - responseLimit
                  - successMessage
                  - destinations
                  - createdAt
                  - updatedAt
        '400':
          description: Invalid request.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PublicApiError'
        '401':
          description: >-
            Missing or invalid Replo Public API token. Send an active key as
            `Authorization: Bearer replo_sk_...`; if it was revoked, create a
            new key in Replo Settings.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PublicApiError'
        '403':
          description: >-
            You are not authorized to access this resource. Ask a workspace
            owner to perform this action or to grant the key's creator access.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PublicApiError'
        '404':
          description: >-
            Not Found. The resource may not exist, this key may lack the
            required scope, or the key's creator may have lost access. Check the
            key's scopes in Replo Settings and the creator's project or
            workspace access; a workspace owner can grant access.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PublicApiError'
        '409':
          description: The resource is in a conflicting state.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PublicApiError'
        '413':
          description: File content exceeds the 10 MiB limit.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PublicApiError'
        '429':
          description: >-
            Too many requests. Please retry after the time indicated by the
            Retry-After header.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PublicApiError'
        '500':
          description: An internal error occurred.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PublicApiError'
        '503':
          description: Service temporarily unavailable.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PublicApiError'
      security:
        - bearerAuth: []
components:
  schemas:
    PublicApiError:
      type: object
      properties:
        error:
          type: object
          properties:
            code:
              type: string
            message:
              type: string
            doc_url:
              type: string
            issues:
              type: array
              items:
                type: object
                properties:
                  param:
                    type:
                      - string
                      - 'null'
                    description: >-
                      Dotted path to the failing field within the request body,
                      query or path, e.g. "name" or "variants.0.available"; null
                      when the rule covers the whole input.
                  message:
                    type: string
                    description: Why the field was rejected.
                required:
                  - param
                  - message
              description: >-
                Present on an invalid_request whose input failed validation:
                each failing field and why, at most 10.
          required:
            - code
            - message
            - doc_url
      required:
        - error
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer

````

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