canonical: https://jentic.com/apis/faivelo.com/faivelo

# Faivelo API

The Faivelo API runs a full email service over REST: it manages mail domains and their DNS records, creates mailboxes and aliases, and sends, reads, searches, and organises mail. Transactional email goes out through a send endpoint, while per-mailbox operations list folders and messages, flag or move them, mark spam, and download attachments. Partner endpoints let approved resellers provision and manage customer accounts under their own brand, and a Drive surface lists files with download URLs. Authentication uses a bearer API key, scoped per key to the operations it may perform.

## For AI agents

Run a full email service through Faivelo: send transactional mail, create mailboxes and aliases on your domains, manage DNS records, and list, read, search, flag, and move messages in a mailbox.

## Scope

Does not handle SMS, voice, push notifications, or chat. Use for email: hosting mailboxes and domains, sending transactional mail, and reading and organising messages only.

## Capabilities

- Send transactional email via POST /emails and send mail from a specific mailbox via POST `/mailboxes/{address}/send`
- Create mailboxes on your domains via POST /mailboxes and reset their passwords
- List, read, search, flag, move, and mark messages as spam within a mailbox via `/mailboxes/{address}/messages` and its actions
- Manage mail domains and their DNS records via /domains and `/domains/{domain}/dns/records`
- Create and delete aliases via POST /aliases and DELETE `/aliases/{address}`
- Provision and manage reseller customer accounts via the /customers partner endpoints
- List Drive files and get a file download URL via /drive and `/drive/{id}/download-url`

## Use cases

### AI agent with its own mailbox

An AI agent provisions a mailbox on your domain, sends from it, and polls the inbox to read what comes back, for example a verification code during a sign-up it is driving. Through Jentic it creates the mailbox, sends mail, and searches messages without a person wiring SMTP or IMAP. Jentic injects the Faivelo key at call time, so the agent never holds the raw secret.

Example prompt: Search Jentic for 'create a mailbox and send mail', create one with POST /mailboxes, send from it with POST `/mailboxes/{address}/send`, then poll GET `/mailboxes/{address}/messages` for the reply

### Transactional email sending

Applications need to send receipts, password resets, and notifications and know they left the building. Faivelo sends transactional email through POST /emails and lets a caller fetch a sent email's record by id, so a workflow can send and then confirm. It sends from mail domains you control rather than a shared pool.

Example prompt: Call POST /emails with the recipient, subject, and body, then read GET `/emails/{id}` to confirm the send was recorded

### Domain and mailbox provisioning

Standing up email for a new domain means adding the domain, publishing the right DNS records, and creating mailboxes on it. Faivelo exposes the domain, DNS record, and mailbox operations to script that whole setup, so an onboarding flow can take a bare domain to a working mailbox. Aliases can then forward addresses to the right mailbox.

Example prompt: Add DNS with POST `/domains/{domain}/dns/records`, create the mailbox with POST /mailboxes, then create an alias with POST /aliases to forward a public address to it

### Inbox search and triage

A support or automation workflow needs to find specific messages and act on them. Faivelo searches a mailbox, lists folders and messages, and lets a caller flag, move, or mark messages as spam, so an agent can triage an inbox programmatically. Attachments can be downloaded for processing downstream.

Example prompt: Call GET `/mailboxes/{address}/search` to find the message, then POST `/mailboxes/{address}/messages/{uid}/move` to file it in the right folder

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/emails` | Send a transactional email |
| POST | `/mailboxes` | Create a mailbox |
| POST | `/mailboxes/{address}/send` | Send mail from a mailbox |
| GET | `/mailboxes/{address}/messages` | List messages in a mailbox |
| GET | `/mailboxes/{address}/search` | Search messages in a mailbox |
| POST | `/domains/{domain}/dns/records` | Create a DNS record |
| POST | `/aliases` | Create an alias |
| GET | `/domains` | List domains |

## Key resources

- **Mailboxes** — Create mailboxes, send and receive mail, and list, read, search, flag, move, and spam-mark messages
- **Domains and DNS** — Manage mail domains and create, update, and delete their DNS records
- **Emails** — Send transactional email and fetch a sent email's record by id
- **Aliases** — Create and delete aliases that forward addresses to mailboxes
- **Partner customers** — Provision and manage reseller customer accounts, their domains, mailboxes, and keys

## 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:** 62 / 100
- **Maturity:** AI-Aware
- **Dimensions:**
  - Foundational Compliance: 45 / 100
  - Developer Experience & Jentic Compatibility: 66 / 100
  - AI-Readiness & Agent Experience: 53 / 100
  - Agent Usability: 93 / 100
  - Security: 60 / 100
  - AI Discoverability: 82 / 100
- **View full report:** https://jentic.com/apis/faivelo.com/faivelo/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 Faivelo API by hand means managing its bearer key and per-key scopes, publishing DNS for each mail domain, and building the send-then-poll inbox loop yourself. Through Jentic you install once, import Faivelo from the API Directory, store the key once, and your agent calls it.
- **Permission scoping:** Faivelo puts the mailbox address and domain in the URL path, such as `/mailboxes/{address}` and `/domains/{domain}`, so a rule can pin your agent to the mailbox and domain operations it needs. You choose the operations it may call, so destructive ones like deleting a mailbox or a DNS record are not included unless you add them.
- **Credential handling:** Your Faivelo 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 'send a transactional email' or 'create a mailbox', and Jentic returns the matching Faivelo operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Resend** — Transactional email delivery API focused on sending rather than full mailbox hosting
- **Mandrill** — Transactional email service with templates and delivery tracking
- **Gmail API** — Reads and sends mail for existing Google mailboxes

## FAQ

### What authentication does the Faivelo API use?

The Faivelo API authenticates with a bearer API key, per its OpenAPI spec, and each key carries scopes that decide which operations it may perform. When you call it through Jentic, the key is stored encrypted by your own Jentic One instance and injected at execution time, so it never enters the agent's prompt, logs, or context.

### Can I send email from my own domain with the Faivelo API?

Yes. Send transactional email with POST /emails, or send from a specific mailbox with POST `/mailboxes/{address}/send`, both from mail domains you control rather than a shared pool. You can then fetch a sent email's record with GET `/emails/{id}` to confirm it went out.

### Can the Faivelo API read and search a mailbox?

Yes. List messages with GET `/mailboxes/{address}/messages`, search with GET `/mailboxes/{address}/search`, read one with GET `/mailboxes/{address}/messages/{uid}`, and act on it with flag, move, and spam operations. Attachments come down through GET `/mailboxes/{address}/messages/{uid}/attachment.`

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

The OpenAPI spec does not pin rate limits in a machine-readable field. Check the Faivelo documentation for current per-key request and send limits, and have your agent back off when the API signals that it is being throttled.

### How do I give an agent its own mailbox through Jentic?

Search Jentic for 'create a mailbox and send mail' to load the Faivelo operations with their input schemas, create a mailbox with POST /mailboxes, send with POST `/mailboxes/{address}/send`, and poll GET `/mailboxes/{address}/messages` for replies. To run it on your own infrastructure, install Jentic One from its GitHub repo.

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

Yes. Faivelo puts the mailbox address and domain in the URL path, such as `/mailboxes/{address}` and `/domains/{domain}`, so a rule can pin your agent to the mailbox and sending operations it needs. Destructive operations, such as deleting a mailbox or a DNS record, stay out unless you add them, and every call the agent makes is logged.
