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

# Patch metadata

> Use this method for metadata partial updating. If there is no present metadata, one will be created from request. <a href="https://www.phonovation.com/docs/conversations-api" target="_blank">More info</a>

**Required scope:** Enable one of: `conversations:manage`.



## OpenAPI

````yaml /openapi/phonovation-whatsapp.json patch /ccaas/1/conversations/{conversationId}/metadata
openapi: 3.1.0
info:
  title: Phonovation Messaging APIs
  description: >-
    OpenAPI specification for Phonovation messaging, customer engagement, and
    platform APIs.
  contact:
    name: Phonovation support
    email: support@phonovation.com
  version: 3.250.0
  x-generatedAt: '2026-10-15T11:28:56.135064395Z'
servers:
  - url: https://api.messaging.phonovation.com
    description: Phonovation Messaging API production server
security: []
tags:
  - name: customer-engagement
    description: >
      Complete solutions that will help you drive better outcomes for your
      customers and business across the entire customer journey.
    x-type: category
    x-displayName: Customer Engagement
  - name: people
    description: >
      Build rich profiles for each person to create audience segments for more
      precise targeting. Manage duplicates and import your data over API.


      Events reflect actions that end users take on your website or in your
      mobile application.


      Events API is a robust way to send those events to Phonovation. Event can
      be sent only to an existing person in People module and an event
      definition should be created beforehand to describe contents of the event.


      Other events tracking options:

      * [ JavaScript SDK ](https://github.com/phonovation/people-web-sdk)

      * [iOS
      SDK](https://github.com/phonovation/mobile-messaging-sdk-ios/wiki/Events)

      * [Android
      SDK](https://github.com/phonovation/mobile-messaging-sdk-android/wiki/Events)
    x-type: product
    x-displayName: People
  - name: person-profile
    description: ''
    x-type: section
    x-displayName: Person profile
  - name: company-profile
    description: ''
    x-type: section
    x-displayName: Company profile
  - name: tags
    description: ''
    x-type: section
    x-displayName: Tags
  - name: custom-attributes
    description: ''
    x-type: section
    x-displayName: Custom attributes
  - name: custom-attributes-lists
    description: ''
    x-type: section
    x-displayName: 'Custom attributes: Lists'
  - name: contact-information:-push
    description: ''
    x-type: section
    x-displayName: 'Contact Information: Push'
  - name: events
    description: ''
    x-type: section
    x-displayName: Events
  - name: segments
    description: ''
    x-type: section
    x-displayName: Segments
  - name: moments
    description: >
      Use Moments to set up and manage automated messaging campaigns with your
      customers by building conversation workflows.
    x-type: product
    x-displayName: Moments
  - name: flow
    description: >
      [Flow](https://www.phonovation.com/docs/moments/manage-flow) is the
      Phonovation communication builder that helps you create and manage
      messaging campaigns. The Flows API allows you to add or remove people from
      communication programmatically for flows with an [active
      status](https://www.phonovation.com/docs/moments/manage-flow#launch-create).


      Use the Add Participants to flow endpoint to a person or batches of
      persons (between 1-1000 persons). The method works asynchronously to queue
      and process participants at a rate of 10 requests per second. For
      reporting of operation results, use the notifyUrl  field to provide a URL
      of your callback server that will receive a status report or use the Get a
      report on participants added to Flow endpoint.
    x-type: module
    x-displayName: Flow
  - name: conversations
    description: >-
      Conversations is a solution that allows Enterprises to engage in
      conversations with their customers over multiple channels. The solution is
      available either as a web-based cloud platform web interface or over HTTP
      API for 2-way messaging over SMS, WhatsApp, Viber, and Facebook messenger.
      It supports conversation threading, conversation management including
      queues and routing, agent assignment, resolution management and
      conversation history overview.
    x-type: product
    x-displayName: Conversations
  - name: conversation-management
    description: ''
    x-type: section
    x-displayName: Conversation management
  - name: conversation-tags
    description: ''
    x-type: section
    x-displayName: Conversation tags
  - name: conversation-messages
    description: ''
    x-type: section
    x-displayName: Conversation messages
  - name: conversation-events
    description: ''
    x-type: section
    x-displayName: Conversation events
  - name: conversation-notes
    description: ''
    x-type: section
    x-displayName: Conversation notes
  - name: conversation-agents
    description: ''
    x-type: section
    x-displayName: Conversation agents
  - name: conversation-queues
    description: ''
    x-type: section
    x-displayName: Conversation queues
  - name: conversation-routing
    description: ''
    x-type: section
    x-displayName: Conversation routing
  - name: bots
    description: ''
    x-type: section
    x-displayName: Bots
  - name: metadata
    description: ''
    x-type: section
    x-displayName: Metadata
  - name: templates
    description: ''
    x-type: section
    x-displayName: Templates
  - name: conversation-forms
    description: ''
    x-type: section
    x-displayName: Conversation forms
  - name: account-configuration
    description: ''
    x-type: section
    x-displayName: Account Configuration
  - name: agent-configuration-calls
    description: ''
    x-type: section
    x-displayName: Agent Configuration (Calls)
  - name: outbound-call-conversation-calls
    description: ''
    x-type: section
    x-displayName: Outbound Call Conversation (Calls)
  - name: waiting-strategies-calls
    description: ''
    x-type: section
    x-displayName: Waiting Strategies (Calls)
  - name: recording-configuration-calls
    description: ''
    x-type: section
    x-displayName: Recording Configuration (Calls)
  - name: recording-metadata-calls
    description: ''
    x-type: section
    x-displayName: Recording metadata (Calls)
  - name: recording-calls
    description: ''
    x-type: section
    x-displayName: Recording (Calls)
  - name: wrap-up-configuration-calls
    description: ''
    x-type: section
    x-displayName: Wrap Up Configuration (Calls)
  - name: wrap-up-time-calls
    description: ''
    x-type: section
    x-displayName: Wrap Up Time (Calls)
  - name: transfers-calls
    description: ''
    x-type: section
    x-displayName: Transfers (Calls)
  - name: transfer-to-external-number-configuration-calls
    description: ''
    x-type: section
    x-displayName: Transfer to External Number Configuration (Calls)
  - name: transfer-strategy-calls
    description: ''
    x-type: section
    x-displayName: Transfer Strategy (Calls)
  - name: call-hold-calls
    description: ''
    x-type: section
    x-displayName: Call Hold (Calls)
  - name: hold-configuration-calls
    description: ''
    x-type: section
    x-displayName: Hold Configuration (Calls)
  - name: call-timeout-calls
    description: ''
    x-type: section
    x-displayName: Call Timeout (Calls)
  - name: working-hours
    description: ''
    x-type: section
    x-displayName: Working Hours
  - name: tts-options-calls
    description: ''
    x-type: section
    x-displayName: TTS options (Calls)
  - name: away-audio-messages
    description: ''
    x-type: section
    x-displayName: Away Audio Messages
  - name: web-forms
    description: ''
    x-type: section
    x-displayName: Web Forms
  - name: answers
    description: >
      Answers is the Phonovation fully-encompassed chatbot building platform
      that enables you to build, test, and deploy highly customized chatbots of
      different types. Multiple channels are supported on Answers like WhatsApp,
      Facebook Messenger, Live Chat, Apple Business Chat, Viber, Google Business
      Messaging and other. Communication with Bot is achieved through existing
      Conversations solution infrastructure which enables integration and
      switching between communicating with bot and a live agent. Processing can
      start by receiving MO message or by receiving a trigger event. Users can
      manage bots (create, update, delete, start and stop bots) through a web
      interface. For more details, visit the [Answers
      documentation](https://www.phonovation.com/docs/answers).


      Answers API is in Early access stage.
    x-type: product
    x-displayName: Answers
  - name: answers-testing-start-test
    description: ''
    x-type: section
    x-displayName: Start Answers test
  - name: answers-testing-stop-test
    description: ''
    x-type: section
    x-displayName: Stop Answers test
  - name: answers-testing-send-message
    description: ''
    x-type: section
    x-displayName: Send inbound message to test
  - name: common-assets
    description: >
      Reuse assets created on Phonovation SaaS products in order to recreate
      configuration more easily on a single or across multiple accounts. Export
      or share Moments flows, Answers chatbots or other SaaS assets from your
      account and import it on another one.  


      This feature is in Early access stage.
    x-type: product
    x-displayName: Common Assets
  - name: saas-resource-export
    description: ''
    x-type: section
    x-displayName: Export resource
  - name: saas-resource-import
    description: ''
    x-type: section
    x-displayName: Import resource
  - name: saas-resource-share
    description: ''
    x-type: section
    x-displayName: Share resource
  - name: saas-status-request
    description: ''
    x-type: section
    x-displayName: Get SaaS request status
  - name: knowledge-base
    description: >-
      Knowledge Base is a centralized content management system for creating,
      organizing, and retrieving articles, attachments, and structured content.
      Content is organized into categories, folders, and a hierarchical content
      tree. Articles support draft and published workflow statuses, tagging,
      commenting, and file attachments.
    x-type: product
    x-displayName: Knowledge Base
  - name: knowledge-base-search
    description: ''
    x-type: section
    x-displayName: Search
  - name: knowledge-base-articles
    description: ''
    x-type: section
    x-displayName: Articles
  - name: knowledge-base-categories
    description: ''
    x-type: section
    x-displayName: Categories
  - name: knowledge-base-folders
    description: ''
    x-type: section
    x-displayName: Folders
  - name: knowledge-base-content-tree
    description: ''
    x-type: section
    x-displayName: Content Tree
  - name: knowledge-base-tags
    description: ''
    x-type: section
    x-displayName: Tags
  - name: knowledge-base-attachments
    description: ''
    x-type: section
    x-displayName: Attachments
  - name: ai-hub
    description: >
      AI-powered tools and services to help you create smarter and more
      personalized customer experiences.
    x-type: category
    x-displayName: AI Hub
  - name: ai-assistants
    description: >
      Phonovation AI assistant is a retrieval-augmented generation (RAG)
      solution that performs tasks based on documents and

      instructions you specify. This means the AI draws answers directly from
      your documents, resulting in more accurate

      and relevant responses. For more information on use cases and how to build
      AI assistants, visit our

      [AI Assistant](https://www.phonovation.com/docs/ai-hub/ai-assistant)
      product documentation.


      With AI Assistants API, you can:

      * Query your existing AI assistants created via [Phonovation
      Portal](https://www.phonovation.com/docs/ai-hub/ai-assistant/create-ai-assistant)

      * Retrieve context the AI assistant uses to answer your queries
    x-type: product
    x-displayName: AI Assistants
  - name: channels
    description: >
      Create a perfect customer experience by using the channels your customer
      already use and love.
    x-type: category
    x-displayName: Channels
  - name: sms
    description: >
      SMS (Short Message Service) is the most extensive messaging service
      available in terms of reach and coverage. A SMS can be sent to and from
      any mobile device in the world and does not necessarily require a data
      connection.


      Phonovation SMS API allows you to send and receive text messages (SMS),
      fetch or receive delivery reports on your endpoint in real time, and see
      message logs. You can send messages in different languages, schedule your
      messages, define delivery time window, and much more.


      To utilize SMS in combination with other channels, check out [Messages
      API](https://www.phonovation.com/docs/api/platform/messages-api).
    x-type: product
    x-displayName: SMS
  - name: outbound-sms
    description: >
      When you send an SMS to a phone number belonging to an end user's device
      you are sending an Outbound SMS. Historically, this was and still is
      referred to as a Mobile Terminated (MT) SMS, though nowadays an SMS is not
      always sent to a mobile device. In an Outbound SMS you can set the From or
      Sender field with whatever you have registered or purchased with
      Phonovation, either a Long Number, Short Code, or text based Sender.
    x-type: module
    x-displayName: Outbound SMS
  - name: send-message
    description: ''
    x-type: section
    x-displayName: Send a message
  - name: manage-scheduled-sms-messages
    description: ''
    x-type: section
    x-displayName: Manage Scheduled SMS Messages
  - name: confirm-conversion
    description: ''
    x-type: section
    x-displayName: Confirm conversion
  - name: inbound-sms
    description: >
      When an end user sends an SMS from their device to a Phone Number or Short
      Code they have sent an Inbound SMS. The Inbound SMS is routed to the
      Phonovation Platform and Phonovation in turn routes the SMS to its
      Customer who has purchased that Phone Number or Short Code. Inbound SMS,
      for historical reasons, are referred to as Mobile Originated (MO) SMS.
    x-type: module
    x-displayName: Inbound SMS
  - name: logs-and-status-reports
    description: >
      Status Reports tell you what happened to the SMS you sent, whether it was
      successfully delivered or failed to be delivered.

      They also provide timestamps, network information if available, and on SMS
      delivery failure, a status code indicating the reason. 

      Status Reports can be pushed in real-time to a Customer's webhook or can
      be retrieved by an API call. 

      Logs provide similar information to Status Reports but are available to
      query for 48hrs.
    x-type: module
    x-displayName: Logs and Status Reports
  - name: whatsapp
    description: >
      With 2 billion users, WhatsApp is the most used application worldwide. It
      enables you to reach more customers, sharing important and timely
      notifications, as well as provide real-time customer support. Phonovation
      is an official WhatsApp Business solution provider. Send and manage
      WhatsApp messages over Phonovation's WhatsApp API.


      To utilize WhatsApp in combination with other channels, check out
      [Messages
      API](https://www.phonovation.com/docs/api/platform/messages-api).


      [Learn more about WhatsApp channel and use
      cases](https://www.phonovation.com/docs/whatsapp).
    x-type: product
    x-displayName: WhatsApp
  - name: whatsapp-outbound-messages
    description: >
      When you send a WhatsApp message to a phone number belonging to an end
      user's device you are sending an outbound WhatsApp message. 

      There are several types of WhatsApp messages:
        - Template message – use a pre-defined template to send text, images, videos, share location, documents, attach buttons, and configure SMS failover.
        - Free-form text or media – use it only when contacted by the end user within a certain timeframe to send text, images, audio, video, stickers, share location, or contacts.
        - Interactive messages – send a message that your end user can interact with, such as interactive buttons, lists, or product messages.
    x-type: module
    x-displayName: Outbound messages
  - name: whatsapp-template-message
    description: ''
    x-type: section
    x-displayName: Template Message
  - name: whatsapp-text-and-media-messages
    description: ''
    x-type: section
    x-displayName: Text and media messages
  - name: send-whatsapp-interactive-messages
    description: ''
    x-type: section
    x-displayName: Interactive messages
  - name: whatsapp-events
    description: ''
    x-type: section
    x-displayName: Events
  - name: whatsapp-inbound-messages
    description: >
      When the end user sends a WhatsApp from their device to a phone number,
      they have sent an inbound WhatsApp message. 

      The inbound message is routed to the Phonovation Platform and Phonovation
      in turn routes the message to its customer who has registered the WhatsApp
      sender.

      Typical supporting features you’d use with inbound messages are:
        - Marking messages as read to communicate to the end user that you have read their message.
        - Downloading media and its metadata sent over by the end user.
    x-type: module
    x-displayName: Inbound messages
  - name: whatsapp-receive-inbound-message
    description: ''
    x-type: section
    x-displayName: Receive inbound message
  - name: whatsapp-get-inbound-media
    description: ''
    x-type: section
    x-displayName: Get inbound media
  - name: whatsapp-mark-message-as-read
    description: ''
    x-type: section
    x-displayName: Mark message as read
  - name: whatsapp-message-status-reports
    description: >
      Status Reports tell you what happened to the WhatsApp message you sent,
      whether it was successfully delivered or failed to be delivered, whether
      it’s been seen. 

      Status Reports can be pushed in real time to a customer's webhook or can
      be retrieved by an API call. 

      Logs provide similar information to Status Reports but are only available
      to query for 48hrs.

      There are a few reports you can set up for your WhatsApp messaging:
        - Delivery Reports - In case of a failure, you’ll receive a timestamp with a delivery failure message and a status code indicating the reason behind it.
        - Seen Reports – In case the message has been delivered successfully to the end user, this report will additionally inform you whether the message has been seen.
        - Payments - It provides all updates to your payment transaction in real time. It's also possible to fetch current state of the payment transaction in any time.
    x-type: module
    x-displayName: Message Status Reports
  - name: whatsapp-status-reports
    description: ''
    x-type: section
    x-displayName: Status Reports
  - name: whatsapp-payments
    description: ''
    x-type: section
    x-displayName: Payments
  - name: whatsapp-marketing-update
    description: ''
    x-type: section
    x-displayName: Marketing Update
  - name: whatsapp-service-management
    description: >
      As opposed to free-form messages, template messages can be sent and
      delivered at any time. 

      Here, you can manage your templates, from template registration,
      retrieving template statuses, to deleting existing templates.

      With each WhatsApp message, you can send various types of media. Here, you
      can manage your media and configure additional feature enhancing their
      functionality.

      Moreover you can fetch quality and business info of your senders.
    x-type: module
    x-displayName: Service Management
  - name: whatsapp-template-management
    description: ''
    x-type: section
    x-displayName: Template Management
  - name: whatsapp-flow-management
    description: ''
    x-type: section
    x-displayName: Flow Management
  - name: whatsapp-media-management
    description: ''
    x-type: section
    x-displayName: Media Management
  - name: whatsapp-sender-management
    description: ''
    x-type: section
    x-displayName: Sender Management
  - name: whatsapp-bulk-sender-registration
    description: ''
    x-type: section
    x-displayName: Bulk Sender Registration
  - name: whatsapp-identity-management
    description: >
      Set up identity change, an add-on available for senders hosted by
      Phonovation. This is supported for interactive buttons, interactive lists,
      or an interactive product message. 

      Identity change allows you to increase your security by preventing
      messages from being sent to unverified end users. 

      Once enabled for a sender, you would receive notifications when an end
      user's WhatsApp account (MSISDN) has potentially been transferred to a
      different user. 

      When a potential identity change has been detected, the outbound traffic
      towards that end user is blocked until you verify the user outside the
      channel and acknowledge the change.

      Contact your Account Executive for more information.
    x-type: module
    x-displayName: Identity Management
  - name: whatsapp-ad-conversions
    description: >
      The Conversions API for Business Messaging enables advertisers to
      consolidate web, app, physical store, and business messaging events into a
      single endpoint for Meta. With Phonovation, you can submit Purchase or
      LeadSubmitted conversion events for WhatsApp.
    x-type: module
    x-displayName: Ad Conversions
  - name: platform
    description: |
      Modular tools to scale and automate your business.
    x-type: category
    x-displayName: Platform
  - name: subscriptions-api
    description: >
      Subscriptions are a way to manage notifications sent to your webhooks by
      Phonovation.

      It is a useful feature if you want to narrow down the list of events to be
      notified about or specify different webhooks for different use cases.

      It will also allow you to set up authentication settings for your
      endpoint.


      If you want to use mutual TLS for the webhook that receives notification
      events from Phonovation, you can upload and manage a TLS certificate that
      Phonovation will use when connecting to your server. The certificate
      allows your server to verify that the request is really coming from
      Phonovation. For details, see [Create and Manage
      Certificates](https://www.phonovation.com/docs/cpaas-x/subscriptions-management/create-manage-subscriptions#create-and-manage-certificates).
    x-type: product
    x-displayName: Subscriptions Management
  - name: subscription
    description: ''
    x-type: section
    x-displayName: Subscription
  - name: profile
    description: ''
    x-type: section
    x-displayName: Profile
  - name: security
    description: ''
    x-type: section
    x-displayName: Security
  - name: certificate
    description: ''
    x-type: section
    x-displayName: Certificate
paths:
  /ccaas/1/conversations/{conversationId}/metadata:
    patch:
      tags:
        - customer-engagement
        - conversations
        - metadata
      summary: Patch metadata
      description: >-
        Use this method for metadata partial updating. If there is no present
        metadata, one will be created from request. <a
        href="https://www.phonovation.com/docs/conversations-api"
        target="_blank">More info</a>


        **Required scope:** Enable one of: `conversations:manage`.
      operationId: patch-metadata
      parameters:
        - name: conversationId
          in: path
          description: Id of the conversation to update metadata for.
          required: true
          style: simple
          explode: false
          schema:
            type: string
      requestBody:
        description: Metadata key-value pairs.
        content:
          application/json:
            schema:
              type: object
              minProperties: 1
            examples:
              Patch metadata.:
                summary: Patch metadata.
                description: Patch metadata.
                value:
                  key1: value1_updated
                  key3: value3
        required: true
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/e89661b226e518f36a162935afcdf1132c95b0e63e9c86c5ef5f31c5a8d865a2.StatusCodeResponse
              examples:
                Successful response:
                  summary: Successful response
                  description: Successful response
                  value:
                    statusCode: SUCCESS
                    message: Metadata patch to conversation successfully.
        '400':
          description: Bad request
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/e89661b226e518f36a162935afcdf1132c95b0e63e9c86c5ef5f31c5a8d865a2.StatusCodeResponse
              examples:
                Invalid Id:
                  summary: Invalid Id
                  description: Invalid Id
                  value:
                    requestError:
                      serviceException:
                        messageId: NOT_FOUND
                        text: >-
                          Invalid id 'e43bc422-09c9-4591-8b9d-82debcf04e0d'
                          given! No such entity exists.
                Invalid body:
                  summary: Invalid body
                  description: Invalid body
                  value:
                    requestError:
                      serviceException:
                        messageId: BAD_REQUEST
                        text: Invalid request body.
        '401':
          $ref: '#/components/responses/ApiException401'
        '403':
          $ref: '#/components/responses/ApiException403'
        '404':
          $ref: '#/components/responses/ApiException404'
        '500':
          $ref: '#/components/responses/ApiException500'
      security:
        - APIKeyHeader: []
components:
  schemas:
    e89661b226e518f36a162935afcdf1132c95b0e63e9c86c5ef5f31c5a8d865a2.StatusCodeResponse:
      type: object
      properties:
        statusCode:
          $ref: >-
            #/components/schemas/e89661b226e518f36a162935afcdf1132c95b0e63e9c86c5ef5f31c5a8d865a2.StatusCode
        message:
          type: string
      title: StatusCodeResponse
    e89661b226e518f36a162935afcdf1132c95b0e63e9c86c5ef5f31c5a8d865a2.StatusCode:
      type: string
      enum:
        - SUCCESS
        - ERROR
      title: StatusCode
    ApiException:
      type: object
      properties:
        requestError:
          $ref: '#/components/schemas/ApiRequestError'
      title: ApiException
    ApiRequestError:
      type: object
      properties:
        serviceException:
          $ref: '#/components/schemas/ApiRequestErrorDetails'
      title: ApiRequestError
    ApiRequestErrorDetails:
      type: object
      properties:
        messageId:
          type: string
          description: Identifier of the error.
        text:
          type: string
          description: Detailed error description.
        validationErrors:
          type: object
          additionalProperties:
            type: array
            items:
              type: string
              description: Validation errors.
          description: Validation errors.
      title: ApiRequestErrorDetails
  responses:
    ApiException401:
      description: Unauthorized
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ApiException'
          example:
            requestError:
              serviceException:
                messageId: UNAUTHORIZED
                text: Unauthorized
        application/xml:
          schema:
            $ref: '#/components/schemas/ApiException'
          example: |
            <?xml version="1.0" encoding="UTF-8"?><ApiException>
              <requestError>
                <serviceException>
                  <messageId>UNAUTHORIZED</messageId>
                  <text>Unauthorized</text>
                </serviceException>
              </requestError>
            </ApiException>
    ApiException403:
      description: Forbidden
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ApiException'
          example:
            requestError:
              serviceException:
                messageId: FORBIDDEN
                text: Forbidden
        application/xml:
          schema:
            $ref: '#/components/schemas/ApiException'
          example: |
            <?xml version="1.0" encoding="UTF-8"?><ApiException>
              <requestError>
                <serviceException>
                  <messageId>FORBIDDEN</messageId>
                  <text>Forbidden</text>
                </serviceException>
              </requestError>
            </ApiException>
    ApiException404:
      description: Not Found
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ApiException'
          example:
            requestError:
              serviceException:
                messageId: NOT_FOUND
                text: Not found
        application/xml:
          schema:
            $ref: '#/components/schemas/ApiException'
          example: |
            <?xml version="1.0" encoding="UTF-8"?><ApiException>
              <requestError>
                <serviceException>
                  <messageId>NOT_FOUND</messageId>
                  <text>Not found</text>
                </serviceException>
              </requestError>
            </ApiException>
    ApiException500:
      description: Internal Server Error
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ApiException'
          example:
            requestError:
              serviceException:
                messageId: GENERAL_ERROR
                text: Something went wrong. Please contact support.
        application/xml:
          schema:
            $ref: '#/components/schemas/ApiException'
          example: |
            <?xml version="1.0" encoding="UTF-8"?><ApiException>
              <requestError>
                <serviceException>
                  <messageId>GENERAL_ERROR</messageId>
                  <text>Something went wrong. Please contact support.</text>
                </serviceException>
              </requestError>
            </ApiException>
  securitySchemes:
    APIKeyHeader:
      type: apiKey
      description: >
        This is the most secure authorization type and the one with the most
        flexibility.


        API keys can be generated by calling the dedicated API method.
        Furthermore, API keys can have a limited scope and cover only some API
        methods. Lastly, they can

        be revoked at any time. This range of possibilities makes API keys well
        suited for separating the API access rights across multiple applications
        or use cases.

        Finally, the loss of an API key is easily manageable.


        You can manage your API keys from
        [GUI](https://portal.phonovation.com/settings/accounts/api-keys), or
        programmatically

        with [dedicated API](#platform-&-connectivity/settings).


        API key Authorization header example:


        ```shell

        Authorization: App
        003026bbc133714df1834b8638bb496e-8f4b3d9a-e931-478d-a994-28a725159ab9

        ```
      name: Authorization
      in: header
      x-default: 'App '

````

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