Email templates

Preview में

Logic वाले templates, send के समय rendered.

किसी email template को Bird में store करें और उसे id से reference करें। जब message भेजा जाता है तब Conditionals, loops, और defaults हर recipient के लिए render होते हैं, इसलिए personalization logic आपके code में बिखरने के बजाय template में ही रहती है। इसे declared variables के साथ HTML के रूप में author करें, या अपने React Email components को render करें।

welcome.tsx
200 · 1.2s
import { BirdClient } from "@messagebird/sdk";
import { render } from "@react-email/render";
import { WelcomeEmail } from "./emails/welcome";

const bird = new BirdClient({ apiKey: process.env.BIRD_API_KEY! });

const { data, error } = await bird.email.send({
  from:    "Bird <hello@bird.com>",
  to:      ["ada@example.com"],
  subject: "Your invite is ready",
  html:    await render(<WelcomeEmail name="Ada" />),
}).safe();

if (error) throw error;
console.log(data.id);
// → "em_2bX91Yk8h..."

एक template store करें। Send के समय personalize करें।

सिर्फ़ वही values भेजें जो हर recipient के लिए बदलती हैं।

Templates Bird Email API का हिस्सा हैं। Layout और उसकी logic एक बार store करें; हर send पर आप template को reference करते हैं और प्रति-recipient values का एक flat set पास करते हैं। Bird अंतिम message अपनी तरफ़ render करता है, इसलिए वही template एक email चलाए या दस लाख।

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import { BirdClient } from "@messagebird/sdk";

const bird = new BirdClient({ apiKey: process.env.BIRD_API_KEY! });

// Store a template once. Conditionals and loops render per recipient at send.
const tpl = await bird.templates.create({
  name:    "order-confirmation",
  subject: "Order {{ order_number }} confirmed",
  html:    "<h1>Thanks, {{ first_name or 'there' }}.</h1>" +
           "{{ if is_member }}<p>You earned {{ points }} points.</p>{{ end }}",
  variables: [
    { key: "first_name",   type: "string", fallback: "there" },
    { key: "order_number", type: "string" },
    { key: "is_member",    type: "boolean" },
    { key: "points",       type: "number" },
  ],
});

// Send it. Bird fills in the blanks for each recipient.
await bird.email.send({
  from:      "orders@acme.com",
  to:        ["ada@example.com"],
  template:  tpl.id,
  variables: { first_name: "Ada", order_number: "A-1043", is_member: true, points: 120 },
});

Find-and-replace से कहीं ज़्यादा।

असली templating logic, Bird की तरफ़ resolve होती हुई, हर recipient के लिए, send के समय।

  1. 01

    Conditionals.

    किसी block को सिर्फ़ तभी दिखाएँ जब कोई value लागू हो, जैसे members-only नोट या free-shipping banner, बिना दो अलग templates भेजे।

  2. 02

    Loops.

    किसी array के हर item के लिए एक row दोहराएँ, ताकि एक ही order-confirmation template हर वो line item list करे जो customer ने सचमुच ख़रीदा।

  3. 03

    Defaults.

    जब कोई field मौजूद न हो तो एक safe value पर fall back करें, ताकि खाली first name कभी खाली greeting बनकर न जाए।

  4. 04

    Nested data.

    सिर्फ़ flat top-level keys नहीं, dotted paths के साथ structured objects में पहुँचें, ताकि आपके मौजूदा data shapes सीधे map हो जाएँ।

  5. 05

    Rich variable types.

    Declared variables strings, numbers, booleans, arrays, और objects हो सकते हैं, यही ऊपर बताए loops और conditionals को संभव बनाता है।

इसे उसी तरह author करें जैसे आप पहले से काम करते हैं।

API के ज़रिए declared variables की एक list के साथ plain HTML भेजें, और आपके पास एक चलता-फिरता template है, कोई नया editor सीखने की ज़रूरत नहीं। Components पसंद हैं? अपने React Email templates को HTML में render करें और नतीजा store करें। जानने लायक एक बात: Bird के tokens को JSX में literal text के रूप में छोड़ दें ताकि वे render में बचे रहें और send के समय भर जाएँ, बजाय इसके कि React render होते समय कोई value bake हो जाए।

receipt.ts
React Email
import { render } from "@react-email/render";
import { Receipt } from "./emails/receipt";

// Author in React. Leave Bird's tokens as literal text so they
// survive the render and get personalized per recipient at send.
const html = await render(<Receipt firstName="{{ first_name }}" />);

await bird.templates.create({
  name:    "receipt",
  subject: "Your receipt",
  html,
  variables: [{ key: "first_name", type: "string", fallback: "there" }],
});

Versioned, बिल्कुल आपके बाक़ी code की तरह।

Editing एक draft पर होती है और जो live है उसे कभी नहीं छूती। Publish करने पर एक immutable, numbered version freeze होकर push हो जाता है; अगर कोई बदलाव ग़लत हो जाए, तो किसी पहले version पर roll back कर फिर से publish करें। एक साथ हुई edits चुपचाप overwrite होने के बजाय पकड़ी जाती हैं, इसलिए एक ही template पर काम कर रहे दो लोग एक-दूसरे का काम नहीं बिगाड़ते। हर version की एक स्थिर पहचान होती है, यही चीज़ per-template reporting को opens और clicks सही ढंग से attribute करने देती है।

हर brand को consistent रखें।

एक brand kit आपके रंग, type, spacing, logo, और voice को रखता है, और उन्हें किसी template पर लागू करता है ताकि output बिना हर एक को हाथ से restyle किए आप जैसा दिखे और पढ़े। Kits workspace स्तर पर रहते हैं और एक workspace कई रख सकता है, क्योंकि एक parent brand, एक sub-brand, और आपका सादा transactional mail शायद ही कभी एक जैसा look चाहते हैं। Kit इस्तेमाल करना optional है: बिना kit वाला template साफ़-सुथरे defaults पर fall back करता है।

जो ship होगा उसका ठीक वैसा preview देखें।

किसी template को sample values से भरें और किसी के प्राप्त करने से पहले rendered message देखें। Preview उसी rendering path से गुज़रता है जिससे असली send गुज़रता है, इसलिए जिसे आप approve करते हैं वही बाहर जाता है, न कि कोई qरीब-क़रीब approximation जो असली recipients के लिए tokens और logic resolve होते ही बदल जाए।

Templates किस दिशा में जा रहे हैं।

Stored-template model आगे आने वाली चीज़ों की नींव है: किसी prompt में एक template describe करें और refine करने के लिए एक draft generate करें, बिना HTML लिखे इसे visual रूप से बनाएँ, और coding agents को MCP के ज़रिए on-brand templates compose करने दें, साथ ही शुरुआत के लिए starter templates की एक library। ये उसी versioned, brand-aware model पर बनते हैं, कोई अलग track नहीं, इसलिए जो API आप आज integrate करते हैं वही वे extend करते हैं।

Docs में और गहराई से जाएँ।

देखें कि templates sending guide में कैसे फ़िट होते हैं, जिसमें React Email render करना शामिल है, और email events और webhooks wire up करें ताकि opens और clicks प्रति template वापस आएँ।

Templates से जुड़े सामान्य सवाल

क्या मुझे visual builder इस्तेमाल करना ही पड़ेगा?+
नहीं। आप templates को पूरी तरह API के ज़रिए बना और मैनेज कर सकते हैं: अपना HTML declared variables की एक list के साथ भेजें, और भेजते समय template को उसकी id से reference करें। Builder बस एक रास्ता है, इकलौता नहीं।
हर send पर HTML पास करने से stored template कैसे अलग है?+
Stored template को id से reference किया जाता है और वह versioned होता है, और send के समय उसका personalization Bird की तरफ render होता है। तो आप हर बार पूरा body नहीं, सिर्फ़ प्रति-recipient values भेजते हैं, और layout तथा logic एक ही जगह रहते हैं, बजाय हर call पर आपके code में दोबारा बनने के।
Personalization find-and-replace से आगे क्या कर सकता है?+
Conditionals, arrays पर loops, nested fields, और प्रति-field defaults, सब send के समय हर recipient के लिए resolve होते हैं। एक membership block सिर्फ़ members को दिख सकता है; एक order अपने line items list कर सकता है। Logic template में stored रहता है, इसलिए इसे चलाने के लिए हर recipient का एक flat key-value payload काफ़ी है।
क्या React Email काम करता है?+
हाँ। अपने React Email components को HTML में render करें और नतीजे को template body के रूप में store करें। प्रति-recipient values के लिए, Bird के tokens को JSX में literal text के रूप में छोड़ दें ताकि वे render में बचे रहें और send के समय भर जाएँ, बजाय इसके कि React render होते समय कोई value bake हो जाए।
अगर मैंने कोई template बिगाड़ दिया तो क्या मैं उसे roll back कर सकता हूँ?+
Publish करने पर एक immutable, numbered version freeze हो जाता है। Editing एक draft पर होती है और जो live है उसे तब तक नहीं छूती जब तक आप publish न करें, और आप किसी भी पहले publish किए गए version पर roll back कर उसे फिर से publish कर सकते हैं। हर version की एक स्थिर पहचान बनी रहती है, यही चीज़ per-template reporting को sends सही ढंग से attribute करने देती है।
क्या कोई AI generation या drag-and-drop builder है?+
ये वो हैं जिनकी तरफ़ हम बढ़ रहे हैं, न कि जो पहले ship होते हैं। API (declared variables के साथ HTML) और React Email आज उपलब्ध authoring रास्ते हैं; एक visual builder, prompt-to-template generation, और एक agent compose surface इसी stored-template model के ऊपर आते हैं।
मैं असल में कोई stored template कैसे भेजूँ?+
Send call वैसी की वैसी रहती है: template को उसकी id से reference करें और प्रति-recipient values पास करें, बाक़ी का काम मौजूदा email send API संभाल लेता है। सीखने के लिए कोई अलग template-send endpoint नहीं है।

Templates एक platform का हिस्सा हैं, कोई point tool नहीं।

उसी Email API पर templates को store, version, और personalize करें जो sending, deliverability, suppression, और analytics संभालता है। Keys का एक set।

एक चैनल से शुरुआत करें।
तैयार होने पर बाकी जोड़ें।

एक test API key तुरंत आपकी है। जब आप payment method जोड़ते हैं और sender verify करते हैं, तब production अनलॉक हो जाता है।

Claude Code, Cursor या Codex इस्तेमाल कर रहे हैं? एक setup prompt कॉपी करें और आपका agent आपके लिए Bird CLI और skills इंस्टॉल कर देगा। अपना चुनें:

Cursor