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

# Configure or change the proxy

> Explicitly sets one of the three accepted states:
  - `mode=custom`: uses your own proxy provided in `proxy_url`;
  - `mode=internal`: uses the internal infrastructure; or
  - `mode=none`: direct connection, allowed only with `confirm_no_proxy=true`.

Important: `POST /instance/proxy` confirms that the configuration was saved, not that the proxy has already been proven to be in use.
The main operational validation happens in the instance's next real connection cycle.

In practical terms:
  - `200 OK` here = configuration persisted successfully;
  - real connectivity failures may appear later; and
  - to observe the real state, query `GET /instance/proxy` and read:
    - `effective_mode`
    - `effective_detail`
    - `fallback.active`
    - `last_test_error`
    - `validation_error`

When `mode=custom`, you can also define the fallback via `proxy_fallback`:
  - `internal`: tries the internal infrastructure and, if it still fails, may use direct as a last resort;
  - `never`: does not use a fallback; or
  - a fallback proxy URL controlled by the client.

When `mode=internal`, `rotate_now: true` immediately replaces the persisted internal proxy.
If more than one internal source is available, the platform picks another source without exposing the provider.
If there is only one source, it only swaps the proxy/IP within that source.

Protocols accepted in custom proxy URLs:
  - `http://usuario:senha@host:porta`
  - `https://usuario:senha@host:porta`
  - `socks5://usuario:senha@host:porta`
  - `socks5h://usuario:senha@host:porta`

The generic `socks://` scheme is not accepted. For SOCKS proxies, use `socks5://` or `socks5h://`.




## OpenAPI

````yaml /openapi-en.json post /instance/proxy
openapi: 3.1.0
info:
  title: WppFy -  WhatsApp API
  version: 1.0.0
  description: >
    API for managing WhatsApp instances and communications.


    ## Important Recommendation: WhatsApp Business

    **It is HIGHLY RECOMMENDED to use WhatsApp Business accounts** instead of
    regular WhatsApp for integration; regular WhatsApp may present
    inconsistencies, disconnections, limitations, and instability when used with
    our API.


    ## Authentication

    - Regular endpoints require a 'token' header with the instance token


    ## Instance States

    Instances can be in the following states:

    - `disconnected`: Disconnected from WhatsApp

    - `connecting`: Connection in progress

    - `connected`: Successfully connected and authenticated
servers:
  - url: https://api.wppfy.com
security:
  - token: []
tags:
  - name: Instance
    description: |
      Operations related to an instance's lifecycle, such as connecting,
      disconnecting, and checking status.
  - name: Proxy
    description: >
      WppFy uses an internal proxy by default.

      You can keep this default, configure your own proxy via `proxy_url`, or
      use your Android phone as a proxy by installing the app from
      https://github.com/WppFy/silver_proxy_apk (direct APK:
      https://github.com/WppFy/silver_proxy_apk/raw/refs/heads/main/silver_proxy.apk).

      If nothing is sent, we keep using the internal proxy. IPs are Brazilian;
      for international clients, consider a proxy in the client's region.
  - name: Profile
    description: |
      Operations related to the WhatsApp instance profile, such as changing
      the profile name and picture.
  - name: Business
    description: |
      ⚠️ **EXPERIMENTAL** - Endpoints not yet fully tested.

      Operations related to the WhatsApp Business business profile.
      Allows querying and updating business profile data such as description,
      address, email, categories, and managing the product catalog.

      **Requirements:**
      - The currently connected account must be a **WhatsApp Business** account
      - Personal WhatsApp accounts do not have a business profile

      **Note:** These endpoints may not work as expected.
      Report any problems found.
  - name: Calls
    description: |
      Operations related to WhatsApp calls.
      Allows making and rejecting calls programmatically.
  - name: Send Message
    description: >
      Endpoints for sending WhatsApp messages with different content types.


      ## Common Optional Fields


      All message sending endpoints support the following optional fields:


      - **`delay`** *(integer)*: Delay in milliseconds before sending
        - During the delay, "Typing..." or "Recording audio..." will appear depending on the type
        - Example: `5000` (5 seconds)

      - **`readchat`** *(boolean)*: Mark chat as read after sending
        - Removes the unread message counter from the chat
        - Example: `true`

      - **`readmessages`** *(boolean)*: Mark last received messages as read
        - Marks the last 10 **received** messages (not sent by you) as read
        - Useful to confirm reading pending messages before replying
        - Different from `readchat` which only removes the unread counter
        - Example: `true`

      - **`replyid`** *(string)*: ID of the message to reply to
        - Creates a reply linked to the original message
        - Support varies by message type
        - Example: `"3A12345678901234567890123456789012"`

      - **`mentions`** *(string)*: Numbers to mention (only for group sending)
        - Specific numbers: `"5511999999999,5511888888888"`
        - Mention all: `"all"`

      - **`forward`** *(boolean)*: Marks the message as forwarded in WhatsApp
        - Adds the "Forwarded" indicator to the message
        - Example: `true`

      - **`track_source`** *(string)*: Message tracking source
        - Identifies the system or source sending the message
        - Useful for integrations (e.g., "chatwoot", "crm", "chatbot")
        - Example: `"chatwoot"`

      - **`track_id`** *(string)*: ID for message tracking
        - Free identifier to track the message in external systems
        - Allows correlating messages between different platforms
        - **Note**: The system accepts duplicate values - there is no uniqueness validation
        - Use the same ID in multiple messages if it makes sense for your integration
        - Example: `"msg_123456789"`

      ### Sending to Groups

      - **`number`** *(string)*: To send a message to a group, use the group ID
      ending with `@g.us`
        - Example: `"120363012345678901@g.us"`
        - **How to get the Group ID:**
          - Use the `chatid` from the webhook received when someone sends a message in the group
          - Use the `GET /group/list` endpoint to list all groups and their IDs

      ## Available Placeholders


      All message sending endpoints support dynamic placeholders for automatic
      personalization:


      ### Name Fields

      - **`{{name}}`**: Consolidated chat name, using the first available
      option:
        1. Lead name (`lead_name`)
        2. Lead full name (`lead_fullName`)
        3. WhatsApp contact name (`wa_contactName`)
        4. WhatsApp profile name (`wa_name`)

      - **`{{first_name}}`**: First valid word of the consolidated name (minimum
      2 characters)


      ### WhatsApp Fields

      - **`{{wa_name}}`**: WhatsApp profile name

      - **`{{wa_contactName}}`**: Contact name as saved in WhatsApp


      ### Lead Fields

      - **`{{lead_name}}`**: Lead name

      - **`{{lead_fullName}}`**: Lead full name

      - **`{{lead_personalid}}`**: Personal ID (SSN, CPF, CNPJ, etc)

      - **`{{lead_email}}`**: Lead email

      - **`{{lead_status}}`**: Current lead status

      - **`{{lead_notes}}`**: Lead notes

      - **`{{lead_assignedAttendant_id}}`**: ID of the assigned attendant


      ### Custom Fields

      Fields added via custom fields are accessible using `{{lead_field01}}` to
      `{{lead_field20}}` or use `{{fieldname}}` defined in
      `/instance/updateFieldsMap`.


      ### Usage Example

      ```

      Hello {{name}}! I saw you work at {{company}}.

      Is your email {{lead_email}} correct?

      ```


      **💡 Tip**: Use `/chat/find` to fetch chat data and see available fields
      before sending messages with placeholders.
  - name: Async Message
    description: >
      Operational controls for the internal asynchronous send queue used when a
      send endpoint receives `async=true`.


      This section is used to:

      - check the current state of the async queue

      - configure the delay between messages sent with `async=true`

      - clear pending backlog and cancel messages not yet completed


      Scope:

      - covers only the internal queue of async direct messages

      - does not change messages already sent successfully
  - name: Message Actions and Search
  - name: Chats
  - name: Contacts
  - name: Blocklist
  - name: Labels
  - name: Groups and Communities
  - name: Newsletters and Channels
    description: >
      Operations for reading and following WhatsApp channels (newsletters).


      Main use cases:

      - list posts already published in a channel

      - edit recent posts in a channel

      - delete recent posts in a channel

      - check post views and reactions

      - integrate channels without needing to persist messages locally


      Notes:

      - `/newsletter/messages` returns the post content

      - `/newsletter/messages/edit` edits the content of recent posts

      - `/newsletter/messages/delete` deletes recent posts

      - views (`viewsCount`) and reactions (`reactionCounts`) come in each post
      of `/newsletter/messages`, not via webhook event

      - `/newsletter/updates` is deprecated: WhatsApp does not respond and the
      API returns 504

      - newsletters use their own routes and must not use `/message/edit` or
      `/message/delete`
  - name: Quick Replies
    description: >
      Management of quick replies to streamline service.


      **⚠️ Important**: This feature is only useful if you use a custom
      frontend/interface

      to register and use the replies. The API only stores the replies, 

      but does not apply them automatically.


      ### How it works:

      - **Create**: Register pre-defined responses with titles and content

      - **List**: Retrieve all registered responses to display in your interface

      - **Use**: Your frontend system can use these responses to speed up typing


      ### Use cases:

      - Custom web service interfaces

      - Mobile apps with reply suggestions

      - CRM systems with message templates

      - Productivity tools for attendants


      **Not a chatbot**: For automatic responses, use Chatbot features.
  - name: CRM
    description: >
      Complete customer relationship management system integrated with the API.


      **💾 Internal Storage**: All lead data is saved directly in the API,

      eliminating the need for external databases. Your application can focus
      only

      on the interface and business logic.


      ### Available Features:

      - **📋 20+ customizable fields**: Name, phone, email, company, notes, etc.

      - **🏷️ Label System**: Organize and categorize your contacts

      - **🔍 Advanced Search**: Filter by any field or label

      - **📊 Complete History**: All interactions are registered automatically


      ### 🎯 Placeholders in messages:

      Use dynamic variables in messages for automatic personalization:


      ```

      Hello {{name}}! I saw you work at {{company}}.

      Is your email {{email}} correct?

      Notes: {{notes}}

      ```


      ### Typical Flow:

      1. **Capture**: Leads arrive via WhatsApp or forms

      2. **Enrichment**: Add data using `/chat/editLead`

      3. **Segmentation**: Organize with labels

      4. **Communication**: Send personalized messages with placeholders

      5. **Follow-up**: History is saved automatically


      **Ideal for**: Sales, marketing, support, lead qualification
  - name: Chatwoot Integration
    description: >
      **🚧 BETA INTEGRATION - Chatwoot integration system for unified service**


      **⚠️ WARNING**: This integration is in BETA phase. Use at your own risk.
      We recommend testing in a non-production environment before use in
      production.


      This category contains resources to configure and manage integration with
      Chatwoot, an open-source customer service platform. The integration allows
      centralizing WhatsApp conversations in Chatwoot.


      ### Available Features:

      - 🔧 **Complete Configuration**: Configure URL, tokens, and Chatwoot
      credentials

      - 📬 **Bidirectional Sync**: New messages between WhatsApp and Chatwoot
      are synced automatically

      - 📱 **Contact Management**: Automatic sync of names and phones

      - 🔄 **LID→PN Update**: Automatic migration from Local ID to Phone Number

      - 🏷️ **Smart Names**: Name system with tilde (~) for automatic update

      - 🚫 **Group Separation**: Option to ignore groups in sync

      - 👤 **Message Signature**: Agent identification in sent messages

      - 🔗 **Automatic Webhook**: URL generated automatically to configure in
      Chatwoot


      ### 🏷️ Smart Name System:

      - **Names with tilde (~)**: Updated automatically when contact modifies
      name in WhatsApp

      - **Specific names**: For fixed name, remove tilde (~) from name in
      Chatwoot

      - **Example**: "~John Doe" = automatic, "John Doe" = fixed

      - **LID→PN Migration**: No conversation duplication during transition

      - **Native responses**: Appear directly in Chatwoot without external
      markings


      ### ⚠️ Known Limitations:

      - **History sync**: Not implemented - only new messages are synced


      ### Use Cases:

      - Centralized service in Chatwoot

      - Support teams with multiple agents

      - CRM integration via Chatwoot

      - Communication channel centralization

      - Automatic contact and name management


      **Ideal for**: Companies with service teams, call centers, technical
      support (in test environment)


      **Requires**: Configured Chatwoot instance, API tokens, and test
      environment


      **🚧 Remember**: BETA integration - features may change without prior
      notice
  - name: Server-Sent Events (SSE)
paths:
  /instance/proxy:
    post:
      tags:
        - Proxy
      summary: Configure or change the proxy
      description: >
        Explicitly sets one of the three accepted states:
          - `mode=custom`: uses your own proxy provided in `proxy_url`;
          - `mode=internal`: uses the internal infrastructure; or
          - `mode=none`: direct connection, allowed only with `confirm_no_proxy=true`.

        Important: `POST /instance/proxy` confirms that the configuration was
        saved, not that the proxy has already been proven to be in use.

        The main operational validation happens in the instance's next real
        connection cycle.


        In practical terms:
          - `200 OK` here = configuration persisted successfully;
          - real connectivity failures may appear later; and
          - to observe the real state, query `GET /instance/proxy` and read:
            - `effective_mode`
            - `effective_detail`
            - `fallback.active`
            - `last_test_error`
            - `validation_error`

        When `mode=custom`, you can also define the fallback via
        `proxy_fallback`:
          - `internal`: tries the internal infrastructure and, if it still fails, may use direct as a last resort;
          - `never`: does not use a fallback; or
          - a fallback proxy URL controlled by the client.

        When `mode=internal`, `rotate_now: true` immediately replaces the
        persisted internal proxy.

        If more than one internal source is available, the platform picks
        another source without exposing the provider.

        If there is only one source, it only swaps the proxy/IP within that
        source.


        Protocols accepted in custom proxy URLs:
          - `http://usuario:senha@host:porta`
          - `https://usuario:senha@host:porta`
          - `socks5://usuario:senha@host:porta`
          - `socks5h://usuario:senha@host:porta`

        The generic `socks://` scheme is not accepted. For SOCKS proxies, use
        `socks5://` or `socks5h://`.
      requestBody:
        required: true
        content:
          application/json:
            examples:
              custom_with_internal_fallback:
                summary: Custom proxy with internal fallback
                value:
                  mode: custom
                  proxy_url: http://usuario:senha@proxy-do-cliente.example:8080
                  proxy_fallback: internal
              custom_with_explicit_backup_proxy:
                summary: Custom proxy with its own fallback proxy
                value:
                  mode: custom
                  proxy_url: http://usuario:senha@proxy-principal.example:8080
                  proxy_fallback: socks5://backup:senha@proxy-backup.example:1080
              internal_now:
                summary: Internal mode
                value:
                  mode: internal
              internal_rotate_now:
                summary: Rotate internal proxy now
                value:
                  mode: internal
                  rotate_now: true
              no_proxy:
                summary: Explicit direct
                value:
                  mode: none
                  confirm_no_proxy: true
            schema:
              type: object
              properties:
                mode:
                  type: string
                  enum:
                    - custom
                    - internal
                    - none
                  description: Canonical field for defining the proxy strategy.
                proxy_url:
                  type: string
                  description: >
                    Required when `mode=custom`.

                    Accepted protocols: `http://`, `https://`, `socks5://`, and
                    `socks5h://`.

                    The generic `socks://` scheme is not supported; use
                    `socks5://` or `socks5h://`.
                  example: http://usuario:senha@ip:porta
                proxy_fallback:
                  type: string
                  description: >
                    Fallback policy for `mode=custom`.

                    Accepts `internal`, `never`, or a fallback proxy URL using
                    `http://`, `https://`, `socks5://`, or `socks5h://`.
                confirm_no_proxy:
                  type: boolean
                  description: Required when `mode=none`.
                rotate_now:
                  type: boolean
                  description: >-
                    When `true` with `mode=internal`, immediately switches the
                    persisted internal proxy without exposing the provider used.
                  default: false
                proxy_managed_country:
                  type: string
                  description: >-
                    ISO alpha-2 country used to validate the managed proxy
                    egress. Use only with `mode=internal`.
                  example: br
                proxy_managed_state:
                  type: string
                  description: >-
                    State/province of the geographic target returned by the city
                    catalog.
                  example: sp
                proxy_managed_city:
                  type: string
                  description: City slug returned by `GET /proxy-managed/cities`.
                  example: campinas
      responses:
        '200':
          description: Proxy configured successfully
          content:
            application/json:
              examples:
                custom_internal_fallback_saved:
                  summary: >-
                    Configuration saved; actual usage will be confirmed in the
                    next connection cycle
                  value:
                    details: Proxy configurado
                    proxy:
                      mode: custom
                      effective_mode: custom
                      fallback:
                        active: false
                        reason: ''
                        since: 0
                      proxy_url: http://***:***@proxy-do-cliente.example:8080
                      proxy_fallback: internal
                      managed: false
                      last_test_at: 0
                      last_test_error: ''
                      validation_error: false
                    restart_requested: true
                after_connect_failure_example:
                  summary: Example of what GET may show later if the saved proxy fails
                  value:
                    details: Proxy configurado
                    proxy:
                      mode: custom
                      effective_mode: custom
                      fallback:
                        active: false
                        reason: ''
                        since: 0
                      proxy_url: http://***:***@proxy-do-cliente.example:8080
                      proxy_fallback: internal
                      managed: false
                      last_test_at: 0
                      last_test_error: ''
                      validation_error: false
                    restart_requested: true
                direct_explicit:
                  summary: Explicit direct
                  value:
                    details: Proxy configurado
                    proxy:
                      mode: none
                      effective_mode: direct
                      fallback:
                        active: false
                        reason: ''
                        since: 0
                      proxy_url: ''
                      proxy_fallback: internal
                      managed: false
                      last_test_at: 0
                      last_test_error: ''
                      validation_error: false
                internal_rotated:
                  summary: Internal proxy rotated
                  value:
                    details: Proxy configurado
                    rotated: true
                    proxy:
                      mode: internal
                      effective_mode: internal
                      effective_detail: managed_pool
                      fallback:
                        active: false
                        reason: ''
                        since: 0
                      proxy_url: managed_pool://hidden
                      proxy_fallback: internal
                      managed: true
                      last_test_at: 0
                      last_test_error: ''
                      validation_error: false
              schema:
                type: object
                example:
                  details: Proxy configurado
                  proxy:
                    mode: custom
                    effective_mode: custom
                    fallback:
                      active: false
                      reason: ''
                      since: 0
                    proxy_url: http://***:***@proxy-do-cliente.example:8080
                    proxy_fallback: internal
                    managed: false
                    last_test_at: 0
                    last_test_error: ''
                    validation_error: false
                  restart_requested: true
                properties:
                  details:
                    type: string
                    example: Proxy configured
                  proxy:
                    type: object
                    properties:
                      mode:
                        type: string
                        enum:
                          - custom
                          - internal
                          - none
                        description: Client's persisted intent after saving.
                      effective_mode:
                        type: string
                        enum:
                          - custom
                          - internal
                          - direct
                        description: Effective transport at the time of the response.
                      effective_detail:
                        type: string
                        enum:
                          - managed_pool
                          - internal_route
                          - relay
                        description: >-
                          Additional detail of the effective transport. When
                          there is no additional detail, the field is omitted.
                      fallback:
                        type: object
                        description: Current contingency status.
                        properties:
                          active:
                            type: boolean
                            description: >-
                              Indicates whether the instance is currently
                              operating in fallback.
                          reason:
                            type: string
                            description: >-
                              Summarized internal reason for the current
                              fallback.
                          since:
                            type: integer
                            description: >-
                              Unix timestamp in milliseconds since when the
                              current fallback has been active.
                      proxy_url:
                        type: string
                        description: Masked URL of the persisted proxy.
                      proxy_fallback:
                        type: string
                        description: Persisted fallback policy for `mode=custom`.
                      managed:
                        type: boolean
                        description: >-
                          Legacy field tied to the use of internal
                          infrastructure.
                      last_test_at:
                        type: integer
                        description: Timestamp of the last persisted test/error.
                      last_test_error:
                        type: string
                        description: Last persisted error for diagnostics.
                      validation_error:
                        type: boolean
                        description: Indicates whether `last_test_error` is populated.
                  restart_requested:
                    type: boolean
                    description: >-
                      Indicates whether a connection restart was requested to
                      apply the proxy.
                  rotated:
                    type: boolean
                    description: >-
                      Present as `true` when `rotate_now` successfully switches
                      the internal proxy.
        '400':
          description: Invalid payload or proxy validation failure
          content:
            application/json:
              schema:
                type: object
                properties:
                  error:
                    type: string
                    example: confirm_no_proxy is required to disable proxy
        '401':
          description: Invalid or expired token
          content:
            application/json:
              schema:
                type: object
                properties:
                  error:
                    type: string
                    example: Unauthorized
        '409':
          description: No alternative proxy available for internal rotation
          content:
            application/json:
              schema:
                type: object
                properties:
                  error:
                    type: string
                    example: >-
                      could not rotate internal proxy: no alternative proxy
                      available for rotation
        '500':
          description: Internal server error configuring the proxy
          content:
            application/json:
              schema:
                type: object
                properties:
                  error:
                    type: string
                    description: Message detailing the error encountered
      security:
        - token: []
components:
  securitySchemes:
    token:
      name: token
      type: apiKey
      in: header

````

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