Elemental channel element

The channel element sets content per channel. Send a detailed message on email and a shorter one on push. The type value is "channel". When to use:

Provide channel-specific content (different content for email vs push vs SMS)
Use raw channel data for provider-specific formats (MJML for email, Slack blocks, etc.)
Create channel-specific layouts and structures

Channel elements are only valid at the top level and cannot be nested. If one appears at the top level, every sibling must also be a channel element.

Alternative: most elements support a channels property that shows a single element on chosen channels only. See .

Basic example

{
  "type": "channel",
  "channel": "email",
  "elements": [
    {
      "type": "meta",
      "title": "My Subject"
    },
    {
      "type": "text",
      "content": "My email body"
    }
  ]
}

const { requestId } = await client.send.message({
  message: {
    to: {
      email: "sarah@acme-corp.com",
    },
    content: {
      version: "2022-01-01",
      elements: [
        {
          type: "channel",
          channel: "email",
          elements: [
            {
              type: "meta",
              title: "My Subject",
            },
            {
              type: "text",
              content: "My email body",
            },
          ],
        },
      ],
    },
  },
});

response = client.send.message(
    message={
      "to": {
        "email": "sarah@acme-corp.com",
      },
      "content": {
        "version": "2022-01-01",
        "elements": [
          {
            "type": "channel",
            "channel": "email",
            "elements": [
              {
                "type": "meta",
                "title": "My Subject",
              },
              {
                "type": "text",
                "content": "My email body",
              },
            ],
          },
        ],
      },
    },
)

curl -X POST https://api.courier.com/send \
  -H "Authorization: Bearer $COURIER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
      "message": {
        "to": {
          "email": "sarah@acme-corp.com"
        },
        "content": {
          "version": "2022-01-01",
          "elements": [
            {
              "type": "channel",
              "channel": "email",
              "elements": [
                {
                  "type": "meta",
                  "title": "My Subject"
                },
                {
                  "type": "text",
                  "content": "My email body"
                }
              ]
            }
          ]
        }
      }
    }'

response = courier.send_.message(
  message: {
    to: {
      email: "sarah@acme-corp.com"
    },
    content: {
      version: "2022-01-01",
      elements: [
        {
          type: "channel",
          channel: "email",
          elements: [
            {
              type: "meta",
              title: "My Subject"
            },
            {
              type: "text",
              content: "My email body"
            }
          ]
        }
      ]
    }
  }
)

// Elemental nodes carry no typed content fields, so pass the document as raw JSON.
content := param.Override[shared.ElementalContentParam](json.RawMessage(`{
  "version": "2022-01-01",
  "elements": [
    {
      "type": "channel",
      "channel": "email",
      "elements": [
        {
          "type": "meta",
          "title": "My Subject"
        },
        {
          "type": "text",
          "content": "My email body"
        }
      ]
    }
  ]
}`))

response, err := client.Send.Message(context.TODO(), courier.SendMessageParams{
	Message: courier.SendMessageParamsMessage{
		To: courier.SendMessageParamsMessageToUnion{
			OfUserRecipient: &shared.UserRecipientParam{
				Email: courier.String("sarah@acme-corp.com"),
			},
		},
		Content: courier.SendMessageParamsMessageContentUnion{OfElementalContent: &content},
	},
})

SendMessageParams params = SendMessageParams.builder()
    .message(SendMessageParams.Message.builder()
        .to(JsonValue.from(java.util.Map.of("email", "sarah@acme-corp.com")))
        .content(JsonValue.from(java.util.Map.of(
                "version", "2022-01-01",
                "elements", java.util.List.of(
                  java.util.Map.of(
                    "type", "channel",
                    "channel", "email",
                    "elements", java.util.List.of(
                      java.util.Map.of(
                        "type", "meta",
                        "title", "My Subject"),
                      java.util.Map.of(
                        "type", "text",
                        "content", "My email body")))))))
        .build())
    .build();
SendMessageResponse response = client.send().message(params);

$response = $client->send->message(
  message: [
    'to' => [
      'email' => 'sarah@acme-corp.com',
    ],
    'content' => [
      'version' => '2022-01-01',
      'elements' => [
        [
          'type' => 'channel',
          'channel' => 'email',
          'elements' => [
            [
              'type' => 'meta',
              'title' => 'My Subject',
            ],
            [
              'type' => 'text',
              'content' => 'My email body',
            ],
          ],
        ],
      ],
    ],
  ],
);

// Elemental nodes expose no typed content fields, so build the document from raw JSON.
SendMessageParams parameters = new()
{
    Message = new()
    {
        To = new UserRecipient { Email = "sarah@acme-corp.com" },
        Content = ElementalContent.FromRawUnchecked(
            JsonSerializer.Deserialize<Dictionary<string, JsonElement>>("""
            {
              "version": "2022-01-01",
              "elements": [
                {
                  "type": "channel",
                  "channel": "email",
                  "elements": [
                    {
                      "type": "meta",
                      "title": "My Subject"
                    },
                    {
                      "type": "text",
                      "content": "My email body"
                    }
                  ]
                }
              ]
            }
            """)),
    },
};

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

courier send message \
  --api-key "$COURIER_API_KEY" \
  --message.to '{"email": "sarah@acme-corp.com"}' \
  --message.content '{"version": "2022-01-01", "elements": [{"type": "channel", "channel": "email", "elements": [{"type": "meta", "title": "My Subject"}, {"type": "text", "content": "My email body"}]}]}'

With Courier MCP, send an email and an SMS to sarah@acme-corp.com with different content on each channel.

Fields

string

required

The channel the contents of this element should be applied to. Can be:

Standard channels: "email", "push", "direct_message", "sms"
Provider names: "slack", "discord", "teams", etc.
"default" - applies to all channels not explicitly specified

CourierElement[]

An array of Elemental elements to apply to the channel. If raw has not been specified, elements is required.

object

Raw data to apply to the channel. Use channel-specific formats like MJML for email, Slack blocks, or webhook payloads. If elements has not been specified, raw is required.

string

The CSS font-family stack to apply to the rendered email. Only valid when channel is "email". Use the exact fontFamily value from the . Google Fonts are loaded automatically. Defaults to Helvetica, Arial, sans-serif if omitted.

{
  "type": "channel",
  "channel": "email",
  "font_family": "Roboto, Arial, sans-serif",
  "elements": [...]
}

Examples and variants Using elements Provide different Elemental content per channel:

{
  "type": "channel",
  "channel": "email",
  "elements": [
    {
      "type": "meta",
      "title": "Order Confirmation"
    },
    {
      "type": "text",
      "content": "Your order #{{order_id}} has been confirmed. We'll send you tracking information once your order ships."
    },
    {
      "type": "action",
      "content": "View Order",
      "href": "https://app.example.com/orders/{{order_id}}"
    }
  ]
},
{
  "type": "channel",
  "channel": "push",
  "elements": [
    {
      "type": "meta",
      "title": "Order Confirmed"
    },
    {
      "type": "text",
      "content": "Order #{{order_id}} confirmed"
    }
  ]
}

Using raw data Use raw channel data for provider-specific formats. Email with MJML:

{
  "type": "channel",
  "channel": "email",
  "raw": {
    "subject": "Order Confirmation",
    "html": "<mjml><mj-body><mj-section><mj-column><mj-text>Your order has been confirmed!</mj-text></mj-column></mj-section></mj-body></mjml>",
    "text": "Your order has been confirmed!",
    "transformers": ["handlebars", "mjml"]
  }
}

Slack:

{
  "type": "channel",
  "channel": "slack",
  "raw": {
    "text": "Hello World!",
    "blocks": [
      {
        "type": "section",
        "text": {
          "type": "mrkdwn",
          "text": "Your order has been confirmed!"
        }
      }
    ]
  }
}

Webhook:

{
  "type": "channel",
  "channel": "webhook",
  "raw": {
    "payload": {
      "body": {
        "event": "order.confirmed",
        "order_id": "{{order_id}}",
        "timestamp": "{{timestamp}}"
      }
    }
  }
}

Default channel Use "default" to provide content for all channels not explicitly specified:

{
  "type": "channel",
  "channel": "email",
  "elements": [
    {
      "type": "text",
      "content": "Detailed email content here"
    }
  ]
},
{
  "type": "channel",
  "channel": "default",
  "elements": [
    {
      "type": "text",
      "content": "Content for push, SMS, and other channels"
    }
  ]
}

Channel-specific considerations Email

Supports full Elemental elements or raw HTML/MJML
Can use raw.subject for email subject line
Supports transformers array for templating engines

Push

Typically uses meta.title for notification title
Content should be concise due to character limits
Supports action buttons via action elements

SMS

Very limited character count
Best for short, essential messages
No rich formatting support

Direct message (Slack, Discord, Teams, etc.)

Provider-specific formats via raw property
Can use provider-specific block structures
Supports rich interactive elements per provider

Get started

Send messages

Journeys

Broadcasts

Design

Recipients

Tenants

Monitoring

Workspaces

Resources

Elemental channel element