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

> ## Agent Instructions
> Install the Courier skill before writing code: `npx skills add trycourier/courier-skills`. It carries the verified SDK shapes and the rules you cannot get wrong.
> Authenticate every request with `Authorization: Bearer <API_KEY>`. A workspace has several environments and each has its own keys, which are plain `pk_` strings with no environment prefix. Start with Test.
> Send with `client.send.message`, the default import of the v7 Node SDK. Reference a template by its `nt_` id or its alias.
> A send accepts a bare Elemental element list, but storing content on a template requires the top-level elements wrapped in a channel element.
> Templates and journeys can be built in the Courier app or created through the API. Either way they live in the workspace and are referenced by ID when you send.
> The hosted MCP server is https://mcp.courier.com. For a briefing on what Courier is and when to use it, read https://www.courier.com/llms.txt.
> Prefer the Guides tab for how-do-I questions and the Docs tab for how-does-it-behave questions. The API reference lives under /api-reference.

# Send Viber messages through Courier

> Connect a Viber bot with an auth token and address a recipient with viber.receiver.

export const Endpoint = ({method, path, name, href, children, bare}) => {
  const verb = String(method || "").toUpperCase();
  const title = verb + " " + path;
  const label = children || name || path;
  if (bare) {
    return href ? <a href={href}><code>{title}</code></a> : <code>{title}</code>;
  }
  if (!href) {
    return <span className="cx-endpoint" data-method={verb} title={title}>
        <span className="cx-endpoint-label">{label}</span>
        <span className="cx-endpoint-method">{verb}</span>
      </span>;
  }
  return <a className="cx-endpoint" data-method={verb} href={href} title={title}>
      <span className="cx-endpoint-label">{label}</span>
      <span className="cx-endpoint-method">{verb}</span>
    </a>;
};

export const AppLink = ({href, children, name, bare}) => {
  const label = children || name || "Open in Courier";
  if (bare) {
    return <a href={href} target="_blank" rel="noreferrer">{label}</a>;
  }
  return <a className="cx-endpoint" data-kind="app" href={href} target="_blank" rel="noreferrer">
      <span className="cx-endpoint-label">{label}</span>
      <span className="cx-endpoint-method" aria-hidden="true">↗</span>
    </a>;
};

export const Doc = ({href, children, name, bare}) => {
  const label = children || name || href;
  if (bare) {
    return <a href={href}>{label}</a>;
  }
  return <a className="cx-endpoint" data-kind="doc" href={href}>
      <span className="cx-endpoint-label">{label}</span>
      <span className="cx-endpoint-method">DOC</span>
    </a>;
};

## Prerequisites

* [A Viber bot account](https://partners.viber.com/account/create-bot-account)
* Your Viber bot auth token
* [A webhook server that receives Viber POST requests](https://www.npmjs.com/package/viber-bot)

## Setup

Open the <AppLink href="https://app.courier.com/integrations/catalog/viber">Viber integration</AppLink> in Courier, enter your auth token and sender name, then save.

### Webhooks server

Viber requires a registered webhooks server before you send notifications:

```bash theme={null}
curl -X POST 'https://chatapi.viber.com/pa/set_webhook' \
     -H 'Content-Type: application/json' \
     -H 'X-Viber-Auth-Token: VIBER_AUTH_TOKEN' \
     -d '{ "url": "YOUR_WEBHOOK_SERVER_URL", "event_types": ["delivered"] }'
```

The server receives Viber events: the UserIDs of users who subscribe, and delivery status events.

## Profile requirements

Viber addresses the recipient by `UserID`, which goes in `viber.receiver` on the profile. Store it once with <Endpoint method="POST" path="/profiles/{user_id}" name="Create a Profile" href="/docs/api-reference/user-profiles/create-a-profile" />, which merges into the profile and creates it if it does not exist:

<CodeGroup>
  ```javascript Node.js highlight={3-5} theme={null}
  const profile = await client.profiles.create('user_123', {
    profile: {
      viber: {
        receiver: '12943673==',
      },
    },
  });
  ```

  ```python Python highlight={4-6} theme={null}
  profile = client.profiles.create(
      user_id="user_123",
      profile={
          "viber": {
              "receiver": "12943673==",
          },
      },
  )
  ```

  ```bash cURL highlight={7-9} theme={null}
  curl --request POST \
    --url https://api.courier.com/profiles/user_123 \
    --header "Authorization: Bearer $COURIER_API_KEY" \
    --header 'Content-Type: application/json' \
    --data '{
      "profile": {
        "viber": {
          "receiver": "12943673=="
        }
      }
    }'
  ```

  ```ruby Ruby highlight={4-6} theme={null}
  profile = courier.profiles.create(
    "user_123",
    profile: {
      viber: {
        receiver: "12943673=="
      }
    }
  )
  ```

  ```go Go highlight={6-8} theme={null}
  profile, err := client.Profiles.New(
  	context.TODO(),
  	"user_123",
  	courier.ProfileNewParams{
  		Profile: map[string]any{
  			"viber": map[string]any{
  				"receiver": "12943673==",
  			},
  		},
  	},
  )
  ```

  ```java Java highlight={4-5} theme={null}
  ProfileCreateParams params = ProfileCreateParams.builder()
      .userId("user_123")
      .profile(ProfileCreateParams.Profile.builder()
          .putAdditionalProperty("viber", JsonValue.from(java.util.Map.of(
              "receiver", "12943673==")))
          .build())
      .build();
  ProfileCreateResponse profile = client.profiles().create(params);
  ```

  ```php PHP highlight={2-4} theme={null}
  $profile = $client->profiles->create('user_123', profile: [
    'viber' => [
      'receiver' => '12943673==',
    ],
  ]);
  ```

  ```csharp C# highlight={7-9} theme={null}
  ProfileCreateParams parameters = new()
  {
      UserID = "user_123",
      Profile = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(
          """
          {
            "viber": {
              "receiver": "12943673=="
            }
          }
          """
      ),
  };
  var profile = await client.Profiles.Create(parameters);
  ```

  ```bash CLI highlight={4} wrap theme={null}
  courier profiles create \
    --api-key "$COURIER_API_KEY" \
    --user-id user_123 \
    --profile '{"viber":{"receiver":"12943673=="}}'
  ```

  ```text MCP theme={null}
  With Courier MCP, save the Viber receiver 12943673== on user_123.
  ```
</CodeGroup>

The recipient needs an active [Viber](https://www.viber.com/en/) account. Viber sends the `UserID` to your webhooks server after a user messages the Viber bot.

Then send to `user_id` and Courier resolves the address.

For a one-off with no stored profile, pass it inline instead: `"to": { "viber": { "receiver": "12943673==" } }`.

<CardGroup cols={1}>
  <Card title="Send by user id" icon="user" href="/docs/recipients/overview#send-by-user-id">
    The call in every language, and the rest of the profile object.
  </Card>
</CardGroup>

## Send to a recipient

<Tabs>
  <Tab title="Send to user id">
    Courier reads `viber` off the saved profile, so preferences apply and the value can change without touching this code.

    <CodeGroup>
      ```javascript Node.js highlight={4} theme={null}
      const { requestId } = await courier.send.message({
        message: {
          to: {
            user_id: "user_123",
          },
          template: "nt_01kx4h2jdafq8bk9aftxak4b40",
        },
      });
      ```

      ```python Python highlight={4} theme={null}
      response = client.send.message(
          message={
              "to": {
                  "user_id": "user_123",
              },
              "template": "nt_01kx4h2jdafq8bk9aftxak4b40",
          },
      )
      ```

      ```bash cURL highlight={7} wrap theme={null}
      curl -X POST https://api.courier.com/send \
        -H "Authorization: Bearer $COURIER_API_KEY" \
        -H "Content-Type: application/json" \
        -d '{
          "message": {
            "to": {
              "user_id": "user_123"
            },
            "template": "nt_01kx4h2jdafq8bk9aftxak4b40"
          }
        }'
      ```

      ```ruby Ruby highlight={4} theme={null}
      response = courier.send_.message(
        message: {
          to: {
            user_id: "user_123"
          },
          template: "nt_01kx4h2jdafq8bk9aftxak4b40"
        }
      )
      ```

      ```go Go highlight={5} theme={null}
      response, err := client.Send.Message(context.TODO(), courier.SendMessageParams{
      	Message: courier.SendMessageParamsMessage{
      		To: courier.SendMessageParamsMessageToUnion{
      			OfUserRecipient: &shared.UserRecipientParam{
      				UserID: courier.String("user_123"),
      			},
      		},
      		Template: courier.String("nt_01kx4h2jdafq8bk9aftxak4b40"),
      	},
      })
      ```

      ```java Java highlight={3} theme={null}
      SendMessageParams params = SendMessageParams.builder()
          .message(SendMessageParams.Message.builder()
              .to(UserRecipient.builder().userId("user_123").build())
              .template("nt_01kx4h2jdafq8bk9aftxak4b40")
              .build())
          .build();
      SendMessageResponse response = client.send().message(params);
      ```

      ```php PHP highlight={4} theme={null}
      $response = $client->send->message(
        message: [
          'to' => [
            'user_id' => 'user_123',
          ],
          'template' => 'nt_01kx4h2jdafq8bk9aftxak4b40',
        ],
      );
      ```

      ```csharp C# highlight={5} theme={null}
      SendMessageParams parameters = new()
      {
          Message = new()
          {
              To = new UserRecipient { UserID = "user_123" },
              Template = "nt_01kx4h2jdafq8bk9aftxak4b40",
          },
      };

      var response = await client.Send.Message(parameters);
      ```

      ```bash CLI highlight={3} wrap theme={null}
      courier send message \
        --api-key "$COURIER_API_KEY" \
        --message.to '{"user_id": "user_123"}' \
        --message.template nt_01kx4h2jdafq8bk9aftxak4b40
      ```

      ```text MCP theme={null}
      With Courier MCP, send my template to user_123 by email.
      ```
    </CodeGroup>
  </Tab>

  <Tab title="Send to `viber`">
    Pass it inline instead and nothing is stored. Swap this `to` object into the call on the other tab.

    <CodeGroup>
      ```javascript Node.js highlight={5-7} theme={null}
      const { requestId } = await courier.send.message({
        message: {
          // A provider recipient is a profile field, so it sits outside the typed union.
          to: {
            viber: {
              receiver: "12943673==",
            },
          } as any,
          template: "nt_01kx4h2jdafq8bk9aftxak4b40",
        },
      });
      ```

      ```python Python highlight={4-6} theme={null}
      response = client.send.message(
          message={
              "to": {
                  "viber": {
                      "receiver": "12943673==",
                  },
              },
              "template": "nt_01kx4h2jdafq8bk9aftxak4b40",
          },
      )
      ```

      ```bash cURL highlight={7-9} wrap theme={null}
      curl -X POST https://api.courier.com/send \
        -H "Authorization: Bearer $COURIER_API_KEY" \
        -H "Content-Type: application/json" \
        -d '{
          "message": {
            "to": {
              "viber": {
                "receiver": "12943673=="
              }
            },
            "template": "nt_01kx4h2jdafq8bk9aftxak4b40"
          }
        }'
      ```

      ```ruby Ruby highlight={4-6} theme={null}
      response = courier.send_.message(
        message: {
          to: {
            viber: {
              receiver: "12943673=="
            }
          },
          template: "nt_01kx4h2jdafq8bk9aftxak4b40"
        }
      )
      ```

      ```go Go highlight={2-4} theme={null}
      // A provider recipient is a profile field, so it sits outside the typed union.
      to := param.Override[shared.UserRecipientParam](
      	json.RawMessage(`{"viber": {"receiver": "12943673=="}}`),
      )

      response, err := client.Send.Message(context.TODO(), courier.SendMessageParams{
      	Message: courier.SendMessageParamsMessage{
      		To: courier.SendMessageParamsMessageToUnion{OfUserRecipient: &to},
      		Template: courier.String("nt_01kx4h2jdafq8bk9aftxak4b40"),
      	},
      })
      ```

      ```java Java highlight={3-4} theme={null}
      // A provider recipient is a profile field, so it sits outside the typed union.
      UserRecipient to = UserRecipient.builder()
          .putAdditionalProperty("viber", JsonValue.from(Map.of(
                  "receiver", "12943673==")))
          .build();

      client.send().message(SendMessageParams.builder()
          .message(SendMessageParams.Message.builder()
              .to(to)
              .template("nt_01kx4h2jdafq8bk9aftxak4b40")
              .build())
          .build());
      ```

      ```php PHP highlight={4-6} theme={null}
      $response = $client->send->message(
        message: [
          'to' => [
            'viber' => [
              'receiver' => '12943673==',
            ],
          ],
          'template' => 'nt_01kx4h2jdafq8bk9aftxak4b40',
        ],
      );
      ```

      ```csharp C# highlight={3-5} theme={null}
      // A provider recipient is a profile field, so it sits outside the typed union.
      UserRecipient to = UserRecipient.FromRawUnchecked(
          JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(
              """{"viber": {"receiver": "12943673=="}}"""
          )
      );

      var response = await client.Send.Message(new() { Message = new() { To = to, Template = "nt_01kx4h2jdafq8bk9aftxak4b40" } });
      ```

      ```bash CLI highlight={3} wrap theme={null}
      courier send message \
        --api-key "$COURIER_API_KEY" \
        --message.to '{"viber": {"receiver": "12943673=="}}' \
        --message.template nt_01kx4h2jdafq8bk9aftxak4b40
      ```

      ```text MCP theme={null}
      With Courier MCP, send my template to the Viber receiver 12943673==.
      ```
    </CodeGroup>
  </Tab>
</Tabs>

## Overrides

<Doc href="/docs/send/overrides#how-overrides-work">How overrides work</Doc> covers the two levels and which one wins.

A provider override changes the request body Courier sends to Viber, or swaps the auth token, sender name, and API URL.

### Body overrides

Override the request body that Courier sends to the Viber [Send Message API](https://developers.viber.com/docs/api/rest-bot-api/#send-message).

<CodeGroup>
  ```javascript Node.js highlight={5-7,10-17} theme={null}
  const { requestId } = await courier.send.message({
    message: {
      template: "nt_01kx4h2jdafq8bk9aftxak4b40",
      to: {
        viber: {
          receiver: "12943673==",
        },
      },
      providers: {
        viber: {
          override: {
            body: {
              type: "picture",
              media: "https://example.com/image.jpg",
            },
          },
        },
      },
    },
  });
  ```

  ```python Python highlight={5-7,10-17} theme={null}
  response = client.send.message(
      message={
          "template": "nt_01kx4h2jdafq8bk9aftxak4b40",
          "to": {
              "viber": {
                  "receiver": "12943673==",
              },
          },
          "providers": {
              "viber": {
                  "override": {
                      "body": {
                          "type": "picture",
                          "media": "https://example.com/image.jpg",
                      },
                  },
              },
          },
      },
  )
  ```

  ```bash cURL highlight={8-10,13-20} wrap theme={null}
  curl -X POST https://api.courier.com/send \
    -H "Authorization: Bearer $COURIER_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "message": {
        "template": "nt_01kx4h2jdafq8bk9aftxak4b40",
        "to": {
          "viber": {
            "receiver": "12943673=="
          }
        },
        "providers": {
          "viber": {
            "override": {
              "body": {
                "type": "picture",
                "media": "https://example.com/image.jpg"
              }
            }
          }
        }
      }
    }'
  ```

  ```ruby Ruby highlight={5-7,10-17} theme={null}
  response = courier.send_.message(
    message: {
      template: "nt_01kx4h2jdafq8bk9aftxak4b40",
      to: {
        viber: {
          receiver: "12943673=="
        }
      },
      providers: {
        viber: {
          override: {
            body: {
              type: "picture",
              media: "https://example.com/image.jpg"
            }
          }
        }
      }
    }
  )
  ```

  ```go Go highlight={4-6,14-21} theme={null}
  // This provider addresses the recipient with fields outside the typed
  // UserRecipient model, so pass the recipient as raw JSON.
  to := param.Override[shared.UserRecipientParam](json.RawMessage(`{
    "viber": {
      "receiver": "12943673=="
    }
  }`))

  response, err := client.Send.Message(context.TODO(), courier.SendMessageParams{
  	Message: courier.SendMessageParamsMessage{
  		To: courier.SendMessageParamsMessageToUnion{OfUserRecipient: &to},
  		Template: courier.String("nt_01kx4h2jdafq8bk9aftxak4b40"),
  		Providers: shared.MessageProvidersParam{
  			"viber": shared.MessageProvidersTypeParam{
  				Override: map[string]any{
  					"body": map[string]any{
  						"type": "picture",
  						"media": "https://example.com/image.jpg",
  					},
  				},
  			},
  		},
  	},
  })
  ```

  ```java Java highlight={6-8,12-17} theme={null}
  SendMessageParams params = SendMessageParams.builder()
      .message(SendMessageParams.Message.builder()
          // This provider addresses the recipient with fields outside the
          // typed UserRecipient model, so pass them as additional properties.
          .to(UserRecipient.builder()
              .putAdditionalProperty("viber", JsonValue.from(java.util.Map.of(
                  "receiver", "12943673=="
              )))
              .build())
          .template("nt_01kx4h2jdafq8bk9aftxak4b40")
          .providers(MessageProviders.builder()
              .putAdditionalProperty("viber", JsonValue.from(java.util.Map.of("override", java.util.Map.of(
                      "body", java.util.Map.of(
                          "type", "picture",
                          "media", "https://example.com/image.jpg"
                      )
                  ))))
              .build())
          .build())
      .build();
  SendMessageResponse response = client.send().message(params);
  ```

  ```php PHP highlight={5-7,10-17} theme={null}
  $response = $client->send->message(
    message: [
      'template' => 'nt_01kx4h2jdafq8bk9aftxak4b40',
      'to' => [
        'viber' => [
          'receiver' => '12943673==',
        ],
      ],
      'providers' => [
        'viber' => [
          'override' => [
            'body' => [
              'type' => 'picture',
              'media' => 'https://example.com/image.jpg',
            ],
          ],
        ],
      ],
    ],
  );
  ```

  ```csharp C# highlight={11-13,21-36} theme={null}
  SendMessageParams parameters = new()
  {
      Message = new()
      {
          // This provider addresses the recipient with fields outside the
          // typed UserRecipient model, so build it from raw JSON.
          To = UserRecipient.FromRawUnchecked(
              JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(
                  """
                  {
                    "viber": {
                      "receiver": "12943673=="
                    }
                  }
                  """
              )
          ),
          Template = "nt_01kx4h2jdafq8bk9aftxak4b40",
          Providers = new Dictionary<string, MessageProvidersType>()
          {
              {
                  "viber",
                  new()
                  {
                      Override = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(
                          """
                          {
                            "body": {
                              "type": "picture",
                              "media": "https://example.com/image.jpg"
                            }
                          }
                          """
                      ),
                  }
              },
          },
      },
  };

  var response = await client.Send.Message(parameters);
  ```

  ```bash CLI highlight={3,5} wrap theme={null}
  courier send message \
    --api-key "$COURIER_API_KEY" \
    --message.to '{"viber": {"receiver": "12943673=="}}' \
    --message.template nt_01kx4h2jdafq8bk9aftxak4b40 \
    --message.providers '{"viber": {"override": {"body": {"type": "picture", "media": "https://example.com/image.jpg"}}}}'
  ```

  ```text MCP theme={null}
  With Courier MCP, send my template to this Viber receiver and override the message body.
  ```
</CodeGroup>

### Config overrides

You can swap the auth token, sender name, or API URL at send time:

<CodeGroup>
  ```javascript Node.js highlight={5-7,10-17} theme={null}
  const { requestId } = await courier.send.message({
    message: {
      template: "nt_01kx4h2jdafq8bk9aftxak4b40",
      to: {
        viber: {
          receiver: "12943673==",
        },
      },
      providers: {
        viber: {
          override: {
            config: {
              token: "RUNTIME_AUTH_TOKEN",
              name: "My Bot Name",
            },
          },
        },
      },
    },
  });
  ```

  ```python Python highlight={5-7,10-17} theme={null}
  response = client.send.message(
      message={
          "template": "nt_01kx4h2jdafq8bk9aftxak4b40",
          "to": {
              "viber": {
                  "receiver": "12943673==",
              },
          },
          "providers": {
              "viber": {
                  "override": {
                      "config": {
                          "token": "RUNTIME_AUTH_TOKEN",
                          "name": "My Bot Name",
                      },
                  },
              },
          },
      },
  )
  ```

  ```bash cURL highlight={8-10,13-20} wrap theme={null}
  curl -X POST https://api.courier.com/send \
    -H "Authorization: Bearer $COURIER_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "message": {
        "template": "nt_01kx4h2jdafq8bk9aftxak4b40",
        "to": {
          "viber": {
            "receiver": "12943673=="
          }
        },
        "providers": {
          "viber": {
            "override": {
              "config": {
                "token": "RUNTIME_AUTH_TOKEN",
                "name": "My Bot Name"
              }
            }
          }
        }
      }
    }'
  ```

  ```ruby Ruby highlight={5-7,10-17} theme={null}
  response = courier.send_.message(
    message: {
      template: "nt_01kx4h2jdafq8bk9aftxak4b40",
      to: {
        viber: {
          receiver: "12943673=="
        }
      },
      providers: {
        viber: {
          override: {
            config: {
              token: "RUNTIME_AUTH_TOKEN",
              name: "My Bot Name"
            }
          }
        }
      }
    }
  )
  ```

  ```go Go highlight={4-6,14-21} theme={null}
  // This provider addresses the recipient with fields outside the typed
  // UserRecipient model, so pass the recipient as raw JSON.
  to := param.Override[shared.UserRecipientParam](json.RawMessage(`{
    "viber": {
      "receiver": "12943673=="
    }
  }`))

  response, err := client.Send.Message(context.TODO(), courier.SendMessageParams{
  	Message: courier.SendMessageParamsMessage{
  		To: courier.SendMessageParamsMessageToUnion{OfUserRecipient: &to},
  		Template: courier.String("nt_01kx4h2jdafq8bk9aftxak4b40"),
  		Providers: shared.MessageProvidersParam{
  			"viber": shared.MessageProvidersTypeParam{
  				Override: map[string]any{
  					"config": map[string]any{
  						"token": "RUNTIME_AUTH_TOKEN",
  						"name": "My Bot Name",
  					},
  				},
  			},
  		},
  	},
  })
  ```

  ```java Java highlight={6-8,12-17} theme={null}
  SendMessageParams params = SendMessageParams.builder()
      .message(SendMessageParams.Message.builder()
          // This provider addresses the recipient with fields outside the
          // typed UserRecipient model, so pass them as additional properties.
          .to(UserRecipient.builder()
              .putAdditionalProperty("viber", JsonValue.from(java.util.Map.of(
                  "receiver", "12943673=="
              )))
              .build())
          .template("nt_01kx4h2jdafq8bk9aftxak4b40")
          .providers(MessageProviders.builder()
              .putAdditionalProperty("viber", JsonValue.from(java.util.Map.of("override", java.util.Map.of(
                      "config", java.util.Map.of(
                          "token", "RUNTIME_AUTH_TOKEN",
                          "name", "My Bot Name"
                      )
                  ))))
              .build())
          .build())
      .build();
  SendMessageResponse response = client.send().message(params);
  ```

  ```php PHP highlight={5-7,10-17} theme={null}
  $response = $client->send->message(
    message: [
      'template' => 'nt_01kx4h2jdafq8bk9aftxak4b40',
      'to' => [
        'viber' => [
          'receiver' => '12943673==',
        ],
      ],
      'providers' => [
        'viber' => [
          'override' => [
            'config' => [
              'token' => 'RUNTIME_AUTH_TOKEN',
              'name' => 'My Bot Name',
            ],
          ],
        ],
      ],
    ],
  );
  ```

  ```csharp C# highlight={11-13,21-36} theme={null}
  SendMessageParams parameters = new()
  {
      Message = new()
      {
          // This provider addresses the recipient with fields outside the
          // typed UserRecipient model, so build it from raw JSON.
          To = UserRecipient.FromRawUnchecked(
              JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(
                  """
                  {
                    "viber": {
                      "receiver": "12943673=="
                    }
                  }
                  """
              )
          ),
          Template = "nt_01kx4h2jdafq8bk9aftxak4b40",
          Providers = new Dictionary<string, MessageProvidersType>()
          {
              {
                  "viber",
                  new()
                  {
                      Override = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(
                          """
                          {
                            "config": {
                              "token": "RUNTIME_AUTH_TOKEN",
                              "name": "My Bot Name"
                            }
                          }
                          """
                      ),
                  }
              },
          },
      },
  };

  var response = await client.Send.Message(parameters);
  ```

  ```bash CLI highlight={3,5} wrap theme={null}
  courier send message \
    --api-key "$COURIER_API_KEY" \
    --message.to '{"viber": {"receiver": "12943673=="}}' \
    --message.template nt_01kx4h2jdafq8bk9aftxak4b40 \
    --message.providers '{"viber": {"override": {"config": {"token": "RUNTIME_AUTH_TOKEN", "name": "My Bot Name"}}}}'
  ```

  ```text MCP theme={null}
  With Courier MCP, send my template to this Viber receiver with a different auth token.
  ```
</CodeGroup>

## Provider details

```text theme={null}
viber
```

Courier recommends routing to the channel. Naming this key in `routing.channels` instead is supported, and sends through just this provider.

<Card title="Send to a specific provider" icon="bullseye-arrow" href="/docs/send/send-to-a-provider" horizontal arrow="true">
  When that is worth doing, and what you give up: failover, channel priority, and providers you add later.
</Card>