canonical: https://jentic.com/apis/anjal.app/anjal

# Anjal App Anjal API

The Anjal API creates email inboxes and sends and receives mail for AI agents across isolated workspaces. Inboxes live on a shared sending domain or a custom domain you register and verify, and each one can send, reply, forward, draft, thread, label, and search messages, with attachments handled through one-time upload and download links. It also isolates resources per tenant for reseller setups, pushes delivery events over webhooks, and drives LinkedIn outreach through connected sessions.

## For AI agents

Create email inboxes on shared or custom domains, send and receive mail, manage drafts and threads, search messages, verify sending domains, and receive delivery events over webhooks.

## Scope

Does not handle SMS, voice calls, or push notifications. Use for email inboxes, delivery, and connected LinkedIn outreach only.

## Capabilities

- Create email inboxes on a shared or custom sending domain
- Send, reply to, and forward messages from an inbox
- Search messages full-text across inboxes
- Draft messages and organize them into threads and labels
- Register and verify a custom sending domain
- Subscribe to delivery events through webhooks
- Check recipient deliverability before sending

## Use cases

### Agent-managed mailboxes

An AI agent connected through Jentic provisions an inbox and starts corresponding on a user's behalf: it creates the inbox, sends a message, and reads the reply from the thread. Because the agent discovers operations by intent, a full send-and-receive email loop runs without a developer wiring the inbox and messaging endpoints by hand.

Example prompt: Create an inbox, send a message to a recipient, then list the inbox threads and read the reply

### Reseller-isolated email per customer

Anjal isolates resources across workspaces and tenants so a reseller can give each end-customer its own inboxes under one billing relationship. An agent can create a workspace, issue a scoped key, and register a custom domain for that tenant, keeping each customer's mail separate. This supports multi-tenant products without each tenant leaking into another's data.

Example prompt: Create a workspace, register and verify a custom domain for it, and create an inbox on that domain

### Deliverability and event tracking

Before sending, the API checks whether a recipient address is deliverable, and after sending it pushes delivery events to a webhook. An agent can validate a list, send only to deliverable addresses, and react to bounces or opens as the events arrive, grounding send decisions in Anjal's deliverability and event data rather than guessing.

Example prompt: Check whether a recipient is deliverable, send a message if it is, and register a webhook to receive the delivery events

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/v1/inboxes` | Create an inbox |
| POST | `/v1/inboxes/{id}/send` | Send a message from an inbox |
| GET | `/v1/inboxes/{id}/threads` | List threads in an inbox |
| GET | `/v1/messages/search` | Search messages across inboxes |
| POST | `/v1/inboxes/{id}/drafts` | Create a draft |
| POST | `/v1/domains` | Register a custom domain |
| POST | `/v1/webhooks` | Create a webhook |
| POST | `/v1/verify-email` | Check recipient deliverability |

## Key resources

- **Inboxes** — Create inboxes and send, reply, forward, thread, and read messages
- **Messages** — List, search, and read messages and attachments across inboxes
- **Domains** — Register, verify, and export zone files for custom sending domains
- **Workspaces & Tenants** — Isolate resources per workspace and tenant for reseller setups
- **Webhooks** — Create webhooks that push delivery events to your endpoint
- **Drafts** — Create, update, and send drafts within an inbox

## AI readiness

This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.

- **Score:** 56 / 100
- **Maturity:** Foundational
- **Dimensions:**
  - Foundational Compliance: 45 / 100
  - Developer Experience & Jentic Compatibility: 60 / 100
  - AI-Readiness & Agent Experience: 48 / 100
  - Agent Usability: 81 / 100
  - Security: 50 / 100
  - AI Discoverability: 79 / 100
- **View full report:** https://jentic.com/apis/anjal.app/anjal/scorecard
- **How the score is calculated:** https://docs.jentic.com/reference/api-readiness-framework/overview/
- **More about the dimensions:** https://docs.jentic.com/reference/api-readiness-framework/specification/#dimensional-model-overview

### Score it yourself

Every API in the directory is allowlisted, so you can re-score it with no key required.

- **Score your own API:** https://jentic.com/scorecard.md
- **Scoring CLI agent skill:** https://github.com/jentic/jentic-api-scorecard/blob/main/skills/jentic-api-scorecard/SKILL.md

```sh
npx @jentic/api-scorecard-cli score <openapi-url>
```

## Why Jentic

- **Setup:** Wiring the Anjal API by hand means handling its X-API-Key auth, registering and verifying sending domains, and tracking webhooks and per-tenant workspace keys yourself. Through Jentic you install once, import the API from the Directory, store the key once, and your agent calls it.
- **Permission scoping:** Anjal carries its request targets in the body rather than the URL path, so rules bound which operations your agent may call: you can allow inbox send and read operations while leaving inbox deletion and domain management out unless you add them. You choose the operations it may use.
- **Credential handling:** Your Anjal API key is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'create an inbox' or 'send an email', and Jentic returns the matching Anjal operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Resend** — Resend sends transactional email with a developer-first API but without Anjal's per-tenant inbox model
- **SendGrid Mail** — SendGrid sends high-volume transactional and marketing email through a hosted platform
- **Twilio** — Twilio adds SMS and voice channels alongside Anjal's email for multi-channel outreach

## FAQ

### What authentication does the Anjal API use?

The Anjal API authenticates with an API key sent in the X-API-Key header, as declared in its OpenAPI spec, and workspace keys scope access per tenant. Through Jentic the key is stored once by your own self-hosted instance and injected at call time, so it never appears in the agent's prompt or logs.

### Can I send and receive email with the Anjal API?

Yes. You create an inbox, send messages, reply, forward, and draft, and read threads and attachments back. Full-text search spans inboxes, and a webhook pushes delivery events so an agent can react to replies and bounces.

### Is there an Anjal API MCP server?

You do not need an MCP server to give your agent the Anjal API. Jentic connects it directly from the API Directory: import the API, store your API key once, and your agent sends and reads mail on demand without loading another server's tool definitions into its context.

### Can I limit what my agent is allowed to do with the Anjal API?

Yes. Write a rule that allows only the inbox send and read operations for one workspace, so the agent can correspond from that workspace but cannot delete inboxes or manage domains unless you add those, and every call it makes is logged for review. Anjal carries its targets in the request body, so rules bound which operations the agent may call.

### What are the rate limits for the Anjal API?

The OpenAPI spec does not specify rate limits for the Anjal API. Check the vendor documentation at https://anjal.app for current limits before sending at high volume.

### How do I send an email with the Anjal API through Jentic?

Search Jentic for an intent such as 'send an email from an inbox', and it returns the matching operation with its input schema so your agent passes the recipient and body correctly. To run it on your own infrastructure, install Jentic One from its GitHub repo.