Channel settings and overrides

Channel settings control how each channel behaves within a template, and send-time overrides let you adjust a single message.

How overrides work

An override changes part of a message at send time, without editing the template. Courier applies it just before handing the message to the provider, so it works with template-based sends and with any content the template renders. There are two levels:

Level	Where you set it	Applies to
Channel override	`message.channels.<channel>.override`	Every provider configured for that channel
Provider override	`message.providers.<key>.override`	One provider, passing fields from that provider’s own API

Use both on the same send if you need to. When the two set the same field, the provider override wins.

Courier applies overrides after the render step. The Rendered tab in the logs won’t show them, only the pre-override output. To see the final payload, look at the provider request in the Raw tab.

The fields each channel accepts live with that channel: , , , and . Each provider page documents its own provider-specific schema.

Prerequisites

A template with more than one channel
A connected provider for each of those channels

Configure channels

Set email address fields

Email channels carry sender and recipient fields you set in the channel settings, with variables allowed for dynamic values:

From: "Sarah Bennett <notify@acme-corp.com>". The Name <email> form carries the display name, and it is the only way to set one when a provider’s integration has no From Name field.
Reply-To: where replies go.
CC / BCC: additional recipients, often driven by a variable.

The sender resolves at three levels, and the first one set wins:

message.channels.email.override.from on the send, for one message.
The From field here, for every send of this template.
From Address on the provider integration, for every email through that provider.

With none of the three set, the send fails at the provider rather than falling back to a Courier address. walks the whole setup.

Gmail is the exception. It always sends as the authorized inbox, so a From value here has no effect on it. Set the display name with the integration’s From Name instead.

Add per-channel conditions

A channel condition skips only that channel, while the rest of the notification still delivers (a template condition, by contrast, stops the whole send). Set them in the channel’s Conditions tab, or over the API with message.channels.<channel>.if, where each value is an expression evaluated against data and profile:

const { requestId } = await courier.send.message({
  message: {
    to: {
      user_id: "user_123",
    },
    template: "nt_01kx4h2jdafq8bk9aftxak4b40",
    channels: {
      sms: {
        if: "data.priority === 'high'",
      },
    },
  },
});

response = client.send.message(
    message={
        "to": {
            "user_id": "user_123",
        },
        "template": "nt_01kx4h2jdafq8bk9aftxak4b40",
        "channels": {
            "sms": {
                "if": "data.priority === 'high'",
            },
        },
    },
)

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",
      "channels": {
        "sms": {
          "if": "data.priority === '\''high'\''"
        }
      }
    }
  }'

response = courier.send_.message(
  message: {
    to: {
      user_id: "user_123"
    },
    template: "nt_01kx4h2jdafq8bk9aftxak4b40",
    channels: {
      sms: {
        if: "data.priority === 'high'"
      }
    }
  }
)

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"),
		Channels: shared.MessageChannelsParam{
			"sms": shared.ChannelParam{If: courier.String("data.priority === 'high'")},
		},
	},
})

SendMessageParams params = SendMessageParams.builder()
    .message(SendMessageParams.Message.builder()
        .to(UserRecipient.builder().userId("user_123").build())
        .template("nt_01kx4h2jdafq8bk9aftxak4b40")
        .channels(MessageChannels.builder()
            .putAdditionalProperty("sms", JsonValue.from(
                java.util.Map.of("if", "data.priority === 'high'")))
            .build())
        .build())
    .build();
SendMessageResponse response = client.send().message(params);

$response = $client->send->message(
  message: [
    'to' => [
      'user_id' => 'user_123',
    ],
    'template' => 'nt_01kx4h2jdafq8bk9aftxak4b40',
    'channels' => [
      'sms' => [
        'if' => 'data.priority === \'high\'',
      ],
    ],
  ],
);

SendMessageParams parameters = new()
{
    Message = new()
    {
        To = new UserRecipient { UserID = "user_123" },
        Template = "nt_01kx4h2jdafq8bk9aftxak4b40",
        Channels = new Dictionary<string, Channel>
        {
            { "sms", new Channel { If = "data.priority === 'high'" } },
        },
    },
};

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

courier send message \
  --api-key "$COURIER_API_KEY" \
  --message.to '{"user_id": "user_123"}' \
  --message.template nt_01kx4h2jdafq8bk9aftxak4b40 \
  --message.channels '{"sms": {"if": "data.priority === '\''high'\''"}}'

With Courier MCP, send my nt_01kx4h2jdafq8bk9aftxak4b40 template to user_123 and only use SMS when the priority is high.

Setting routing on a send drops the template’s default routing conditions, so include any channel conditions you want in message.channels.

User preferences take precedence over channel conditions. When a user sets custom channel routing, conditions run only within their selected channels.

Override a provider at send time

Adjust how a specific provider sends this one message with providers.<provider>.override, without changing the template. For example, filter push tokens or set a provider-specific field:

const { requestId } = await courier.send.message({
  message: {
    to: {
      user_id: "user_123",
    },
    template: "nt_01kx4h2jdafq8bk9aftxak4b40",
    routing: {
      method: "all",
      channels: [
        "push",
      ],
    },
    providers: {
      "firebase-fcm": {
        override: {
          config: {
            filterByBundleId: true,
            bundleId: "com.acme.app",
          },
        },
      },
    },
  },
});

response = client.send.message(
    message={
        "to": {
            "user_id": "user_123",
        },
        "template": "nt_01kx4h2jdafq8bk9aftxak4b40",
        "routing": {
            "method": "all",
            "channels": [
                "push",
            ],
        },
        "providers": {
            "firebase-fcm": {
                "override": {
                    "config": {
                        "filterByBundleId": True,
                        "bundleId": "com.acme.app",
                    },
                },
            },
        },
    },
)

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",
      "routing": {
        "method": "all",
        "channels": [
          "push"
        ]
      },
      "providers": {
        "firebase-fcm": {
          "override": {
            "config": {
              "filterByBundleId": true,
              "bundleId": "com.acme.app"
            }
          }
        }
      }
    }
  }'

response = courier.send_.message(
  message: {
    to: {
      user_id: "user_123"
    },
    template: "nt_01kx4h2jdafq8bk9aftxak4b40",
    routing: {
      method: "all",
      channels: [
        "push"
      ]
    },
    providers: {
      "firebase-fcm": {
        override: {
          config: {
            filterByBundleId: true,
            bundleId: "com.acme.app"
          }
        }
      }
    }
  }
)

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"),
		Routing: courier.SendMessageParamsMessageRouting{
			Channels: []shared.MessageRoutingChannelUnionParam{
				{OfString: courier.String("push")},
			},
			Method: "all",
		},
		Providers: shared.MessageProvidersParam{
			"firebase-fcm": shared.MessageProvidersTypeParam{
				Override: map[string]any{
					"config": map[string]any{
						"filterByBundleId": true,
						"bundleId": "com.acme.app",
					},
				},
			},
		},
	},
})

SendMessageParams params = SendMessageParams.builder()
    .message(SendMessageParams.Message.builder()
        .to(UserRecipient.builder().userId("user_123").build())
        .template("nt_01kx4h2jdafq8bk9aftxak4b40")
        .routing(SendMessageParams.Message.Routing.builder()
            .addChannel("push")
            .method(SendMessageParams.Message.Routing.Method.ALL)
            .build())
        .providers(MessageProviders.builder()
            .putAdditionalProperty("firebase-fcm", JsonValue.from(java.util.Map.of("override", java.util.Map.of(
                    "config", java.util.Map.of(
                        "filterByBundleId", true,
                        "bundleId", "com.acme.app"
                    )
                ))))
            .build())
        .build())
    .build();
SendMessageResponse response = client.send().message(params);

$response = $client->send->message(
  message: [
    'to' => [
      'user_id' => 'user_123',
    ],
    'template' => 'nt_01kx4h2jdafq8bk9aftxak4b40',
    'routing' => [
      'method' => 'all',
      'channels' => [
        'push',
      ],
    ],
    'providers' => [
      'firebase-fcm' => [
        'override' => [
          'config' => [
            'filterByBundleId' => true,
            'bundleId' => 'com.acme.app',
          ],
        ],
      ],
    ],
  ],
);

SendMessageParams parameters = new()
{
    Message = new()
    {
        To = new UserRecipient { UserID = "user_123" },
        Template = "nt_01kx4h2jdafq8bk9aftxak4b40",
        Routing = new() { Channels = ["push"], Method = Send::Method.All },
        Providers = new Dictionary<string, MessageProvidersType>()
        {
            {
                "firebase-fcm",
                new()
                {
                    Override = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(
                        """
                        {
                          "config": {
                            "filterByBundleId": true,
                            "bundleId": "com.acme.app"
                          }
                        }
                        """
                    ),
                }
            },
        },
    },
};

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

courier send message \
  --api-key "$COURIER_API_KEY" \
  --message.to '{"user_id": "user_123"}' \
  --message.template nt_01kx4h2jdafq8bk9aftxak4b40 \
  --message.routing '{"method": "all", "channels": ["push"]}' \
  --message.providers '{"firebase-fcm": {"override": {"config": {"filterByBundleId": true, "bundleId": "com.acme.app"}}}}'

With Courier MCP, send my nt_01kx4h2jdafq8bk9aftxak4b40 template to user_123 with a provider-specific override.

See for the push override fields, and each for its override options.

Check the logs

Send with your settings and open the message in . Confirm the channels that sent, and that each channel condition behaved as expected.

Get started

Send messages

Journeys

Broadcasts

Design

Recipients

Tenants

Monitoring

Workspaces

Resources

Channel settings and overrides

How overrides work

Prerequisites

Configure channels

​How overrides work

​Prerequisites

​Configure channels

How overrides work

Prerequisites

Configure channels