> ## 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` from the Node SDK (`@trycourier/courier` v7 and later, where the client is the default import). 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.

# Journey AI node

> Run an LLM prompt inside a journey with the run's context, and use its structured output.

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>;
};

AI nodes run a large language model prompt as part of a journey. Courier sends the prompt and the run's context to the model you select.

Courier parses the response into structured output and adds those fields back into the journey context.

Downstream nodes use that output to make decisions, personalize messages, or update user data.

**AI nodes need the Business or Enterprise plan**, and run on [AI credits](#billing).

## Configuration

Click the AI node on the canvas to open the summary panel, then click **Configure** to open the full configuration drawer.

<Frame caption="AI node configuration drawer with model selector, web search toggle, prompt, and output schema">
  <img src="https://mintcdn.com/courier-4f1f25dc/A-IH_41Pkuff3UAy/assets/ai-node-edit-drawer.webp?fit=max&auto=format&n=A-IH_41Pkuff3UAy&q=85&s=85b402f156dc5667b28a1b9f6bd338b2" alt="" width="2080" height="1592" data-path="assets/ai-node-edit-drawer.webp" />
</Frame>

### AI model

Choose the model that fits what the AI node needs to do. Courier supports models from OpenAI and Anthropic, so each node can balance speed, cost, and output quality.

Use smaller models for predictable structured tasks: classifying users, extracting fields, scoring engagement, or returning simple JSON. Use larger models when the prompt needs more context, nuanced reasoning, or higher-quality generated copy.

Available models:

| Provider  | Model            |
| --------- | ---------------- |
| Anthropic | Claude Fable 5   |
| Anthropic | Claude Opus 5    |
| Anthropic | Claude Opus 4.8  |
| Anthropic | Claude Sonnet 5  |
| Anthropic | Claude Haiku 4.5 |
| OpenAI    | GPT-5.6 Sol      |
| OpenAI    | GPT-5.5          |
| OpenAI    | GPT-5.4          |
| OpenAI    | GPT-5.6 Terra    |
| OpenAI    | GPT-5.4 Mini     |
| OpenAI    | GPT-5.6 Luna     |
| OpenAI    | GPT-5.4 Nano     |

See [Billing](#billing) for credit costs, token overages, and web search pricing.

### Web search

Toggle web search on when the prompt needs current information the journey context does not have. The model can then query the internet before generating its structured response.

Web search is available for Anthropic models only. Each invocation with web search enabled costs an additional **2 credits**. Search results also count as input tokens, along with the prompt, output schema, journey context, and resolved variables. If the total input exceeds **3,072 tokens**, input token overage applies.

### Prompt

Write a natural-language prompt describing what you want the model to do. The prompt field supports `{{variable}}` interpolation. Type `{{` to see available fields from the trigger schema, profile, or upstream fetch responses.

For the onboarding nudge example below, the prompt might be:

```text theme={null}
You are a product growth assistant. Based on this user's profile and activity, write a personalized onboarding nudge that encourages them to try the next feature most relevant to their use case.

Rules:
- subject_line should be under 60 characters, personalized, and action-oriented
- body_copy should be 1-2 sentences, friendly, and reference what they've already done
- recommended_feature must be exactly one of: templates, automations, integrations, analytics
- tone must be exactly one of: encouraging, celebratory, urgent

User: {{data.user_name}}
Plan: {{data.plan_name}}
Features used so far: {{data.features_used}}
Days since signup: {{data.days_since_signup}}
```

A token counter in the top-right of the drawer shows prompt + schema size in real time. Most AI node runs stay within the included token limit. Input token overage usually only applies when variables, fetch responses, or web search results add large amounts of text.

### Output schema

The output schema defines the structure of the model's response. Define it in two modes:

**Form mode** (default): Add fields with a name and type (string, number, or boolean). Optionally add a description telling the model what the field should contain.

**JSON mode**: Write a JSON Schema directly. Use this for more complex schemas or when pasting from an existing definition.

For the onboarding nudge example, the form-mode schema would be:

| Field                 | Type   | Description                                             |
| --------------------- | ------ | ------------------------------------------------------- |
| `subject_line`        | string | Personalized email subject under 60 characters          |
| `body_copy`           | string | 1-2 sentence nudge referencing the user's activity      |
| `recommended_feature` | string | One of: templates, automations, integrations, analytics |
| `tone`                | string | One of: encouraging, celebratory, urgent                |

The model's response is parsed as JSON and merged into the journey context. Downstream nodes reference the fields the same way they reference trigger or fetch data:

* In <Doc href="/docs/journeys/nodes/branch">branch conditions</Doc>: select `data.tone` or `data.recommended_feature` as the field
* In <Doc href="/docs/journeys/build">journey templates</Doc>: use `{{subject_line}}` or `{{body_copy}}`

### Conditions

AI nodes support optional <Doc href="/docs/journeys/nodes/branch">conditions</Doc>. If they are not met when the run reaches the node, it's skipped and no credits are consumed.

## Testing

Click **Test** in the configuration drawer to open the test panel. Run the prompt against the selected model with sample variable values and see the structured response before publishing the journey.

<Frame caption="Test drawer showing prompt, output schema, and structured test result">
  <img src="https://mintcdn.com/courier-4f1f25dc/A-IH_41Pkuff3UAy/assets/ai-node-test-drawer.webp?fit=max&auto=format&n=A-IH_41Pkuff3UAy&q=85&s=401a429e6bcf8b28fa528d4c6ac55459" alt="" width="2444" height="1790" data-path="assets/ai-node-test-drawer.webp" />
</Frame>

The test result shows the parsed JSON output on the right, or an error message if the request failed.

<Warning>
  A test run is billed like a real one. It calls the same model and deducts the same credits, so iterating on a prompt with an expensive model adds up.
</Warning>

## Example: personalized onboarding nudge

A journey that generates tailored onboarding messages from each user's activity:

<Frame caption="Onboarding nudge journey: API trigger → Fetch activity → AI generates personalized copy → branch on tone → send via the right channel">
  <img src="https://mintcdn.com/courier-4f1f25dc/A-IH_41Pkuff3UAy/assets/ai-node-example-journey.webp?fit=max&auto=format&n=A-IH_41Pkuff3UAy&q=85&s=847711bd514d06905d48424df7d62342" alt="" width="1280" height="1670" data-path="assets/ai-node-example-journey.webp" />
</Frame>

1. **Trigger**: Fires on day 3 after signup. The trigger schema includes `user_name`, `plan_name`, `features_used`, and `days_since_signup`.
2. **Fetch Data**: Pulls the user's recent activity summary from your application API.
3. **AI node**: Given the user's profile and activity, generates a personalized nudge with `subject_line`, `body_copy`, `recommended_feature`, and `tone`. Model: Claude Sonnet 5 (2.5 credits per run).
4. **Branch**: Routes based on `data.tone`:
   * Path "Celebratory": user has been active → sends a congratulatory email with `{{subject_line}}` and `{{body_copy}}`.
   * Path "Urgent": user hasn't engaged → sends a push notification to re-engage.
   * Default: sends a standard onboarding email with the AI-generated copy.

## Common patterns

**Score and classify users**: Feed product usage, behavior, and profile data into the LLM. Route the journey based on risk level, intent, engagement, or any structured category the model returns.

**Generate personalized notifications**: Give the model your journey context and get back tailored subject lines, body copy, and recommended actions. Personalized content for every recipient without dozens of template variants.

**Enrich user profiles**: Classify users into personas, derive lifecycle stage, or generate account summaries. Persist outputs to the profile so every future journey starts with richer context.

**Structured output for downstream logic**: Define an output schema with field names, types, and enums. The LLM returns structured JSON that branch conditions, send nodes, and downstream integrations can act on directly.

## Debugging AI nodes

Open <Doc href="/docs/monitor/journey-metrics">Run Inspection</Doc> and click the AI node step to see:

* The model used and whether web search was enabled
* The resolved prompt (with variables substituted)
* The output schema that was sent to the model
* The structured JSON response
* Token usage (input and output token counts)

If the AI node fails (model error or timeout), the step context shows the error. The journey continues but no output is merged into the context. Use a downstream branch condition to handle missing AI output fields.

## Billing

AI nodes need the **Business** or **Enterprise** plan. On Developer the node cannot be placed on the canvas and credit packs cannot be bought.

Each AI node invocation consumes credits based on the selected model. Credits are billed at **100 credits per \$1** and bought as packs in the console, separately from your send bill. Auto top-up charges your card for another pack when the balance falls below a threshold, 100 credits by default.

| Provider  | Model            | Credits per invocation |
| --------- | ---------------- | ---------------------: |
| Anthropic | Claude Fable 5   |                      9 |
| Anthropic | Claude Opus 5    |                      4 |
| Anthropic | Claude Opus 4.8  |                      4 |
| Anthropic | Claude Sonnet 5  |                    2.5 |
| Anthropic | Claude Haiku 4.5 |                      1 |
| OpenAI    | GPT-5.6 Sol      |                      5 |
| OpenAI    | GPT-5.5          |                      5 |
| OpenAI    | GPT-5.4          |                    2.5 |
| OpenAI    | GPT-5.6 Terra    |                      2 |
| OpenAI    | GPT-5.4 Mini     |                   0.75 |
| OpenAI    | GPT-5.6 Luna     |                    0.2 |
| OpenAI    | GPT-5.4 Nano     |                    0.2 |

The values above are base costs per invocation. Each invocation includes up to **3,072 input tokens** and **1,000 output tokens**. Most AI node runs stay within these included limits.

Input tokens cover everything sent to the model: the prompt, output schema, journey context, resolved variables, upstream fetch responses, and web search results. Input token overage applies when the node sends a large amount of text, such as long variables, large fetch responses, or web search results.

Output tokens are generated by the model response. Output token overage applies only when the model response exceeds 1,000 tokens. Control output length through the prompt and output schema.

| Provider  | Model            | Input token overage<br />credits / 1K tokens | Output token overage<br />credits / 1K tokens |
| --------- | ---------------- | -------------------------------------------: | --------------------------------------------: |
| Anthropic | Claude Fable 5   |                                        1.250 |                                         6.250 |
| Anthropic | Claude Opus 5    |                                        0.625 |                                         3.125 |
| Anthropic | Claude Opus 4.8  |                                        0.625 |                                         3.125 |
| Anthropic | Claude Sonnet 5  |                                        0.375 |                                         1.875 |
| Anthropic | Claude Haiku 4.5 |                                        0.125 |                                         0.625 |
| OpenAI    | GPT-5.6 Sol      |                                        0.625 |                                         3.750 |
| OpenAI    | GPT-5.5          |                                        0.625 |                                         3.750 |
| OpenAI    | GPT-5.4          |                                        0.313 |                                         1.875 |
| OpenAI    | GPT-5.6 Terra    |                                        0.250 |                                         1.500 |
| OpenAI    | GPT-5.4 Mini     |                                        0.094 |                                         0.563 |
| OpenAI    | GPT-5.6 Luna     |                                        0.025 |                                         0.150 |
| OpenAI    | GPT-5.4 Nano     |                                        0.025 |                                         0.156 |

Web search is available for Anthropic models only. When enabled, each invocation costs an additional **2 credits**. Search results also count as input tokens, so web search can push the total past 3,072 tokens and trigger input token overage.