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

# Email on Acid API

Jentic publishes the only available OpenAPI specification for Email on Acid API, keeping it validated and agent-ready. Email on Acid runs pre-send email tests across more than 90 client and device combinations and returns rendered screenshots so marketing teams can catch broken layouts before campaigns go out. The API supports creating and reprocessing inbox tests, fetching per-client results, and running spam filter checks against major providers. Use it to gate marketing email deployment on automated rendering and deliverability checks rather than manual previews.

## For AI agents

Run automated rendering and spam tests on marketing emails across 90+ inbox clients and retrieve per-client screenshots and deliverability scores.

## Scope

Does not handle email sending, list management, or campaign analytics - use for pre-send rendering and spam QA only.

## Capabilities

- Submit an HTML email for rendering tests across desktop, mobile, and webmail clients
- Retrieve per-client screenshot URLs and rendering metadata for a completed test
- Reprocess a stalled test against the currently available client list
- Trigger spam filter tests and read scores from SpamAssassin and major mailbox providers
- List the catalogue of supported email clients and devices before submitting a test
- Delete completed tests to manage account storage and audit history

## Use cases

### Pre-Send Rendering QA

Run an HTML email through Email on Acid before deployment to catch layout breaks in Outlook desktop, Apple Mail, Gmail webmail, and mobile clients. The API creates a test, returns a test ID, and exposes per-client screenshot URLs as renders complete. Marketing operations teams use this to gate campaign sends on automated visual checks instead of manually forwarding to test inboxes, cutting QA time per campaign from hours to minutes.

Example prompt: POST `/email/tests` with the campaign HTML and a list of target client IDs, poll GET `/email/tests/{testId}/results/{clientId}` for each client, and return the screenshot URLs that show rendering failures.

### Campaign Spam Score Check

Submit campaign content to spam tests and read scores from major filters before sending to a paid list. The API runs the email against SpamAssassin and major provider checks and returns scored output identifying triggers such as suspect headers or content phrases. Teams use this to fix deliverability issues before damaging sender reputation, particularly on cold or re-engagement sends.

Example prompt: POST `/spam/tests` with the email subject, headers, and body, then GET `/spam/tests/{testId}` once processing completes to retrieve the score breakdown and trigger keywords.

### Client Coverage Discovery

List the supported email clients before scheduling a rendering test so the right device and client matrix is targeted. The API returns identifiers and human-readable names for every client currently available for testing. Operations teams script this into nightly checks so new clients are picked up automatically and old ones are pruned from test plans.

Example prompt: Call GET `/email/clients` and return a deduplicated list of client IDs grouped by platform (desktop, mobile, webmail).

### Agent-Driven Pre-Flight Email Check

An agent inside a marketing platform takes a draft HTML email, submits it to Email on Acid for both rendering and spam tests, waits for results, and writes a structured pass or fail summary back to the campaign record. Through Jentic the agent searches for the relevant operations, loads input schemas, and executes the calls without bespoke client code. Integration time drops from a multi-day SDK build to under an hour.

Example prompt: Search Jentic for 'test email rendering across clients', execute POST `/email/tests` and POST `/spam/tests` in parallel, poll for completion, and return a single JSON object summarising rendering issues and the spam score.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/email/tests` | Create an email rendering test |
| GET | `/email/tests/{testId}` | Get test details and overall status |
| GET | `/email/tests/{testId}/results/{clientId}` | Get rendering result for a specific client |
| POST | `/email/tests/{testId}/reprocess` | Reprocess a stalled test |
| POST | `/spam/tests` | Create a spam filter test |
| GET | `/spam/tests/{testId}` | Get spam test scores and triggers |
| GET | `/email/clients` | List supported email clients |

## Key resources

- **Email Tests** — Create, retrieve, reprocess, and delete inbox rendering tests and read per-client results
- **Spam Tests** — Submit campaign content for spam filter scoring and retrieve trigger details
- **Clients** — List the catalogue of supported email clients and devices for test targeting

## Why Jentic

- **Setup:** Wiring Email on Acid by hand means handling its HTTP Basic auth, encoding credentials on every call, and polling test results across clients yourself. Through Jentic you install once, import the Email on Acid API from the API Directory, store the Basic credential once, and your agent calls it.
- **Permission scoping:** Email on Acid puts the test id in the URL path (`/email/tests/{testId}`, `/spam/tests/{testId}`), so a rule can pin your agent to one test for its result reads. You choose the operations it may call, so starting new tests or reprocessing are not included unless you add them.
- **Credential handling:** Your Email on Acid Basic credential 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 'test email rendering across clients' or 'run a spam check', and Jentic returns the matching Email on Acid operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Mailtrap API** — Email sandbox and testing inbox with rendering preview
- **Elastic Email API** — Bulk email delivery for validated campaigns
- **SparkPost API** — Send the campaign once Email on Acid QA passes
- **Postmark Account API** — Account-level provisioning to support tested sender domains

## FAQ

### Why is there no official OpenAPI spec for Email on Acid API?

Email on Acid does not publish an OpenAPI specification. Jentic generates and maintains this spec so that AI agents and developers can call Email on Acid API via structured tooling. It is validated against the live API and kept up to date. Get started with Jentic One, the self-hosted execution layer.

### What authentication does the Email on Acid API use?

The API uses HTTP Basic authentication with your Email on Acid account credentials passed in the Authorization header. Through Jentic, those credentials are stored encrypted in the vault and the agent receives only a scoped token, so the username and password never enter the agent's context.

### Can I run spam filter tests with the Email on Acid API?

Yes. POST `/spam/tests` submits the email and GET `/spam/tests/{testId}` returns the scores and trigger details. The same flow can be used directly or driven through a Jentic agent.

### How do I get rendering screenshots through Jentic?

Search Jentic with the query 'test email rendering across clients', load the schema for POST `/email/tests`, execute it with your HTML and client list, then call GET `/email/tests/{testId}/results/{clientId}` per client to retrieve screenshot URLs.

### What are the rate limits for the Email on Acid API?

The OpenAPI spec does not declare quantitative rate limits; Email on Acid enforces limits at the account tier. Treat 429 responses as authoritative and back off using the Retry-After header when present.

### Can I list the available email clients before submitting a test?

Yes. GET `/email/clients` returns the current catalogue with client IDs and platform metadata, so you can build the target client list dynamically rather than hard-coding values.

### How do I reprocess a test that did not finish?

Call POST `/email/tests/{testId}/reprocess` to requeue an incomplete test against the currently available client list, then re-poll GET `/email/tests/{testId}` until status reaches completion.

### Can I limit what my agent is allowed to do with the Email on Acid API?

Yes. Because you run Jentic One yourself, your own rules decide which Email on Acid operations and credentials the agent may use. You can grant it only read operations such as GET `/email/tests/{testId}` and GET `/spam/tests/{testId}` while withholding test-creating or reprocessing calls, and since the test id lives in the URL path you can pin the agent to a single test for its result reads. The Basic credential stays with your Jentic One instance, so the agent acts only within the operations you approve.