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

> Enables or disables channels of one sender, or changes the alias of a mailbox.

# Update Campaign Sender Channels

<Note>
  The sender pool requires at least the **Email Pro** plan.
</Note>

<Tip>
  To pin the sender of one step, outside the pool, see
  [Set Step Sender](/api-reference/endpoints/sequences/set-step-sender) in the
  Sequences group.
</Tip>

Changes the channels of one sender in the pool. The changes apply in the order
of the body. The channels that the body does not list do not change.

| Change | Body entry |
| - | - |
| Enable one account | `{ "type": "whatsapp", "id": "<account id>", "enabled": true }` |
| Enable every account of a type | `{ "type": "email", "enabled": true }` |
| Disable one account | `{ "type": "email", "id": "<mailbox id>", "enabled": false }` |
| Change the alias of a mailbox | `{ "type": "email", "id": "<mailbox id>", "alias": "<address>" }` |

* A sender outside the pool joins the pool with the enabled channels.
* When the last channel of a sender is disabled, the sender leaves the pool.
* LinkedIn cannot be disabled alone: a sender in the pool always sends on
  LinkedIn. To stop it, use
  [Remove Campaign Sender](/api-reference/endpoints/senders/remove-campaign-sender).
* An enabled channel type must be used by at least one step of the campaign.

When the change disables a channel, `impact.contactedLeads` gives the
contacted leads that keep this channel. Their next steps stop with a "Send user
is missing" error, until the channel comes back in the pool.


## OpenAPI

````yaml patch /campaigns/{campaignId}/senders/{userId}
openapi: 3.0.0
info:
  title: lemlist API
  version: 1.0.0
  description: >-
    Welcome to the lemlist Developer Documentation.


    lemlist is very customizable and open. You'll find on this page all the API
    and integration you can do with lemlist.


    # Rate Limit


    lemlist's API rate limits requests in order to prevent abuse and overload of
    our services.  

    Rate limits are applied on all routes and per API key performing the
    request.  

    The rate limits are **20** requests per **2** seconds.  

    The response provides any information you may need about it:


    | Header | Description |

    | --- | --- |

    | Retry-After | The number of seconds in which you can retry |

    | X-RateLimit-Limit | The maximum requests in that time |

    | X-RateLimit-Remaining | The number of remaining requests you can make |

    | X-RateLimit-Reset | The date when the rate limit will reset |


    _Example of values for the rate limit headers_


    ``` json

    {
        "Retry-After": 2,
        "X-RateLimit-Limit": 20,
        "X-RateLimit-Remaining": 7,
        "X-RateLimit-Reset" : "Tue Feb 16 2021 09:02:42 GMT+0100 (Central European Standard Time)"
    }

     ```

    # Definitions


    ## Team


    A team is the entity of lemlist that can handle users and billing.


    ## Credits


    Credits are the coins a team uses to enrich emails, LinkedIn URLs, etc. via
    the enrich route. Each enrichment feature needs a certain amount of credits
    to run.


    ## User


    You use a user account to connect to lemlist and send messages via the
    connected emails or LinkedIn account.


    ## Campaign


    A campaign is the entity to automate outreach. A campaign has multiple
    sequences composed of steps.


    ## Lead


    A lead is a person that you try to contact via a campaign.


    ## Activity


    An activity is the history of all the steps.


    ## Unsubscribe


    An unsubscribe occurs when a person decides they don't want to receive
    emails from you anymore.


    # Authentication


    All API routes use the dedicated subdomain `api.lemlist.com`.


    lemlist uses API keys to allow access to the API. You can get your lemlist
    API key at our [integration
    page](https://app.lemlist.com/settings/integrations).


    You need to add the `Authorization` header using the `Basic` authentication
    type. `login:password` **where the login is always empty and the password is
    the API key**.


    ⚠️ **Don't forget to add the semicolon (**`:`**) before your API key in curl
    command.**


    > To authorize, use this code: 
      

    ``` shell

    curl https://api.lemlist.com/api/team \
      --user ":YourApiKey"

     ```

    **Make sure to replace** **`YourApiKey`** **with your API key.**


    # Give feedback


    If you want to report a bug, ask for data, or share with us a use case,
    please fill this [form](https://lemlist.typeform.com/to/mfVlkyGf). It will
    help us centralize your needs!
servers:
  - url: https://api.lemlist.com/api
security:
  - basicAuth: []
tags:
  - name: Enrichment Providers
    description: >-
      The data providers lemlist can call to find an email or a phone.


      Internal providers are paid with lemlist credits and always available.
      External providers run on your own account: connect one by saving its API
      key, and it becomes available to your waterfalls. `GET
      /enrichments/providers` is the catalog of provider ids accepted by the
      waterfall endpoints.
  - name: Enrichment Waterfalls
    description: >-
      Control which data providers lemlist calls when enriching a contact, and
      in which order.


      A waterfall is an ordered list of providers for one enrichment `type`
      (`email` or `phone`). Providers are tried one after the other until one
      returns a result.


      Every team has exactly one default waterfall per type (`isDefault: true`).
      While its `editor` is `lemlist` it follows the lemlist behaviour:
      providers you connected with your own API key are tried first, then
      internal providers in a random order. Once a team member edits its
      provider list, `editor` becomes that user's id and the list is followed as
      is; resetting it hands it back to `lemlist`.


      Custom waterfalls (`isDefault: false`) carry `conditions` on the contact
      being enriched, keyed by contact property; every key present must match.
      When a contact is enriched, lemlist runs a single waterfall: the custom
      waterfall of the requested type whose conditions match the contact, or the
      default waterfall when none does. If several match, the one with the most
      condition keys wins, then the most recently updated. Only that waterfall
      runs; when it finds nothing, the enrichment ends without falling back to
      another one.
paths:
  /campaigns/{campaignId}/senders/{userId}:
    parameters:
      - name: campaignId
        in: path
        required: true
        description: The unique identifier of the campaign
        example: cam_A1b2C3d4E5f6G7h8M
        schema:
          type: string
      - name: userId
        in: path
        required: true
        description: The team member to change
        example: usr_A1b2C3d4E5f6G7h8N
        schema:
          type: string
    patch:
      tags:
        - Senders
      summary: Update Campaign Sender Channels
      description: >-
        Enables or disables channels of one sender in the pool of a campaign, or
        changes the alias of a mailbox. The changes apply in order. The other
        channels of the sender do not change. Requires the Email Pro plan.
      parameters: []
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - channels
              additionalProperties: false
              properties:
                channels:
                  type: array
                  minItems: 1
                  items:
                    type: object
                    required:
                      - type
                    additionalProperties: false
                    properties:
                      type:
                        type: string
                        enum:
                          - email
                          - linkedin
                          - whatsapp
                          - phone
                      id:
                        type: string
                        description: >-
                          The account: the mailbox id, the WhatsApp account id
                          or the phone number. Omit it for `linkedin`. Without
                          `id`, the change applies to every account of the type.
                      alias:
                        type: string
                        description: >-
                          Email only, with an `id`: the alias address of the
                          mailbox to send as. Forbidden with `enabled: false`.
                      enabled:
                        type: boolean
                        description: >-
                          `true` enables the channel, `false` disables it.
                          Without `enabled`, only the alias changes: `id` and
                          `alias` are then required.
            example:
              channels:
                - type: whatsapp
                  id: uwa_A1b2C3d4E5f6G7h8Q
                  enabled: true
                - type: email
                  id: usm_A1b2C3d4E5f6G7h8P
                  alias: hello@example.com
      responses:
        '200':
          description: Success
          content:
            application/json:
              schema:
                type: object
                properties:
                  data:
                    $ref: '#/components/schemas/SenderPool'
                  impact:
                    type: object
                    description: Present when the change removes a sender or a channel.
                    properties:
                      contactedLeads:
                        type: integer
                        description: >-
                          The contacted leads that keep a removed sender or a
                          removed channel. Their next steps stop with a "Send
                          user is missing" error until the sender is back in the
                          pool.
              example:
                data:
                  campaignId: cam_A1b2C3d4E5f6G7h8M
                  senderStrategy: random
                  espMatching: false
                  readOnly: false
                  senders:
                    - userId: usr_A1b2C3d4E5f6G7h8K
                      name: John Doe
                      email: john@example.com
                      channels:
                        - type: email
                          id: usm_A1b2C3d4E5f6G7h8L
                          label: john@example.com
                          alias: john@example.com
                          esp: google
                          diagnostics: []
                      diagnostics: []
                    - userId: usr_A1b2C3d4E5f6G7h8N
                      name: Jane Smith
                      email: jane@example.com
                      channels:
                        - type: email
                          id: usm_A1b2C3d4E5f6G7h8P
                          label: jane@example.com
                          alias: hello@example.com
                          esp: microsoft
                          diagnostics: []
                        - type: whatsapp
                          id: uwa_A1b2C3d4E5f6G7h8Q
                          label: '+15550100199'
                          diagnostics: []
                      diagnostics: []
                  diagnostics: []
        '400':
          description: >-
            Bad request: malformed user id, the body does not match the schema,
            the user is not a team member, an account or an alias does not
            belong to the user, the user has no account of the type, no step of
            the campaign uses the channel type, or a change disables LinkedIn
          content:
            application/json:
              schema:
                type: object
                properties:
                  error:
                    type: string
                    description: Human-readable error message
                  code:
                    type: string
                    description: Machine-readable error code
              example:
                error: >-
                  LinkedIn cannot be disabled alone. Remove the sender from the
                  campaign instead
                code: SENDER_CAMPAIGN_LINKEDIN_IMPLICIT
        '401':
          description: The authentication you supplied is incorrect
          content:
            text/plain:
              example: The authentication you supplied is incorrect
        '402':
          description: The sender pool requires at least the Email Pro plan
          content:
            text/plain:
              example: route is available starting emailPro plan
        '404':
          description: Campaign not found
          content:
            application/json:
              schema:
                type: object
                properties:
                  error:
                    type: string
                    description: Human-readable error message
                  code:
                    type: string
                    description: Machine-readable error code
              example:
                error: Campaign not found
                code: SENDER_CAMPAIGN_NOT_FOUND
        '405':
          description: Method not allowed
          content:
            application/json:
              schema:
                type: object
                properties:
                  error:
                    type: string
                    description: Human-readable error message
                  code:
                    type: string
                    description: Machine-readable error code
              example:
                error: Route bad method
                code: ROUTE_BAD_METHOD
        '409':
          description: >-
            The campaign uses a dynamic sender strategy: the leads select the
            senders, and the pool is read-only
          content:
            application/json:
              schema:
                type: object
                properties:
                  error:
                    type: string
                    description: Human-readable error message
                  code:
                    type: string
                    description: Machine-readable error code
              example:
                error: >-
                  The campaign uses a dynamic sender strategy: the leads select
                  the senders
                code: SENDER_CAMPAIGN_DYNAMIC_STRATEGY
components:
  schemas:
    SenderPool:
      type: object
      description: The sender pool of a campaign, as the campaign editor shows it.
      properties:
        campaignId:
          type: string
        senderStrategy:
          type: string
          description: >-
            `random`, or a dynamic strategy: `contactOwner`, `leadImporter` or
            `customField:<field>`.
        espMatching:
          type: boolean
          description: >-
            `true` when a lead gets a mailbox of the same provider as its
            address, when the pool has one.
        readOnly:
          type: boolean
          description: '`true` for a dynamic sender strategy: the leads select the senders.'
        senders:
          type: array
          items:
            type: object
            properties:
              userId:
                type: string
              name:
                type: string
              email:
                type: string
              channels:
                type: array
                description: >-
                  The enabled channels. Remove `label`, `esp` and `diagnostics`
                  to get a valid `channels` entry of the request bodies.
                items:
                  type: object
                  properties:
                    type:
                      type: string
                      enum:
                        - email
                        - linkedin
                        - whatsapp
                        - phone
                    id:
                      type: string
                      description: >-
                        The mailbox id, the WhatsApp account id, the phone
                        number, or the user id for LinkedIn.
                    label:
                      type: string
                    alias:
                      type: string
                      description: 'Email only: the address the mailbox sends as.'
                    esp:
                      type: string
                      enum:
                        - google
                        - microsoft
                        - smtp
                      description: 'Email only: the provider of the mailbox.'
                    diagnostics:
                      type: array
                      description: >-
                        The problems that block or limit the sending. See [Get
                        Campaign
                        Senders](/api-reference/endpoints/senders/get-campaign-senders#diagnostics).
                      items:
                        $ref: '#/components/schemas/SenderDiagnostic'
              diagnostics:
                type: array
                description: >-
                  The problems that block or limit the sending. See [Get
                  Campaign
                  Senders](/api-reference/endpoints/senders/get-campaign-senders#diagnostics).
                items:
                  $ref: '#/components/schemas/SenderDiagnostic'
        diagnostics:
          type: array
          description: >-
            The problems of the whole pool, for example no account of a required
            channel type in the team.
          items:
            $ref: '#/components/schemas/SenderDiagnostic'
    SenderDiagnostic:
      type: object
      description: One health problem of a sender, a channel or the whole pool.
      properties:
        scope:
          type: string
          enum:
            - channel
            - user
            - step
            - global
          description: >-
            What the problem is about: one channel, one sender, one step or the
            whole pool.
        type:
          type: string
          enum:
            - error
            - warning
            - info
          description: '`error` blocks the sending. `warning` and `info` do not.'
        code:
          type: string
          enum:
            - channel_missing
            - channel_disconnected
            - channel_linked_elsewhere
            - channel_issue
            - channel_not_required
            - license_missing
            - no_required_channel_active
            - no_account_connected
            - no_sender_enabled
            - sender_paused
        message:
          type: string
          description: More details, for example the error of a mailbox.
        channelType:
          type: string
          enum:
            - email
            - linkedin
            - whatsapp
            - phone
          description: >-
            The channel type of the problem. Absent when the problem is not
            about one channel type.
  securitySchemes:
    basicAuth:
      type: http
      scheme: basic

````

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