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

# Update Chat Access

> Overrides member access on one or more chats via a map of member email to access flag. Merges into existing overrides unless replace is true. Pass null or an empty object as access with replace true to remove every override.



## OpenAPI

````yaml api-reference/openapi-generated.json PATCH /v1/chats/access
openapi: 3.0.3
info:
  title: Periskope API
  version: 1.0.0
  description: >-
    Periskope external API.


    Responses use a flat, unwrapped shape: most endpoints return the resource at
    the top level, and list endpoints return a wrapper object with pagination
    inline (e.g. `{ from, to, count, chats: [...] }`). The documented response
    schemas describe these shapes directly.
servers:
  - url: https://api.periskope.app
security:
  - bearerAuth: []
paths:
  /v1/chats/access:
    patch:
      tags:
        - Chats
      summary: Override chat access for members
      description: >-
        Overrides member access on one or more chats via a map of member email
        to access flag. Merges into existing overrides unless replace is true.
        Pass null or an empty object as access with replace true to remove every
        override.
      operationId: updateChatAccess
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties:
                access:
                  type: object
                  nullable: true
                  additionalProperties:
                    type: boolean
                  description: >-
                    Map of workspace member emails to access flags. Set an email
                    to true to grant the member access to the chats, false to
                    revoke it. Pass null or an empty object together with
                    replace true to remove every access override from the chats;
                    without replace an empty map changes nothing.
                  example:
                    user@example.com: true
                chat_ids:
                  type: array
                  items:
                    type: string
                  minItems: 1
                  description: Ids of the chats whose access overrides to update
                  example:
                    - 120363000000000000@g.us
                    - 922222222222@c.us
                replace:
                  type: boolean
                  description: >-
                    When true, the existing access overrides of each chat are
                    fully replaced with the given access map (an empty or null
                    map then removes every override). Defaults to false (the map
                    is merged into the existing overrides; an empty or null map
                    changes nothing).
                  example: false
              required:
                - access
                - chat_ids
      responses:
        '204':
          description: Chat access overrides updated — no content
        '401':
          description: Invalid, expired or missing API token
          content:
            application/json:
              examples:
                error:
                  summary: Invalid, expired or missing API token
                  value:
                    code: UNAUTHORIZED_ERROR
                    message: Invalid bearer auth token
                    status: 401
              schema:
                type: object
                properties:
                  code:
                    type: string
                    example: UNAUTHORIZED_ERROR
                  message:
                    type: string
                    example: Invalid bearer auth token
                  status:
                    type: integer
                    example: 401
                example:
                  code: UNAUTHORIZED_ERROR
                  message: Invalid bearer auth token
                  status: 401
        '422':
          description: Request validation failed
          content:
            application/json:
              examples:
                error:
                  summary: Request validation failed
                  value:
                    code: VALIDATION_ERROR
                    message: Request validation failed
                    status: 422
                    fields:
                      body.chat_id:
                        message: chat_id is required
              schema:
                type: object
                properties:
                  code:
                    type: string
                    example: VALIDATION_ERROR
                  message:
                    type: string
                    example: Request validation failed
                  status:
                    type: integer
                    example: 422
                  fields:
                    type: object
                    additionalProperties:
                      type: object
                      properties:
                        message:
                          type: string
                        value: {}
                    example:
                      body.chat_id:
                        message: chat_id is required
                example:
                  code: VALIDATION_ERROR
                  message: Request validation failed
                  status: 422
                  fields:
                    body.chat_id:
                      message: chat_id is required
        '429':
          description: Rate limit exceeded
          content:
            application/json:
              examples:
                error:
                  summary: Rate limit exceeded
                  value:
                    code: RATE_LIMIT_ERROR
                    message: You can only make 100 requests per second
                    status: 429
              schema:
                type: object
                properties:
                  code:
                    type: string
                    example: RATE_LIMIT_ERROR
                  message:
                    type: string
                    example: You can only make 100 requests per second
                  status:
                    type: integer
                    example: 429
                example:
                  code: RATE_LIMIT_ERROR
                  message: You can only make 100 requests per second
                  status: 429
        '500':
          description: Internal server error
          content:
            application/json:
              examples:
                error:
                  summary: Internal server error
                  value:
                    code: UNKNOWN_ERROR
                    message: Internal server error
                    status: 500
              schema:
                type: object
                properties:
                  code:
                    type: string
                    example: UNKNOWN_ERROR
                  message:
                    type: string
                    example: Internal server error
                  status:
                    type: integer
                    example: 500
                example:
                  code: UNKNOWN_ERROR
                  message: Internal server error
                  status: 500
      security:
        - bearerAuth: []
      x-codeSamples:
        - lang: typescript
          label: TypeScript
          source: |-
            import { PeriskopeApi } from '@periskope/periskope-client';

            const client = new PeriskopeApi({
              authToken: 'YOUR_API_KEY',
            });

            async function main() {
              const response = await client.chats.updateChatAccess({
                access: {
                  'user@example.com': true,
                },
                chat_ids: [
                  '120363000000000000@g.us',
                  '922222222222@c.us',
                ],
              });
              console.log(response);
            }

            main();
        - lang: bash
          label: cURL
          source: |-
            curl -X PATCH 'https://api.periskope.app/v1/chats/access' \
              -H 'Authorization: Bearer YOUR_API_KEY' \
              -H 'Content-Type: application/json' \
              -d '{
                "access": {
                  "user@example.com": true
                },
                "chat_ids": [
                  "120363000000000000@g.us",
                  "922222222222@c.us"
                ]
              }'
components:
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: >-
        Your Periskope API token, sent as `Authorization: Bearer <token>`.
        Generate one from the Periskope dashboard under **Settings → API &
        Webhooks**. API access requires an active Pro or Enterprise plan.

````

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