openapi: 3.0.0
info:
  title: MICEtribe Developers
  version: 1.0.1
  description: >-
    Easy-to-use APIs are provided to technical teams to ensure smooth event
    experiece for Attendees, Exhibitors, Speakers, Sponsors and any other
    visitor.
servers:
  - url: '{{base_url}}'
paths:
  /registration:
    post:
      summary: Create/Update Registration
      responses:
        '200':
          description: registration
          headers:
            Date:
              schema:
                type: string
              example: Mon, 22 Dec 2025 13:35:46 GMT
            Transfer-Encoding:
              schema:
                type: string
              example: chunked
            Connection:
              schema:
                type: string
              example: keep-alive
            Server:
              schema:
                type: string
              example: nginx/1.18.0 (Ubuntu)
            Cache-Control:
              schema:
                type: string
              example: no-cache, private
            X-Ratelimit-Limit:
              schema:
                type: integer
              example: '30'
            X-Ratelimit-Remaining:
              schema:
                type: integer
              example: '29'
            Access-Control-Allow-Credentials:
              schema:
                type: boolean
              example: 'true'
            Access-Control-Allow-Methods:
              schema:
                type: string
              example: GET, PUT, POST, DELETE, PATCH, HEAD, OPTIONS
            Access-Control-Allow-Headers:
              schema:
                type: string
              example: '*'
            Access-Control-Expose-Headers:
              schema:
                type: string
              example: '*'
      tags:
        - Registration
      security:
        - BearerAuth: []
      description: >-
        You can use reigstration api to create or update registrations on any
        persona on your event.  

        Same API is used to create indivisual and group registration.


        First, you need to create persona on MICEtribe event and add all fileds
        along with their settings then you can use the API to push to your
        event.  

        Create registration API require the following params:


        - **persona**: it's <u>required</u> param to pass to the API. It is the
        slug of the persona you want to push to.
            
        - **fields**: it's <u>required</u> param to pass to create or update
        registrations. It contains array of json of the fields matching
        MICEtribe persona fields settings.
            
        - **barcode**: this is <u>optional</u> field that is used to replace
        MICEtribe QR code with barcode sent via api
            
        - **parent_barcode**: this is <u>optional</u> fields that is used to
        create this registration as member of another registration. (it's used
        for **group registration**)
            
        - **enable_comms:** this is <u>optional</u> filed that is used to enable
        sending communications via system, currently email and SMS communication
        are supported. Default value for it is false. to turn it on, pass
        boolean **true** value to the field.
            

        **Fields validations:**


        - phone_number field must have at least 5 charachters and be in
        international format so it should start with 00 or +. Successful
        examples of phone number are e.g 0097466666666 or +97466666666 or
        97466666666
            
        - email field must have valid email format and valid DNS
            
        - country field accepts ISO 2-letter code, ISO 3-letter code
            
        - website field shuld be valid URL format
            
        - upload field must have valie url for uploaded file
            
        - date field must be in this format yyyy-mm-dd and it can has time e.g
        yyyy-mm-dd hh:MM:ss
            
        - numberic field must have numbers only
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties:
                persona:
                  type: string
                fields:
                  type: object
                  properties:
                    fullname:
                      type: string
                    email:
                      type: string
                      format: email
                    phone:
                      type: string
                      format: utc-millisec
                    job_title:
                      type: string
                    upload:
                      type: string
                      format: uri
                    organization:
                      type: string
                    country:
                      type: string
                barcode:
                  type: string
            example:
              persona: visitor
              fields:
                fullname: John Does
                email: test@micetribe.com
                phone: '974466666666'
                job_title: Software engineer
                upload: >-
                  https://plan.staging.micetribe.com/assets/images/logoWithoutText.svg
                organization: MICEtribe Company
                country: QAT
              barcode: TPBHJ4GY
    get:
      summary: Get Registrations
      parameters:
        - name: page
          in: query
          required: false
          description: Page number for pagination.
          deprecated: false
          schema: {}
          example: '1'
        - name: per_page
          in: query
          required: false
          description: Number of records to return per page (max 100)
          deprecated: false
          schema: {}
          example: '5'
        - name: pesona
          in: query
          required: false
          description: Persona slug you need to get records for
          deprecated: false
          schema: {}
          example: visitor
        - name: barcode
          in: query
          required: false
          description: The registration barcode to get records for
          deprecated: false
          schema: {}
          example: 0IG6XSAD
        - name: Accept-Encoding
          in: header
          required: false
          deprecated: false
          schema: {}
          example: application/json
      responses: {}
      tags:
        - Registration
      security:
        - BearerAuth: []
      description: >-
        ## Registration - List Registrations


        Retrieves a paginated list of registration records. Useful for admin
        dashboards and reporting.


        ### Method & URL


        - GET `{{base_url}}/registration`
            

        ### Query Parameters


        - `page` (number, optional) — Page number to fetch. Defaults to `1`.
            
        - `per_page` (number, optional) — Items per page. Common values: `5`,
        `20`. Defaults to `5`.
            
        - `persona` (string, optional) — Filter by user persona. Example:
        `visitor`.
            
        - `barcode` (string, optional) — Filter by barcode. Example: `0IG6XSAD`.
            

        ### Headers


        - `Accept: application/json`
            
        - `Accept-Encoding: application/json`
            

        ### Authentication


        - Uses environment variable `{{token}}` if your API requires Bearer or
        API key auth. Ensure the active environment (e.g., Sandbox or Live) has
        this value set.
            

        ### Variables


        - `{{base_url}}` — Base host for the API, provided by the active
        environment.
            

        ### Expected Responses


        - 200 OK — Returns an array of registration objects with pagination
        metadata.
            
        - 400/422 — Validation errors for bad parameters.
            
        - 401 — Missing/invalid credentials if the endpoint is protected.
            

        ### Usage Notes


        - Combine `persona` and `barcode` to narrow results.
            
        - Use smaller `per_page` during development to limit payload size.
            

        ### Examples


        - `GET {{base_url}}registration?page=1&per_page=5` — First page with 5
        items.
            
        - `GET {{base_url}}registration?page=3&per_page=20&persona=visitor` —
        Third page, filtered by persona.
            
        - `GET {{base_url}}registration?barcode=34DD490` — Filter by person
        barcode
      requestBody:
        content:
          application/json:
            schema:
              type: object
  /registration/{registratoin_id}:
    delete:
      summary: Delete Registration
      parameters:
        - name: Accept-Encoding
          in: header
          required: false
          deprecated: false
          schema: {}
          example: application/json
      responses:
        '200':
          description: registration
          headers:
            Date:
              schema:
                type: string
              example: Mon, 22 Dec 2025 13:36:18 GMT
            Transfer-Encoding:
              schema:
                type: string
              example: chunked
            Connection:
              schema:
                type: string
              example: keep-alive
            Server:
              schema:
                type: string
              example: nginx/1.18.0 (Ubuntu)
            Cache-Control:
              schema:
                type: string
              example: no-cache, private
            X-Ratelimit-Limit:
              schema:
                type: integer
              example: '30'
            X-Ratelimit-Remaining:
              schema:
                type: integer
              example: '28'
            Access-Control-Allow-Credentials:
              schema:
                type: boolean
              example: 'true'
            Access-Control-Allow-Methods:
              schema:
                type: string
              example: GET, PUT, POST, DELETE, PATCH, HEAD, OPTIONS
            Access-Control-Allow-Headers:
              schema:
                type: string
              example: '*'
            Access-Control-Expose-Headers:
              schema:
                type: string
              example: '*'
      tags:
        - Registration
      security:
        - BearerAuth: []
      description: Delete api can delete any registration in the allowed event.
      requestBody:
        content:
          application/json:
            schema:
              type: object
    parameters:
      - name: registratoin_id
        in: path
        required: true
        schema:
          type: string
        example: '{{registratoin_id}}'
  /event:
    get:
      summary: Get Event
      parameters:
        - name: Accept-Encoding
          in: header
          required: false
          deprecated: false
          schema: {}
          example: application/json
      responses:
        '200':
          description: event
          headers:
            Date:
              schema:
                type: string
              example: Mon, 22 Dec 2025 13:36:53 GMT
            Transfer-Encoding:
              schema:
                type: string
              example: chunked
            Connection:
              schema:
                type: string
              example: keep-alive
            Server:
              schema:
                type: string
              example: nginx/1.18.0 (Ubuntu)
            Cache-Control:
              schema:
                type: string
              example: no-cache, private
            X-Ratelimit-Limit:
              schema:
                type: integer
              example: '30'
            X-Ratelimit-Remaining:
              schema:
                type: integer
              example: '29'
            Access-Control-Allow-Credentials:
              schema:
                type: boolean
              example: 'true'
            Access-Control-Allow-Methods:
              schema:
                type: string
              example: GET, PUT, POST, DELETE, PATCH, HEAD, OPTIONS
            Access-Control-Allow-Headers:
              schema:
                type: string
              example: '*'
            Access-Control-Expose-Headers:
              schema:
                type: string
              example: '*'
      tags:
        - Event
      security:
        - BearerAuth: []
      description: >-
        **Purpose**  

        Retrieve metadata for the active event, including key details (id, slug,
        name, timezone, start/end) and the available personas with their
        registration fields. Useful for client apps to configure flows and
        validate registration inputs.


        **Endpoint and Method**


        - Method: GET
            
        - URL: {{base_url}}event
            

        **Path/URL Variables**


        - None. The base URL is parameterized via {{base_url}} in your active
        environment.
            

        **Headers**


        - Accept: application/json
            
        - Accept-Encoding: application/json
            

        **Authentication**


        - If the API requires auth, use a Bearer token variable. Configure at
        the folder/collection level or request level:
            
            - Type: Bearer Token
                
            - Token: {{token}}
                
        - If auth is inherited from the collection/folder, no per-request
        changes are needed here.
            

        **Sample Success Response (200) — summarized**  

        `{ "event_id": 6200,`


        `"slug": "mobapp",`


        `"name": "vFairs Mobile app integration",`


        `"timezone": "Asia/Qatar",`


        `"start_date": "2025-11-09T10:00:00+03:00",`


        `"end_date": "2025-11-30T22:00:00+03:00",`


        `"personas": [ {`


        `"id": 15910, "slug": "visitor", "name": "Visitor",`


        `"fields": [ { "id": 323339, "slug": "fullname", "label": "Full name",
        "type": "Name" }, { "id": 323340, "slug": "email", "label": "E-mail",
        "type": "E-mail" }, { "id": 323341, "slug": "phone", "label": "Phone
        number", "type": "Phone number" }`


        `] }, // Additional personas such as exhibitor, speaker, vip, media,
        etc. ] }`  


        Key fields: event_id, slug, name, timezone, start_date, end_date.
        Personas is an array; each persona has id, slug, name, and fields\[\]. A
        field has id, slug, label, type, and optional values (e.g., radio
        options).


        **Response Codes**


        - 200 OK: Event metadata returned successfully.
            
        - 400 Bad Request: Invalid query parameter(s).
            
        - 401 Unauthorized: Missing/invalid token when authentication is
        enforced.
            
        - 404 Not Found: Event not available.
            
        - 5xx Server Error: Unexpected server-side issue.
            

        Usage Tips (Environments and Variables)


        - Set {{base_url}} in your active environment (e.g., Sandbox) to target
        the appropriate host.
            
        - Store {{token}} in the same environment and configure Authorization to
        inherit Bearer token.
            
        - Use examples above for query parameters; toggle them in the Params tab
        as needed.
            
        - Do not modify method, URL, or headers when using this request unless
        your API variant requires it.
      requestBody:
        content:
          application/json:
            schema:
              type: object
components:
  securitySchemes:
    BearerAuth:
      type: http
      scheme: bearer
security:
  - BearerAuth: []
