API access

VoiceBooker provides programmatic API access for integrating with other applications and automating workflows such as usage retrieval, bot deployment, and CI/CD pipeline integration.

Base URL

For the VoiceBooker production instance, use:

https://voicebooker.de/app/api/v1

Authentication

Create an API token for the business in VoiceBooker and send it with every request using this header:

X-API-TOKEN: <your-api-token>

Keep the token private. It determines the business context for the request; the endpoints do not accept an arbitrary business ID to establish access.

Export a bot

GET /exportBots/{botId} exports a bot that belongs to the business associated with the API token. The response contains the bot definition and its stages and can be used as input for /importBots.

Optional query parameters:

pretty=true returns a human-readable HJSON document.

curl --get 'https://voicebooker.de/app/api/v1/exportBots/<bot-id>' \
  --header 'X-API-TOKEN: <your-api-token>' \
  --data-urlencode 'pretty=true'

Example response:

{
  "name": "Reception assistant",
  "id": "kqrmxaveli",
  "stages": [
    {
      "name": "Welcome",
      "id": "mavotirenu",
      "linkId": "qeluzanopi",
      "template": false,
      "prompt": "Welcome the caller.",
      "tools": [],
      "functions": [],
      "settings": {},
      "stageConfig": [],
      "x": 0,
      "y": 0,
      "order": 0,
      "instanceSettings": {}
    }
  ],
  "settings": {},
  "wizard": {}
}

POST /importBots imports a bot definition into the business associated with the API token. Send the exported object as the contents parameter. JSON objects can be sent directly; HJSON content can be sent by setting filename to a name ending in .hjson.

The optional flags are:

overwriteBotStages=true replaces the existing bot with the same name.
overwriteTemplates=true imports template stages instead of reusing existing templates.
replaceBotStages=true updates the bot identified by the exported id rather than creating a new bot.

curl --request POST \
  --url https://voicebooker.de/app/api/v1/importBots \
  --header 'X-API-TOKEN: <your-api-token>' \
  --header 'Content-Type: application/json' \
  --data '{
    "filename": "reception-assistant.json",
    "contents": {"name": "Reception assistant", "settings": {}, "stages": []},
    "overwriteBotStages": false,
    "overwriteTemplates": false,
    "replaceBotStages": false
  }'

Example response:

{
  "id": "vexorimaku",
  "name": "Reception assistant",
  "settings": {},
  "invisible": false
}

Place outbound calls

You can place an outbound call by sending a POST request to:

https://voicebooker.de/app/api/v1/makeCall

Use the following headers:

Content-Type: application/json
X-API-TOKEN: <your-api-token>

Example request:

{
  "dest": "+49-351-123456789",
  "botId": "kqrmxaveli",
  "sipAccountId": "lupenakori",
  "ringTimeout": 25,
  "startTimeout": 10,
  "state": {
    "customerId": "zpjwletodo"
  }
}

Parameter	Description
`dest`	Number to call in E.164 format.
`botId`	Bot used for the call.
`sipAccountId`	SIP account used to place the call. Its number is shown to the callee.
`ringTimeout`	Seconds to ring before cancelling when nobody answers. Default: 30 seconds.
`startTimeout`	Seconds to wait before the bot starts speaking, allowing the callee to speak first.
`state`	Data that can be passed to webhooks or API calls during the call, such as a customer ID.

The REST API returns a callId, which can be used with webhooks triggered when the call succeeds or fails:

{
  "callId": "xavurimeto"
}

Manage bot tests

Bot tests compare a source/calling bot with a destination/responding bot. API-key requests are scoped to the business associated with the token; both referenced bots must belong to that business.

The bot-test endpoints are:

Method	Endpoint	Purpose
`GET`	`/bot_test_setups`	List bot tests.
`POST`	`/bot_test_setups`	Create a bot test.
`PUT`	`/bot_test_setups/{id}`	Update a bot test.
`DELETE`	`/bot_test_setups/{id}`	Delete a bot test.

Example response:

{
  "id": "xavurimeto",
  "name": "Reception replay",
  "settings": {
    "convInitBot": true,
    "maxConvTurns": 30,
    "asCall": false,
    "startTimeout": 0,
    "stateUpdate": {}
  },
  "srcBotId": "kqrmxaveli",
  "destBotId": "vexorimaku"
}

Create a test:

curl --request POST \
  --url https://voicebooker.de/app/api/v1/bot_test_setups \
  --header 'X-API-TOKEN: <your-api-token>' \
  --header 'Content-Type: application/json' \
  --data '{
    "name": "Reception replay",
    "srcBotId": "kqrmxaveli",
    "destBotId": "vexorimaku",
    "settings": {
      "convInitBot": true,
      "maxConvTurns": 30,
      "asCall": false,
      "startTimeout": 0,
      "stateUpdate": {}
    }
  }'

Updates accept any subset of name, settings, srcBotId, and destBotId; omitted fields are preserved. The endpoint returns 403 Forbidden if either referenced bot is outside the token's business or if both references are the same bot.

Fetch a call recording

GET /getRecording/{id} returns the MP3 recording for a call session. Use the call-session ID returned by the usage endpoint as id. Recording must have been enabled for the call.

The response is streamed as audio/mpeg and can be saved directly to an .mp3 file:

curl --request GET \
  --url https://voicebooker.de/app/api/v1/getRecording/<call-session-id> \
  --header 'X-API-TOKEN: <your-api-token>' \
  --output recording.mp3

The endpoint returns 404 Not Found when the call session does not exist, is outside the API token's business scope, or has no available recording. It returns 401 Unauthorized when the API token is missing or invalid.

List call sessions and retrieve transcripts

Use GET /call_sessions to list call sessions, or GET /conversations to list sessions that have visible transcripts. In list mode, both endpoints require start and end dates and return 30 items per page by default. The call field indicates whether a session is a phone call. For example:

curl --get https://voicebooker.de/app/api/v1/call_sessions \
  --header 'X-API-TOKEN: <your-api-token>' \
  --data-urlencode 'start=2026-01-01' \
  --data-urlencode 'end=2026-01-31' \
  --data-urlencode 'page=1'

Use the call-session ID from either list to retrieve one transcript (cs.id in /call_sessions and id in /conversations):

curl --get 'https://voicebooker.de/app/api/v1/conversations/<call-session-id>' \
  --header 'X-API-TOKEN: <your-api-token>' \
  --data-urlencode 'trace=true' \
  --data-urlencode 'page=1'

Set trace=true to return up to 1,000 chronological transcript turns per page, including available prompt, state, stack, and fsCalls function/webhook details. Omit trace for the standard 30-item page. Use page to retrieve later pages. Requests are limited to the businesses available to the API token.

For a compact transcript when you already know the telephony context ID, use GET /conversations?contextUId=<context-id>.

Retrieve usage

GET /usage returns call and chat session usage for the authenticated business and its available partner businesses.

Without a businessId, the response contains usage for all businesses in that scope. Use businessId to retrieve usage for one business, and use start and end to filter by the session creation time.

curl --get https://voicebooker.de/app/api/v1/usage \
  --header 'X-API-TOKEN: <your-api-token>' \
  --data-urlencode 'businessId=zpjwletodo' \
  --data-urlencode 'start=2026-01-01T00:00:00Z' \
  --data-urlencode 'end=2026-02-01T00:00:00Z'

start is inclusive and end is inclusive. Date-time values should be parseable ISO 8601 values. The businessId must be returned by /partnerClients or belong to the authenticated business; using a business outside the token's scope returns 403 Forbidden.

Each usage item contains:

Field	Type	Description
`id`	string	Call-session ID.
`businessId`	string	Business ID.
`botId`	string	Bot ID.
`isCall`	boolean	`true` for a phone call, `false` for another session type.
`direction`	string	`inbound` or `outbound`.
`phoneNumberCaller`	string	Caller number, when available.
`phoneNumberCallee`	string	Called number, when available.
`duration`	integer	Session duration in seconds. Returns `0` when no call detail duration is available.
`costs`	number	Recorded session cost.
`start`	string	Session creation timestamp, returned as a JSON date-time value.

Example response:

[
  {
    "id": "xavurimeto",
    "businessId": "zpjwletodo",
    "botId": "kqrmxaveli",
    "isCall": true,
    "direction": "inbound",
    "phoneNumberCaller": "+491701234567",
    "phoneNumberCallee": "+49301234567",
    "duration": 184,
    "costs": 0.46,
    "start": "2026-01-15T10:30:00.000Z"
  }
]

List partner businesses

For reseller and partner integrations, GET /partnerClients returns the visible businesses connected to the authenticated partner business. The returned business IDs can be passed to the businessId filter on the usage endpoint.

curl --request GET \
  --url https://voicebooker.de/app/api/v1/partnerClients \
  --header 'X-API-TOKEN: <your-api-token>'

The response is an array of business objects.

Example response:

[
  {
    "id": "zpjwletodo",
    "name": "Example Partner Business",
    "city": "Berlin",
    "country": "DE"
  }
]

Manage knowledge-base and media files

API-key requests can list, upload, and delete files for the business associated with the token.

List knowledge-base files

GET /knowledgeBase returns the knowledge-base files for the business. Each item contains only id, name, fileSize, and tokens.

curl --request GET \
  --url https://voicebooker.de/app/api/v1/knowledgeBase \
  --header 'X-API-TOKEN: <your-api-token>'

Upload a knowledge-base file

POST /knowledgeBase accepts a multipart upload using the file and name fields.

curl --request POST \
  --url https://voicebooker.de/app/api/v1/knowledgeBase \
  --header 'X-API-TOKEN: <your-api-token>' \
  --form 'name=handbook.pdf' \
  --form 'file=@handbook.pdf'

The response contains the file ID:

{"id": "kqrmxaveli"}

Delete a knowledge-base file

curl --request DELETE \
  --url https://voicebooker.de/app/api/v1/knowledgeBase/<file-id> \
  --header 'X-API-TOKEN: <your-api-token>'

List media files

GET /mediaFiles returns media files with only id, name, and fileSize.

curl --request GET \
  --url https://voicebooker.de/app/api/v1/mediaFiles \
  --header 'X-API-TOKEN: <your-api-token>'

Upload a media file

POST /mediaFiles accepts a multipart upload using the file and name fields.

curl --request POST \
  --url https://voicebooker.de/app/api/v1/mediaFiles \
  --header 'X-API-TOKEN: <your-api-token>' \
  --form 'name=hold-music.mp3' \
  --form 'file=@hold-music.mp3'

Delete a media file

curl --request DELETE \
  --url https://voicebooker.de/app/api/v1/mediaFiles/<file-id> \
  --header 'X-API-TOKEN: <your-api-token>'

OpenAPI specification

The following OpenAPI 3.1 document describes these APIs. All endpoints use the X-API-TOKEN header.

openapi: 3.1.0
info:
  title: VoiceBooker Partner API
  version: 1.0.0
  description: Retrieve partner businesses and usage for the business associated with an API token.
servers:
  - url: https://voicebooker.de/app/api/v1
    description: VoiceBooker production API
tags:
  - name: Partner access
    description: APIs for partner and reseller integrations.
paths:
  /exportBots/{botId}:
    get:
      tags: [Partner access]
      operationId: exportBot
      summary: Export a bot
      description: Exports a bot belonging to the business associated with the API token.
      security:
        - apiToken: []
      parameters:
        - name: botId
          in: path
          required: true
          description: Bot ID to export.
          schema: {type: string}
        - name: pretty
          in: query
          schema: {type: boolean, default: false}
      responses:
        '200':
          description: Exported bot definition.
          content:
            application/json:
              schema: {$ref: '#/components/schemas/BotExport'}
        '401': {$ref: '#/components/responses/Unauthorized'}
        '403': {description: The bot does not belong to the business associated with the token.}
  /importBots:
    post:
      tags: [Partner access]
      operationId: importBot
      summary: Import a bot
      description: Imports a bot definition into the business associated with the API token.
      security:
        - apiToken: []
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required: [contents]
              properties:
                filename: {type: string}
                contents: {oneOf: [{type: object}, {type: string}]}
                overwriteBotStages: {type: boolean, default: false}
                overwriteTemplates: {type: boolean, default: false}
                replaceBotStages: {type: boolean, default: false}
      responses:
        '200':
          description: Imported bot.
          content:
            application/json:
              schema: {type: object, properties: {id: {type: string}, name: {type: string}}}
        '401': {$ref: '#/components/responses/Unauthorized'}
  /makeCall:
    post:
      tags: [Partner access]
      operationId: makeOutboundCall
      summary: Place an outbound call
      description: Starts an outbound call using the selected bot and SIP account.
      security:
        - apiToken: []
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required: [dest, botId, sipAccountId]
              properties:
                dest: {type: string, description: Destination number in E.164 format.}
                botId: {type: string}
                sipAccountId: {type: string}
                ringTimeout: {type: integer, default: 30}
                startTimeout: {type: integer, default: 0}
                state: {type: object, additionalProperties: true}
      responses:
        '200':
          description: Outbound call started.
          content:
            application/json:
              schema: {type: object, properties: {callId: {type: string}}}
        '401': {$ref: '#/components/responses/Unauthorized'}
  /getRecording/{id}:
    get:
      tags: [Partner access]
      operationId: getCallRecording
      summary: Fetch a call recording
      description: Streams the MP3 recording for a call session when recording is enabled and the session is available to the API token.
      security:
        - apiToken: []
      parameters:
        - name: id
          in: path
          required: true
          description: Call-session ID.
          schema: {type: string}
      responses:
        '200':
          description: Call recording.
          content:
            audio/mpeg:
              schema:
                type: string
                format: binary
        '401': {$ref: '#/components/responses/Unauthorized'}
        '404': {description: The call session or recording is not available to the API token.}
  /call_sessions:
    get:
      tags: [Partner access]
      operationId: listCallSessions
      summary: List call sessions
      description: Returns call-session details for businesses available to the API token.
      security: [{apiToken: []}]
      parameters:
        - {name: start, in: query, required: true, description: Inclusive start date (YYYY-MM-DD)., schema: {type: string, format: date}}
        - {name: end, in: query, required: true, description: Inclusive end date (YYYY-MM-DD)., schema: {type: string, format: date}}
        - {name: page, in: query, required: false, schema: {type: integer, minimum: 1, default: 1}}
      responses:
        '200': {description: Page of call sessions (30 items per page)., content: {application/json: {schema: {type: array, items: {type: object, additionalProperties: true}}}}}
        '401': {$ref: '#/components/responses/Unauthorized'}
  /conversations:
    get:
      tags: [Partner access]
      operationId: listTranscribedSessions
      summary: List sessions with transcripts
      description: Returns visible sessions with transcripts for businesses available to the API token. A contextUId query can instead retrieve a compact transcript for one known telephony context.
      security: [{apiToken: []}]
      parameters:
        - {name: start, in: query, required: false, description: Required when listing sessions., schema: {type: string, format: date}}
        - {name: end, in: query, required: false, description: Required when listing sessions., schema: {type: string, format: date}}
        - {name: page, in: query, required: false, schema: {type: integer, minimum: 1, default: 1}}
        - {name: contextUId, in: query, required: false, description: Return a compact transcript for this telephony context instead of a session list., schema: {type: string}}
      responses:
        '200': {description: Page of transcript-bearing sessions or a compact context transcript., content: {application/json: {schema: {type: array, items: {type: object, additionalProperties: true}}}}}
        '401': {$ref: '#/components/responses/Unauthorized'}
  /conversations/{id}:
    get:
      tags: [Partner access]
      operationId: getCallTranscript
      summary: Retrieve a call transcript
      description: Returns chronological transcript turns and associated call trace data for an available session. Use trace=true for up to 1,000 turns per page, including available prompts, state, stack, and function/webhook calls.
      security: [{apiToken: []}]
      parameters:
        - {name: id, in: path, required: true, description: Call-session ID from a session list., schema: {type: string}}
        - {name: page, in: query, required: false, schema: {type: integer, minimum: 1, default: 1}}
        - {name: trace, in: query, required: false, description: Set to true for the detailed trace; omit for the standard response., schema: {type: boolean}}
      responses:
        '200': {description: Transcript turns for the requested page., content: {application/json: {schema: {type: array, items: {type: object, additionalProperties: true}}}}}
        '401': {$ref: '#/components/responses/Unauthorized'}
  /usage:
    get:
      tags: [Partner access]
      operationId: listUsage
      summary: Retrieve usage
      description: Returns usage for the authenticated business and its available partner businesses, optionally filtered to one business and a date range.
      security:
        - apiToken: []
      parameters:
        - name: businessId
          in: query
          required: false
          description: Business ID. It must be the authenticated business or an available partner business.
          schema:
            type: string
        - name: start
          in: query
          required: false
          description: Inclusive lower bound for the session creation timestamp.
          schema:
            type: string
            format: date-time
        - name: end
          in: query
          required: false
          description: Inclusive upper bound for the session creation timestamp.
          schema:
            type: string
            format: date-time
      responses:
        '200':
          description: Usage records.
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: '#/components/schemas/UsageRecord'
        '401':
          $ref: '#/components/responses/Unauthorized'
        '403':
          description: The requested business is outside the token's scope.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
  /partnerClients:
    get:
      tags: [Partner access]
      operationId: listPartnerClients
      summary: List partner businesses
      description: Returns visible businesses connected to the business associated with the API token.
      security:
        - apiToken: []
      responses:
        '200':
          description: A list of partner businesses.
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: '#/components/schemas/PartnerBusiness'
        '401':
          $ref: '#/components/responses/Unauthorized'
  /knowledgeBase:
    get:
      tags: [Partner access]
      operationId: listKnowledgeBaseFiles
      summary: List knowledge-base files
      description: Returns knowledge-base files for the business associated with the API token.
      security:
        - apiToken: []
      responses:
        '200':
          description: Knowledge-base files.
          content:
            application/json:
              schema:
                type: array
                items: {$ref: '#/components/schemas/KnowledgeBaseFile'}
        '401': {$ref: '#/components/responses/Unauthorized'}
    post:
      tags: [Partner access]
      operationId: uploadKnowledgeBaseFile
      summary: Upload a knowledge-base file
      security:
        - apiToken: []
      requestBody:
        required: true
        content:
          multipart/form-data:
            schema:
              type: object
              required: [file, name]
              properties:
                file: {type: string, format: binary}
                name: {type: string}
      responses:
        '200':
          description: Uploaded file ID.
          content:
            application/json:
              schema: {type: object, properties: {id: {type: string}}}
        '401': {$ref: '#/components/responses/Unauthorized'}
  /knowledgeBase/{fileId}:
    delete:
      tags: [Partner access]
      operationId: deleteKnowledgeBaseFile
      summary: Delete a knowledge-base file
      security:
        - apiToken: []
      parameters:
        - name: fileId
          in: path
          required: true
          schema: {type: string}
      responses:
        '200': {description: File deleted.}
        '401': {$ref: '#/components/responses/Unauthorized'}
        '403': {description: The file does not belong to the business associated with the token.}
  /mediaFiles:
    get:
      tags: [Partner access]
      operationId: listMediaFiles
      summary: List media files
      description: Returns media files for the business associated with the API token.
      security:
        - apiToken: []
      responses:
        '200':
          description: Media files.
          content:
            application/json:
              schema:
                type: array
                items: {$ref: '#/components/schemas/MediaFile'}
        '401': {$ref: '#/components/responses/Unauthorized'}
    post:
      tags: [Partner access]
      operationId: uploadMediaFile
      summary: Upload a media file
      security:
        - apiToken: []
      requestBody:
        required: true
        content:
          multipart/form-data:
            schema:
              type: object
              required: [file, name]
              properties:
                file: {type: string, format: binary}
                name: {type: string}
      responses:
        '200':
          description: Uploaded file ID.
          content:
            application/json:
              schema: {type: object, properties: {id: {type: string}}}
        '401': {$ref: '#/components/responses/Unauthorized'}
  /mediaFiles/{fileId}:
    delete:
      tags: [Partner access]
      operationId: deleteMediaFile
      summary: Delete a media file
      security:
        - apiToken: []
      parameters:
        - name: fileId
          in: path
          required: true
          schema: {type: string}
      responses:
        '200': {description: File deleted.}
        '401': {$ref: '#/components/responses/Unauthorized'}
        '403': {description: The file does not belong to the business associated with the token.}
  /bot_test_setups:
    get:
      tags: [Partner access]
      operationId: listBotTests
      summary: List bot tests
      security: [{apiToken: []}]
      responses:
        '200':
          description: Bot tests for the authenticated business.
          content:
            application/json:
              schema:
                type: array
                items: {$ref: '#/components/schemas/BotTestSetup'}
        '401': {$ref: '#/components/responses/Unauthorized'}
    post:
      tags: [Partner access]
      operationId: createBotTest
      summary: Create a bot test
      security: [{apiToken: []}]
      requestBody:
        required: true
        content:
          application/json:
            schema: {$ref: '#/components/schemas/BotTestSetupInput'}
      responses:
        '200':
          description: Created bot test.
          content: {application/json: {schema: {$ref: '#/components/schemas/BotTestSetup'}}}
        '401': {$ref: '#/components/responses/Unauthorized'}
        '403': {description: A referenced bot is outside the token's business or both bots are identical.}
  /bot_test_setups/{id}:
    put:
      tags: [Partner access]
      operationId: updateBotTest
      summary: Update a bot test
      security: [{apiToken: []}]
      parameters:
        - {name: id, in: path, required: true, schema: {type: string}}
      requestBody:
        required: true
        content:
          application/json:
            schema: {$ref: '#/components/schemas/BotTestSetupUpdate'}
      responses:
        '200':
          description: Updated bot test.
          content: {application/json: {schema: {$ref: '#/components/schemas/BotTestSetup'}}}
        '401': {$ref: '#/components/responses/Unauthorized'}
        '403': {description: A referenced bot is outside the token's business or both bots are identical.}
        '404': {description: Bot test not found.}
    delete:
      tags: [Partner access]
      operationId: deleteBotTest
      summary: Delete a bot test
      security: [{apiToken: []}]
      parameters:
        - {name: id, in: path, required: true, schema: {type: string}}
      responses:
        '200': {description: Bot test deleted.}
        '401': {$ref: '#/components/responses/Unauthorized'}
        '404': {description: Bot test not found.}
components:
  securitySchemes:
    apiToken:
      type: apiKey
      in: header
      name: X-API-TOKEN
      description: 'Send the API token in `X-API-TOKEN: <token>`.'
  schemas:
    BotExport:
      type: object
      properties:
        name: {type: string}
        id: {type: string}
        stages: {type: array, items: {type: object}}
        settings: {type: object}
        wizard: {type: object}
    PartnerBusiness:
      type: object
      description: Business data returned by the partner-business endpoint. Additional fields may be returned as the business model evolves.
      additionalProperties: true
      properties:
        id:
          type: string
          description: Business ID.
        name:
          type: string
    UsageRecord:
      type: object
      required: [id, businessId, botId, isCall, direction, duration, costs, start]
      properties:
        id: {type: string, description: Call-session ID.}
        businessId: {type: string, description: Business ID.}
        botId: {type: string, nullable: true, description: Bot ID.}
        isCall: {type: boolean}
        direction: {type: string, enum: [inbound, outbound]}
        phoneNumberCaller: {type: string, nullable: true}
        phoneNumberCallee: {type: string, nullable: true}
        duration: {type: integer, minimum: 0, description: Duration in seconds.}
        costs: {type: number, format: double}
        start: {type: string, format: date-time}
    KnowledgeBaseFile:
      type: object
      required: [id, name, fileSize, tokens]
      properties:
        id: {type: string, description: Knowledge-base file ID.}
        name: {type: string, description: Original filename.}
        fileSize: {type: integer, description: File size in bytes.}
        tokens: {type: integer, description: Number of processed tokens.}
    MediaFile:
      type: object
      required: [id, name, fileSize]
      properties:
        id: {type: string, description: Media file ID.}
        name: {type: string, description: Original filename.}
        fileSize: {type: integer, description: File size in bytes.}
    BotTestSetup:
      type: object
      required: [id, name, settings, srcBotId, destBotId]
      properties:
        id: {type: string}
        name: {type: string}
        settings: {type: object, additionalProperties: true}
        srcBotId: {type: string}
        destBotId: {type: string}
    BotTestSetupInput:
      type: object
      required: [name, srcBotId, destBotId]
      properties:
        name: {type: string}
        settings: {type: object, additionalProperties: true}
        srcBotId: {type: string}
        destBotId: {type: string}
    BotTestSetupUpdate:
      type: object
      properties:
        name: {type: string}
        settings: {type: object, additionalProperties: true}
        srcBotId: {type: string}
        destBotId: {type: string}
    Error:
      type: object
      properties:
        error:
          type: string
          example: Invalid businessId
  responses:
    Unauthorized:
      description: The API token is missing or invalid.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'

HTTP errors

401 Unauthorized: the API token is missing or does not match an API key.
403 Forbidden: the requested businessId is not the authenticated business or an available partner business.

API access

On this page