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

# Get a Newsletter API

Jentic publishes the only available OpenAPI specification for Get a Newsletter API, keeping it validated and agent-ready. Get a Newsletter is a Nordic email marketing platform used to build and send newsletters, manage subscribers, and report on campaign performance. The API exposes contacts, mailing lists, list subscribers, sender identities, and campaign reports across 25 endpoints, supporting upsert via PUT for both contacts and lists. It is most often used to sync customers from a CRM or e-commerce system into segmented mailing lists and to pull campaign reports back for analytics.

## For AI agents

Manage email contacts and lists, add or remove subscribers, manage verified sender identities, and pull campaign reports for the Get a Newsletter platform. Supports upsert via PUT for predictable sync workflows.

## Scope

Does not handle transactional email, SMS, or push notifications - use for newsletter campaign list management and reporting only.

## Capabilities

- Upsert customer contacts into Get a Newsletter using email as the natural key
- Maintain mailing lists and add or remove subscribers in response to product or CRM events
- Register and verify sender email identities before launching a campaign
- Retrieve campaign reports to feed open and click rates back into analytics dashboards
- Segment subscribers by list membership for targeted campaign sends
- Unsubscribe a contact from a specific list when a customer opts out

## Use cases

### CRM-to-List Synchronisation

Marketing teams want a customer's CRM segment to drive their newsletter membership automatically - for example, putting all paying customers on a 'customers' list and all trial users on a 'trials' list. The Get a Newsletter API supports upsert by email on contacts and add-to-list on subscribers, so a recurring sync job can keep the list aligned with the CRM segment without duplicates.

Example prompt: For each contact in the CRM 'customers' segment, call `PUT `/contacts/{email}`/` to upsert and `POST `/lists/{hash}/subscribers`/` to add to the customer list.

### Transactional Subscribe Flow

When a user signs up to a marketing list on a website, the front-end captures the email and the backend needs to create the contact and add them to a chosen list. The API's contact creation and subscriber addition endpoints support this flow with predictable responses, and the upsert pattern via PUT means re-submissions don't create duplicates.

Example prompt: On form submission, call `PUT `/contacts/{email}`/` then `POST `/lists/{hash}/subscribers`/` to subscribe the user to the chosen list.

### Campaign Report Pipeline

Analytics teams want campaign open rate, click rate, and bounce data alongside web analytics in a single warehouse. The API's reports endpoints expose campaign-level metrics so a daily job can pull report records and load them into a destination such as BigQuery or Snowflake for combined dashboards.

Example prompt: Call `GET /reports/` for new reports since yesterday and `GET `/reports/{id}`/` for each report ID, then load the records into a warehouse table.

### Agent-Driven Newsletter Subscription

An AI agent assisting a customer can subscribe them to the right list when they ask 'sign me up for product updates'. Through Jentic, the agent discovers the subscriber-add endpoint, executes it with the customer's email, and replies with confirmation - without ever holding the API key.

Example prompt: Resolve the customer's email and the requested list slug, then call `POST `/lists/{hash}/subscribers`/` via Jentic and confirm the success response to the customer.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| PUT | `/contacts/{email}/` | Upsert a contact by email |
| POST | `/lists/{hash}/subscribers/` | Add a subscriber to a mailing list |
| DELETE | `/lists/{hash}/subscribers/{email}/` | Remove a subscriber from a list |
| GET | `/lists/` | List all mailing lists |
| GET | `/reports/{id}/` | Get a specific campaign report |
| POST | `/senders/{id}/request_confirmation/` | Request sender email confirmation |

## Key resources

- **Contacts** — Email contacts identified by email; supports list, create, upsert, partial update, delete.
- **Lists** — Mailing lists; supports CRUD plus upsert by hash.
- **Subscribers** — Membership of a contact on a specific mailing list.
- **Senders** — Verified sender identities used as the from address on campaigns.
- **Reports** — Campaign-level performance reports for analytics export.

## Why Jentic

- **Setup:** Wiring the Get a Newsletter API by hand means setting up its Authorization-header token, mapping contact, list, subscriber, and report calls to the right paths, and handling the trailing-slash conventions yourself. Through Jentic you install once, import Get a Newsletter from the API Directory, store the token once, and your agent calls it.
- **Permission scoping:** Get a Newsletter puts the list hash in the URL path (`/lists/{hash}/subscribers`/), so a rule can pin your agent to one list: it can add subscribers to that list and nothing else. You choose the operations it may call, so destructive ones like removing a subscriber are not included unless you add them.
- **Credential handling:** Your Get a Newsletter token is stored once, encrypted, by your own Jentic One instance and injected into the Authorization header at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'add a subscriber to a mailing list' or 'pull a campaign report', and Jentic returns the matching Get a Newsletter operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Mailchimp** — Established email marketing platform with broad audience and automation features.
- **Brevo** — Email marketing and transactional platform (formerly Sendinblue) with EU hosting.
- **ConvertKit** — Creator-focused email platform with tag-based segmentation.
- **Klaviyo** — E-commerce marketing platform paired with newsletter tools when product behaviour drives sends.

## FAQ

### Why is there no official OpenAPI spec for Get a Newsletter API?

Get a Newsletter does not publish an OpenAPI specification. Jentic generates and maintains this spec so that AI agents and developers can call Get a Newsletter 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 Get a Newsletter API use?

The API uses an API token in the `Authorization` header (`tokenAuth` scheme). Through Jentic, the token is stored encrypted in the vault and injected at execution time, so agents never see the raw value.

### Can I upsert a contact by email with the Get a Newsletter API?

Yes. Use `PUT `/contacts/{email}`/` to update or create a contact in a single call, which is the safe pattern for idempotent CRM sync.

### Can I add a subscriber to a specific mailing list?

Yes. Call `POST `/lists/{hash}/subscribers`/` with the email to add a contact to the list identified by `{hash}`. Use `DELETE `/lists/{hash}/subscribers/{email}`/` to remove.

### How do I retrieve a campaign report through Jentic?

Search Jentic for `get a newsletter campaign report`, load the schema for `GET `/reports/{id}`/`, and execute with the report ID. Jentic injects the API token from the vault.

### Does the Get a Newsletter API send transactional emails?

No. The API focuses on newsletter campaigns and list management. For transactional email (password resets, receipts), use a dedicated transactional service alongside Get a Newsletter.

### Can I limit what my agent is allowed to do with the Get a Newsletter API?

Yes. Because you run Jentic One yourself, your own rules decide which Get a Newsletter operations and credentials your agent may use. Since the mailing list hash sits in the URL path (POST `/lists/{hash}/subscribers`/), you can pin the agent to a single list so it only adds subscribers there and nowhere else. You also choose the exact operations it may call, so destructive ones like DELETE `/lists/{hash}/subscribers/{email}`/ stay out of reach unless you explicitly grant them.