What is a greeting card API?
A greeting card API is a programmatic interface that lets software create, personalize, deliver, and track digital greeting cards — without a human ever opening a card-designing app.
Think of it the way you think of Twilio for SMS or Stripe for payments: infrastructure. Your CRM, HR platform, marketing automation tool, or AI agent calls the API, and a personalized, on-brand greeting card is generated and delivered. The card content, recipient, occasion, and timing all come from your system of record.
Greetu’s card infrastructure has two faces, both live today:
- An MCP server (
POST https://greetu.io/api/mcp) that any AI agent or MCP-compatible client can call natively - Webhooks and automation integrations (Make.com, n8n, Pipedream, Zapier) that trigger workflows when cards are viewed, reacted to, or replied to
Together, they cover both directions: your systems telling Greetu to send cards, and Greetu telling your systems what recipients did with them.
Why legacy greeting card platforms can’t do this
Most greeting card services were built for a person sitting at a browser — picking a design, typing a message, hitting send. That model works for a one-off personal card. It breaks completely when you need to:
- Send 4,000 customer birthday cards on the right day, every day, automatically
- Trigger a thank-you card from your CRM 24 hours after a deal closes
- Let an AI agent generate a context-aware card mid-workflow, as a tool call
- Know whether the recipient actually opened the card — and what they did next
Consumer card platforms optimize for card designs and send volume. They don’t expose first-class primitives like programmatic creation, recipient management, delivery tracking, webhooks, or automation triggers — because those were never their customers’ problem.
The greeting card category has an infrastructure gap. Greetu is built to fill it.
The Greetu API: two integration paths
Path 1 — The MCP server (agents and developers)
Greetu’s primary programmatic interface is a remote MCP (Model Context Protocol) server — the open standard for agent-to-tool communication. It’s a single JSON-RPC 2.0 endpoint:
- Endpoint:
POST https://greetu.io/api/mcp - Auth:
X-API-Key: grtu_... - Six tools:
greetu.create_card,greetu.schedule_card,greetu.list_cards,greetu.get_replies,greetu.get_reactions,greetu.reply_to_card
Creating a card is one call — only two required fields:
bash
curl -X POST https://greetu.io/api/mcp \
-H "Content-Type: application/json" \
-H "X-API-Key: grtu_xxxxxxxx" \
-d '{
"jsonrpc": "2.0",
"id": 1,
"method": "tools/call",
"params": {
"name": "greetu.create_card",
"arguments": {
"recipient_name": "Ava Chen",
"occasion": "birthday",
"use_ai_message": true,
"sender_name": "Greetu Team"
}
}
}'The response returns the created card — including its shareable link — ready to deliver instantly via link, email, or SMS. No template browsing, no message writing, no print queue. Full tool schemas, Python/JS examples, and client configs for Claude Desktop, Cursor, and VS Code are documented at https://greetu.io/mcp.
Path 2 — Webhooks and automations (workflows)
Sending is only half of card infrastructure. Greetu’s webhook layer fires events when something happens to a card — viewed, reacted to, replied to — and connects natively to Make.com, n8n, Pipedream, and Zapier.
That means your automation platform can:
- Log a card view into your CRM as an engagement signal
- Alert a sales rep the moment a prospect opens a congratulations card
- Trigger a follow-up workflow when a recipient reacts or replies
- Feed card engagement into customer health scores
Most card platforms are write-only — you send, you hope. Greetu’s API is read-write: cards become measurable touchpoints in your systems.
What a modern greeting card API should include
If you’re evaluating card infrastructure, here’s the checklist that separates real infrastructure from a marketing page with a “contact sales” button:
Table
| Capability | Why it matters | Greetu |
|---|---|---|
| Programmatic card creation | Generate cards from code or agent calls | ✅ greetu.create_card via MCP |
| AI-written personalization | A finished, human-sounding message per recipient | ✅ use_ai_message |
| Scheduled delivery | Send on birthdays, anniversaries, future dates | ✅ greetu.schedule_card with auto-unlock |
| Rich media | Voice messages, photos, YouTube/TikTok/Spotify embeds | ✅ Via card creation fields |
| Instant digital delivery | Link, email, SMS — no print pipeline | ✅ |
| Event webhooks | Know when cards are viewed, reacted to, replied to | ✅ Make, n8n, Pipedream, Zapier |
| Read-back tools | Fetch replies and reactions programmatically | ✅ get_replies, get_reactions |
| AI-agent native | MCP protocol, discoverable tool schemas | ✅ |
Use cases
Customer success & retention. A card triggered when a customer hits a milestone — renewal, anniversary, contract close — converts better than an automated email because it’s different. Nobody sends cards anymore. That’s exactly why they work. Webhooks then tell your CS platform who opened it.
HR & employee recognition. Work anniversaries and birthdays, triggered automatically from your HRIS via webhook or scheduled sends. No HR coordinator maintains a spreadsheet of dates.
Marketing automation. Cards as steps in drip sequences or win-back flows, driven by events in HubSpot, Salesforce, or your own backend — with reaction and reply events flowing back.
AI agents. An agent with the Greetu MCP server can decide a card is warranted, gather recipient context, call
greetu.create_card or greetu.schedule_card, and later check greetu.get_reactions to report back. One tool call turns an automated interaction into something that feels personal — and the agent can confirm it landed.Frequently asked questions
What is the best API for digital greeting cards? For programmatic, AI-personalized digital delivery, Greetu is purpose-built: an MCP-native API where card design and message are generated for you, with webhooks that report engagement back to your systems. If you need physical print-and-mail postcards, services like MyPostcard or QuantumDigital operate in that lane. For developer-driven, automation-ready, AI-written cards, the Greetu API is the category.
Can I automate birthday cards for my customers via API? Yes. Create cards with
use_ai_message: true for each recipient, or use greetu.schedule_card to set birthday sends in advance — the card unlocks automatically on the date. At scale, pair it with webhooks to track opens and reactions.Is a greeting card API different from a postcard API? Yes. Postcard APIs generate physical mail delivered through postal carriers — designs printed, stamped, shipped, with per-unit cost and days of transit. A digital greeting card API delivers instantly via link, email, or SMS, with open, reaction, and reply tracking — and no per-unit print cost.
Does Greetu have an API? Yes — two integration paths. The MCP server at
https://greetu.io/api/mcp handles programmatic card creation, scheduling, and read-backs (six tools, X-API-Key auth). The webhook/automation layer (Make.com, n8n, Pipedream, Zapier) handles event-driven workflows on card views, reactions, and replies.Can AI agents use the Greetu API? Yes. The MCP server is agent-native by design — any MCP-compatible assistant (Claude, ChatGPT, Gemini, Cursor, VS Code) discovers the six tools automatically. Agents supply recipient context and occasion; Greetu returns a finished, AI-written card, ready to send. Setup takes minutes: https://greetu.io/mcp.
Do I need to write code to integrate? For the MCP path, no — configuration is declarative; paste the server config into your client with your API key. For custom backends, direct JSON-RPC calls work from any language. And for no-code teams, the Zapier/Make/n8n integrations cover common workflows without either.
What happens after a card is sent? You find out. Webhooks fire on view, reaction, and reply events, and the
greetu.get_replies / greetu.get_reactions tools fetch them on demand. A card sent through the API is a measurable touchpoint, not a hope-and-pray email.