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

# Transactional Notifications with Novu

> Send transactional notifications for orders, payments, shipments, and account events using Novu workflows, the REST API, and multi-channel delivery.

Send transactional notifications through Novu by triggering a workflow when a business event occurs in your application. Novu delivers the message across in-app, email, SMS, push, or chat based on your workflow steps and the subscriber's contact details.

Common transactional events include order confirmations, shipping updates, payment failures, and subscription renewals.

## How do I send a transactional notification?

1. Create a [workflow](/platform/workflow/create-a-workflow) in the Novu Dashboard with the channels you need (for example, email + in-app).
2. Register or upsert a [subscriber](/platform/concepts/subscribers) with the recipient's `subscriberId`, email, and phone.
3. [Trigger the workflow](/api-reference/events/trigger-event) from your backend with the workflow identifier, `subscriberId`, and event payload.

<Tabs>
  <Tab title="Node.js">
    ```typescript theme={null}
    import { Novu } from '@novu/api';

    const novu = new Novu({ secretKey: process.env.NOVU_SECRET_KEY });

    await novu.trigger({
      workflowId: 'order-shipped',
      to: { subscriberId: 'user_123' },
      payload: {
        orderId: 'ORD-456',
        trackingUrl: 'https://example.com/track/456',
      },
    });
    ```
  </Tab>

  <Tab title="Python">
    ```python theme={null}
    import os
    import novu_py
    from novu_py import Novu

    with Novu(secret_key=os.getenv("NOVU_SECRET_KEY", "")) as novu:
        novu.trigger(trigger_event_request_dto=novu_py.TriggerEventRequestDto(
            workflow_id="order-shipped",
            to={"subscriber_id": "user_123"},
            payload={
                "orderId": "ORD-456",
                "trackingUrl": "https://example.com/track/456",
            },
        ))
    ```
  </Tab>

  <Tab title="Go">
    ```go theme={null}
    import (
        "context"
        "os"

        novugo "github.com/novuhq/novu-go"
        "github.com/novuhq/novu-go/models/components"
    )

    s := novugo.New(novugo.WithSecurity(os.Getenv("NOVU_SECRET_KEY")))

    _, err := s.Trigger(context.Background(), components.TriggerEventRequestDto{
        WorkflowID: "order-shipped",
        To: components.CreateToSubscriberPayloadDto(components.SubscriberPayloadDto{
            SubscriberID: "user_123",
        }),
        Payload: map[string]any{
            "orderId":     "ORD-456",
            "trackingUrl": "https://example.com/track/456",
        },
    }, nil)
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
    use novu;
    use novu\Models\Components;

    $sdk = novu\Novu::builder()
        ->setSecurity('<YOUR_SECRET_KEY_HERE>')
        ->build();

    $sdk->trigger(
        triggerEventRequestDto: new Components\TriggerEventRequestDto(
            workflowId: 'order-shipped',
            to: new Components\SubscriberPayloadDto(subscriberId: 'user_123'),
            payload: [
                'orderId' => 'ORD-456',
                'trackingUrl' => 'https://example.com/track/456',
            ],
        ),
    );
    ```
  </Tab>

  <Tab title=".NET">
    ```csharp theme={null}
    using Novu;
    using Novu.Models.Components;
    using System.Collections.Generic;

    var sdk = new NovuSDK(secretKey: "<YOUR_SECRET_KEY_HERE>");

    await sdk.TriggerAsync(triggerEventRequestDto: new TriggerEventRequestDto() {
        WorkflowId = "order-shipped",
        To = To.CreateSubscriberPayloadDto(new SubscriberPayloadDto() {
            SubscriberId = "user_123",
        }),
        Payload = new Dictionary<string, object>() {
            { "orderId", "ORD-456" },
            { "trackingUrl", "https://example.com/track/456" },
        },
    });
    ```
  </Tab>

  <Tab title="Java">
    ```java theme={null}
    import co.novu.Novu;
    import co.novu.models.components.*;
    import java.util.Map;

    Novu novu = Novu.builder()
        .secretKey("<YOUR_SECRET_KEY_HERE>")
        .build();

    novu.trigger()
        .body(TriggerEventRequestDto.builder()
            .workflowId("order-shipped")
            .to(To2.of(SubscriberPayloadDto.builder()
                .subscriberId("user_123")
                .build()))
            .payload(Map.ofEntries(
                Map.entry("orderId", "ORD-456"),
                Map.entry("trackingUrl", "https://example.com/track/456")))
            .build())
        .call();
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -X POST 'https://api.novu.co/v1/events/trigger' \
    -H 'Content-Type: application/json' \
    -H 'Authorization: ApiKey <NOVU_SECRET_KEY>' \
    -d '{
      "name": "order-shipped",
      "to": { "subscriberId": "user_123" },
      "payload": {
        "orderId": "ORD-456",
        "trackingUrl": "https://example.com/track/456"
      }
    }'
    ```
  </Tab>
</Tabs>

## What channels should I use for transactional messages?

| Event type         | Recommended channels                                                               |
| ------------------ | ---------------------------------------------------------------------------------- |
| Order confirmation | Email + in-app                                                                     |
| Shipping update    | Email, SMS, or push                                                                |
| Payment failure    | Email + in-app, with SMS fallback                                                  |
| Password reset     | Email (see [password reset guide](/guides/use-cases/password-reset-notifications)) |

## Related guides

* [Create a workflow](/platform/workflow/create-a-workflow)
* [Trigger a workflow](/platform/workflow/trigger-workflow)
* [Personalize content](/platform/workflow/add-notification-content/personalize-content)
* [Multi-channel fallback workflows](/guides/use-cases/multi-channel-fallback)

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Do I need to create subscribers before sending notifications?">
    No. You can pass subscriber details inline when triggering a workflow. Novu creates or updates the subscriber automatically if the `subscriberId` does not exist yet.
  </Accordion>

  <Accordion title="Can I send transactional email through my existing ESP?">
    Yes. Connect providers such as SendGrid, Postmark, or Amazon SES in the [Integrations store](/platform/integrations) and use them in email workflow steps.
  </Accordion>
</AccordionGroup>