Elemental Jsonnet element

The Jsonnet element embeds a Jsonnet template in your Elemental document. Jsonnet is a data templating language that generates JSON, so it suits structured content built programmatically. The type value is "jsonnet". When to use:

Generate dynamic JSON structures based on data
Create reusable template logic with functions and variables
Build complex nested objects programmatically
Avoid repetitive JSON structures
Generate locale-specific content programmatically

Jsonnet is an advanced feature and requires knowing its syntax. For simple content, use with Handlebars variables instead.

Basic example

{
  "type": "jsonnet",
  "template": "local person(name, age) = { name: name, age: age, greeting: \"Hello \" + name + \"!\" }; { user: person(\"Sarah Bennett\", 30) }"
}

const { requestId } = await client.send.message({
  message: {
    to: {
      email: "sarah@acme-corp.com",
    },
    content: {
      version: "2022-01-01",
      elements: [
        {
          type: "jsonnet",
          template: "local person(name, age) = { name: name, age: age, greeting: \"Hello \" + name + \"!\" }; { user: person(\"Sarah Bennett\", 30) }",
        },
      ],
    },
  },
});

response = client.send.message(
    message={
      "to": {
        "email": "sarah@acme-corp.com",
      },
      "content": {
        "version": "2022-01-01",
        "elements": [
          {
            "type": "jsonnet",
            "template": "local person(name, age) = { name: name, age: age, greeting: \"Hello \" + name + \"!\" }; { user: person(\"Sarah Bennett\", 30) }",
          },
        ],
      },
    },
)

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": "jsonnet",
              "template": "local person(name, age) = { name: name, age: age, greeting: \"Hello \" + name + \"!\" }; { user: person(\"Sarah Bennett\", 30) }"
            }
          ]
        }
      }
    }'

response = courier.send_.message(
  message: {
    to: {
      email: "sarah@acme-corp.com"
    },
    content: {
      version: "2022-01-01",
      elements: [
        {
          type: "jsonnet",
          template: "local person(name, age) = { name: name, age: age, greeting: \"Hello \" + name + \"!\" }; { user: person(\"Sarah Bennett\", 30) }"
        }
      ]
    }
  }
)

// 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": "jsonnet",
      "template": "local person(name, age) = { name: name, age: age, greeting: \"Hello \" + name + \"!\" }; { user: person(\"Sarah Bennett\", 30) }"
    }
  ]
}`))

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", "jsonnet",
                    "template", "local person(name, age) = { name: name, age: age, greeting: \"Hello \" + name + \"!\" }; { user: person(\"Sarah Bennett\", 30) }")))))
        .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' => 'jsonnet',
          'template' => 'local person(name, age) = { name: name, age: age, greeting: "Hello " + name + "!" }; { user: person("Sarah Bennett", 30) }',
        ],
      ],
    ],
  ],
);

// 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": "jsonnet",
                  "template": "local person(name, age) = { name: name, age: age, greeting: \"Hello \" + name + \"!\" }; { user: person(\"Sarah Bennett\", 30) }"
                }
              ]
            }
            """)),
    },
};

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": "jsonnet", "template": "local person(name, age) = { name: name, age: age, greeting: \"Hello \" + name + \"!\" }; { user: person(\"Sarah Bennett\", 30) }"}]}'

With Courier MCP, send an email to sarah@acme-corp.com whose content is generated by a jsonnet element.

Fields

string

required

The Jsonnet template code. A string of valid Jsonnet, evaluated to produce JSON. The template reaches message data through Jsonnet’s standard variable access.

object

Region-specific Jsonnet templates. Keys are locale codes (e.g., "es", "fr"), and each value is the Jsonnet template for that locale. See the .

string[]

An array of channel names. The Jsonnet element renders only for the listed channels. See .

Jsonnet language basics Jsonnet extends JSON with:

Variables: local name = "Sarah Bennett";
Functions: local greet(name) = "Hello " + name;
Object composition: Merge objects with +
Conditionals: if condition then value1 else value2
Loops: [x * 2 for x in [1, 2, 3]]
Imports: local lib = import "lib.jsonnet";

For complete Jsonnet language documentation, see the official Jsonnet documentation.

Examples and variants Simple object generation Generate a simple JSON object:

{
  "type": "jsonnet",
  "template": "{ message: \"Welcome!\", timestamp: \"2024-01-15\" }"
}

Output:

{
  "message": "Welcome!",
  "timestamp": "2024-01-15"
}

Using functions Create reusable functions:

{
  "type": "jsonnet",
  "template": "local formatPrice(amount) = \"$\" + std.toString(amount); { price: formatPrice(99.99), discount: formatPrice(49.99) }"
}

Output:

{
  "price": "$99.99",
  "discount": "$49.99"
}

Conditional content Generate different content based on conditions:

{
  "type": "jsonnet",
  "template": "local isPremium = true; { tier: if isPremium then \"premium\" else \"basic\", features: if isPremium then [\"feature1\", \"feature2\", \"feature3\"] else [\"feature1\"] }"
}

Output:

{
  "tier": "premium",
  "features": ["feature1", "feature2", "feature3"]
}

Localized templates Provide different Jsonnet templates for different locales:

{
  "type": "jsonnet",
  "template": "{ greeting: \"Hello\", name: \"World\" }",
  "locales": {
    "es": "{ greeting: \"Hola\", name: \"Mundo\" }",
    "fr": "{ greeting: \"Bonjour\", name: \"Monde\" }"
  }
}

Complex nested structures Build complex nested objects:

{
  "type": "jsonnet",
  "template": "local user(name, email) = { profile: { name: name, email: email }, settings: { notifications: true } }; { users: [user(\"Sarah Bennett\", \"sarah@acme-corp.com\"), user(\"Kai Turner\", \"kai@acme-corp.com\")] }"
}

Output:

{
  "users": [
    {
      "profile": {
        "name": "Sarah Bennett",
        "email": "sarah@acme-corp.com"
      },
      "settings": {
        "notifications": true
      }
    },
    {
      "profile": {
        "name": "Kai Turner",
        "email": "kai@acme-corp.com"
      },
      "settings": {
        "notifications": true
      }
    }
  ]
}

Jsonnet templates are evaluated at render time. A syntax or runtime error fails the whole notification render. Test your templates before deploying.

Channel support

Email: ✅ Full support
Push: ✅ Supported (JSON output can be used in push payloads)
SMS: ⚠️ Limited support (JSON output may need to be stringified)
Inbox: ✅ Full support

Additional resources

Get started

Send messages

Journeys

Broadcasts

Design

Recipients

Tenants

Monitoring

Workspaces

Resources

Elemental Jsonnet element