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

# List channel templates

> Lists the channel templates. This is where you find the **name** to use in `template.name` and how many variables each template requires.

The list comes from Connecta DESK, not from a lookup at the provider: that is why it answers fast and takes the status and queue filters. The catalog is fed by the synchronization with Meta/Gupshup, so a template approved at the provider right now shows up here after the next synchronization.

A channel with no synchronized template returns an empty list and schedules the synchronization in the background — the next call already finds the catalog. A channel that does not use approved templates also returns an empty list, with no error.



## OpenAPI

````yaml /api-reference/openapi.en.yaml get /channels/{id}/templates
openapi: 3.0.3
info:
  title: Connecta DESK Public API
  version: 1.0.0
  description: >-
    Public API of Connecta DESK, available at `/api/v1`. Access uses a token
    generated in the tokens module. Each token has permissions per **module ×
    method**, and every list read is paginated.


    ## Authentication


    ```

    Authorization: Bearer sk_live_a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6

    ```


    The token belongs to a **company**, not to a user. The company used is
    always the token's company, so sending `companyId` in the body has no
    effect. A missing, invalid, revoked or expired token gets the same `401`
    response.


    ## Order of checks


    1. **token** → `401`

    2. **active company** → `403`

    3. **API enabled on the plan** → `403 ERR_API_NOT_ENABLED` (does not apply
    to on-premise)

    4. **company rate limit** → `429`

    5. **token permission** → `403 ERR_API_FORBIDDEN_SCOPE`


    ## User ids


    Every user id in the API is the user's id **in this company**, the same one
    `GET /users` returns. This applies to what the API returns (`user.id`,
    `assignedTo.id`, `userCreated.id`) and to what it accepts (`userId`,
    `userIds`, `assignedToUserId` and the `{id}` in user routes).


    The same person can work in several companies, with a different name and
    profile in each one, and has a different id in each company.


    An id that does not belong to this company returns `404`, with the same
    message as an id that does not exist.


    ## Pagination


    Every list `GET` is paginated. The `meta` contains only `page`, `perPage`
    and `hasMore`, without the total number of records. To go through
    everything, keep advancing `page` while `hasMore` is `true`.


    ## Idempotency


    Optional on `POST`/`PUT`, through the `Idempotency-Key` header. If you
    repeat the call with the same key and the same body, you get the stored
    response (with `Idempotent-Replay: true`). With the same key and a different
    body, the response is `409`.
servers:
  - url: https://api.connectadesk.com/api/v1
    description: Production
security:
  - apiToken: []
tags:
  - name: contacts
    description: Contact records, extra fields and marketing source.
  - name: tickets
    x-displayName: Tickets
    description: Opening, transferring, closing and wrap-up of tickets.
  - name: messages
    description: Asynchronous sending and reading of messages.
  - name: tags
    description: Tags and their link to tickets.
  - name: queues
    description: Service queues and their agents.
  - name: wrapups
    description: Wrap-up types.
  - name: users
    description: Agents and administrators.
  - name: schedules
    description: Scheduled messages.
  - name: quick-messages
    description: Quick replies.
  - name: campaigns
    description: Bulk sending.
  - name: crm
    description: Boards, stages, cards and metrics.
  - name: channels
    description: Channels (read only).
  - name: reports
    description: Reports and dashboards.
  - name: products
    description: Product catalog, categories and sales performance.
  - name: custom-fields
    description: Custom fields for contacts and cards, plus company-wide global variables.
  - name: profiles
    description: Company permission profiles (read only).
  - name: webchat
    description: >-
      Native webchat from your own system: open a visitor session, send and read
      messages. The token needs the `webchat` scope (GET and POST).
paths:
  /channels/{id}/templates:
    parameters:
      - $ref: '#/components/parameters/idParam'
      - $ref: '#/components/parameters/page'
      - $ref: '#/components/parameters/perPage'
      - name: status
        in: query
        description: >-
          Template status. Accepts more than one, separated by commas. Without
          the filter, all of

          them come — including drafts and rejected ones.


          | Value | When it shows up |

          |---|---|

          | `APPROVED` | Approved by the provider, ready to send |

          | `PENDING` | Submitted and waiting for review |

          | `REJECTED` | Rejected |

          | `PAUSED` | Paused by the provider, for quality |

          | `DISABLED` | Disabled by Meta due to quality, permanently |

          | `ARCHIVED` | Archived |

          | `DRAFT` | Draft, not submitted for review yet |
        schema:
          type: string
        example: APPROVED
      - name: queueId
        in: query
        description: >-
          Returns only the templates this queue can use: the ones that apply to
          every queue plus the

          ones linked to it. The queue must belong to your company.
        schema:
          type: integer
        example: 13
    get:
      tags:
        - channels
      summary: List channel templates
      description: >-
        Lists the channel templates. This is where you find the **name** to use
        in `template.name` and how many variables each template requires.


        The list comes from Connecta DESK, not from a lookup at the provider:
        that is why it answers fast and takes the status and queue filters. The
        catalog is fed by the synchronization with Meta/Gupshup, so a template
        approved at the provider right now shows up here after the next
        synchronization.


        A channel with no synchronized template returns an empty list and
        schedules the synchronization in the background — the next call already
        finds the catalog. A channel that does not use approved templates also
        returns an empty list, with no error.
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                type: object
                properties:
                  data:
                    type: array
                    items:
                      $ref: '#/components/schemas/ChannelTemplate'
                  meta:
                    $ref: '#/components/schemas/PageMeta'
        '404':
          $ref: '#/components/responses/NotFound'
components:
  parameters:
    idParam:
      name: id
      in: path
      required: true
      schema:
        type: integer
      example: 1042
    page:
      name: page
      in: query
      description: Page number, starting at 1. An invalid value is treated as 1.
      schema:
        type: integer
        minimum: 1
        default: 1
      example: 1
    perPage:
      name: perPage
      in: query
      description: >-
        Number of items per page. The maximum depends on the environment
        (default 100).
      schema:
        type: integer
        minimum: 1
        maximum: 100
        default: 20
      example: 50
  schemas:
    ChannelTemplate:
      type: object
      description: >-
        Approved template of the channel, with the information you need to know
        what to send.
      properties:
        name:
          type: string
          example: confirmacao_pedido
          description: Display name.
        language:
          type: string
          example: pt_BR
        status:
          type: string
          example: APPROVED
        category:
          type: string
          nullable: true
          example: UTILITY
        bodyText:
          type: string
          description: Body text, with the `{{n}}` placeholders.
          example: Olá {{1}}, seu pedido {{2}} foi confirmado.
        bodyVariables:
          type: integer
          description: Number of items `template.parameters.body` must have.
          example: 2
        headerType:
          type: string
          nullable: true
          enum:
            - TEXT
            - IMAGE
            - VIDEO
            - DOCUMENT
            - LOCATION
          description: |-
            Template header type, as approved by Meta:

            | value | meaning |
            | --- | --- |
            | `TEXT` | Text. |
            | `IMAGE` | Image. |
            | `VIDEO` | Video. |
            | `DOCUMENT` | Document (PDF and similar). |
            | `LOCATION` | Location. |
        headerText:
          type: string
          nullable: true
        headerVariables:
          type: integer
          description: >-
            Number of items `template.parameters.header` must have. Always 0
            when the header is media.
          example: 0
        headerRequiresMedia:
          type: boolean
          description: >-
            `true` when the header is an image, video or document. In that case,
            the file is sent through the scheduled message's media upload, not
            through `parameters.header`.
        footerText:
          type: string
          nullable: true
        buttons:
          type: array
          items:
            type: object
    PageMeta:
      type: object
      required:
        - page
        - perPage
        - hasMore
      properties:
        page:
          type: integer
          example: 1
        perPage:
          type: integer
          example: 20
        hasMore:
          type: boolean
          description: Whether there are more records beyond this page.
          example: true
      example:
        page: 1
        perPage: 20
        hasMore: true
    Error:
      type: object
      required:
        - error
      properties:
        error:
          type: object
          required:
            - code
            - message
          properties:
            code:
              type: string
              description: Fixed error code, so your system can handle each case.
              example: ERR_API_FORBIDDEN_SCOPE
            message:
              type: string
            details: {}
  responses:
    NotFound:
      description: >-
        The resource does not exist or belongs to another company. For security,
        the response is the same in both cases.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            error:
              code: ERR_API_NOT_FOUND
              message: Registro não encontrado.
  securitySchemes:
    apiToken:
      type: http
      scheme: bearer
      description: API token in the `sk_live_…` format.

````

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