Back to the blog

Email API for developers – send transactional email with Make Sender

Table of contents

No headings found on page

In short: Make Sender API is a REST API for transactional email. You send JSON over HTTPS to https://api.makesender.no/api/v1/ and authenticate using Basic Auth. You can use templates from Make, merge data per recipient, attach files, manage lists, contacts, and suppression lists, and receive events such as delivered, opened, and bounced back via signed webhooks. The service offers Norwegian support, is operated in Norway, and data is stored in Oslo.

Order confirmations, password links, login codes, and alerts must arrive, and they must arrive now. With Make Sender API, you send them directly from your code, without operating your own email server, building IP reputation, or handling bounces and blocklists yourself.

Here you will find an overview of the API's capabilities, its structure, and what you need to set up before your first call.

Why use an email API?

Sending email is easy. Getting it delivered to the inbox is more difficult. A new server with no history is easily suspected of spam, and large volumes require queuing, retries, and handling of bounces and spam complaints. With Make Sender API, Make handles delivery, providing you with a simple interface to send against.

You integrate, the marketing department owns the content

Templates are created in the Make editor. You only send the template name and the data to be merged. If the marketing department wants to change the text or design of the order confirmation, they do it themselves in Make, without you having to deploy anything.

How the API is structured

REST and JSON. All requests and responses are JSON (Content-Type: application/json). The exception is attachments, which are sent as multipart/form-data.
Basic Auth. The username is your API username, and the password is the API key. You create both in your account settings.
Common address. All endpoints are located under https://api.makesender.no/api/v1/.
Five sections: Messages, contact lists, contacts, suppression lists, and webhooks.

Endpoints

Messages

Endpoint	Function
`POST /{domain}/messages`	Sends an email. Returns `201 Created` once the message has been received and queued.

Key parameters:

Parameter	Usage
`from`, `to`	Required. Supports display names. Separate multiple recipients with commas; duplicates are removed automatically. The `from` address must belong to a verified domain.
`subject`, `text`, `html`	The content of the email. You can omit `subject` if the template has a predefined subject.
`template`	The name of a template in Make. `html`, `text`, and `subject` override the template if sent with the request.
`t:variables`	Template variables. JSON containing data to be merged into the template.
`recipient-variables`	JSON with specific data per recipient, for batch sending with personalized content.
`v:{name}`	Custom data attached to the message.
`o:tracking`, `o:tracking-opens`, `o:tracking-clicks`	Enables or disables tracking for this specific message.
`reply_to`	Reply-to address.
`attachment`, `inline`	Attachments and inline images for the HTML. Maximum of 10 files and 18 MB in total.

Templates support the Liquid template language, allowing you to use conditionals and loops, rather than just basic placeholders like {{ name }}.
You can merge recipient-variables into the template-variables.

All parameters are sent within the request itself. Prefixes indicate the field's function: t: for template data, v: for custom variables, and o: for settings. If you send via SMTP instead, you set these details as X-Make-headers.

Contact lists

Endpoint	Function
`GET /lists`	Retrieves all lists.
`GET /lists/{id}`	Retrieves a single list using its ID or alias.
`POST /lists`	Creates a list.
`PUT /lists/{id}`	Updates a list.
`DELETE /lists/{id}`	Deletes a list and all associated contacts.

Each list has an alias address. If you send to this alias, each contact on the list receives their own copy.

Contacts

Endpoint	Function
`GET /lists/{list}/recipients`	Retrieves contacts from a list.
`GET /lists/{list}/recipients/{email}`	Retrieves a single contact.
`POST /lists/{list}/recipients`	Adds one or multiple contacts in a single call.
`POST /lists/{list}/recipients/import`	Bulk import from CSV, XLS, XLSX, or JSON as a file or raw body, max 5 MB.
`PUT /lists/{list}/recipients/{email}`	Updates custom fields on a contact.
`DELETE /lists/{list}/recipients/{email}`	Removes a contact from the list.

Each contact can have personalized fields in custom_fields, such as name and company, which are merged into the templates.

Suppression list

The suppression list applies account-wide across all lists. Make never sends to addresses on this list. Each entry has a statuscode: bounce, complaint, or unsubscribe.

Endpoint	Function
`GET /suppressions`	Retrieves the entire suppression list.
`GET /suppressions/{email}`	Checks a single address.
`POST /suppressions`	Adds one or multiple addresses in a single call.
`POST /suppressions/import`	Bulk import from CSV, XLS, XLSX, or JSON, max 5 MB. Useful when importing a suppression list from a previous provider.
`DELETE /suppressions/{email}`	Removes an address from the suppression list.

Webhooks

Webhooks are configured under Settings → Webhooks in Make, not via the API. You can set up to 16 endpoints. Each endpoint must use HTTPS and can apply to all domains or just one.

Event	Trigger
`accepted`	The message has been received and queued.
`delivered`	Delivered to the recipient's email server.
`permanent_fail`	Hard bounce.
`temporary_fail`	Soft bounce. Make automatically retries delivery.
`opened`	Opened. Requires open tracking.
`clicked`	Clicked. Requires click tracking.
`complained`	Marked as spam (feedback loop).

Format: POST with JSON containing two parts: signature and event-data.

Signing: HMAC-SHA256 of timestamp and token, using the signing key from your settings. Reject old timestamps and tokens you have previously processed.
Correlation: The job-id in the payload matches the X-Job-ID header, allowing you to link the event with your own system data.
Retries: Respond with a 2xx status code within 10 seconds. Failed deliveries are retried up to 6 times. The endpoint is disabled after 25 consecutive failures.
Idempotency: The same event may be received multiple times and out of order. Deduplicate using id and sort by timestamp.
Testing: The "Send test notification" button sends sample webhooks containing the header X-Webhook-Test: true.

Limits and error handling

Topic	Value
Rate limit	200 requests per minute per API key. Returns `429` when the limit is reached. Use exponential backoff.
Pagination	`page` and `per`, maximum of 100 per page.
Attachments	Maximum of 10 files and 18 MB in total per message.
Import	Maximum of 5 MB per request.
`401`	Invalid username or API key.
`422`	Validation error, such as an unverified domain or excessively large attachments.

Getting started

Get access. The Make Sender API is available to all paying customers. Choose a subscription based on your monthly volume.
Create a subdomain. For example, send.example.com. Never configure DNS records on your root domain, as the MX record will disrupt your regular email flow.
Add the DNS records from the table below, then click "Verify" in Make.
Create an API key in your account settings. Store it in an environment variable or secret manager; never expose it in client-side code or repositories.
Set up webhooks under Settings → Webhooks if you need delivery status updates in your own system.
Send your first message using POST /{domain}/messages, and verify that you receive a 201 Created status.

DNS records for the subdomain

Record	Name	Value
SPF (TXT)	`send.example.com`	`v=spf1 mx include:_spf.makesender.no ~all`
DKIM	`make1._domainkey.send.example.com`	Unique value per domain, retrieved in Make
MX	`send.example.com`	`10 mxa.makesender.no.`

The MX record ensures that bounce messages return to Make, keeping your suppression list updated.

API or SMTP?

If you simply need to point an existing system to an SMTP server, Make Sender SMTP is quicker to set up. The API offers broader functionality: code-controlled lists, contacts, suppression lists, flexible batch sending, and structured responses. Both options route through the same delivery engine.

Delivery and operations

Established reputation. Make sends from IP addresses with strong history and from Norwegian servers well-regarded by ISPs.
Monitoring. Delivery rates, blocklists, and feedback loops are continuously monitored.
Automated suppression list. Hard bounces and spam complaints are added automatically without manual effort.
Dedicated IP. High-volume senders can obtain a dedicated IP address to build their own sender reputation.
Logs. View status, error codes, and SMTP responses for each message directly in Make.

Privacy and data storage

Make is a Norwegian company that stores customer data on servers in Oslo, avoiding US-based cloud providers. Make acts as the data processor. The sender is responsible for ensuring the legal basis for contacting recipients.

Support

Access support in Norwegian from specialists who understand both email delivery and the API, rather than chatbots or outsourced ticket systems.

Areas we assist with

DNS setup. Make helps you configure subdomains, SPF, DKIM, and MX correctly, ensuring domain verification is completed.
Technical advice. Receive guidance on integration, batch sending, webhooks, and the optimal use of templates and lists.
Troubleshooting. If an email fails to deliver, support will review status codes, error codes, and SMTP responses with you.
Developer communication. Support can coordinate directly with your development team when required.

Need assistance or have questions?

Phone: +47 21 64 00 10
Email: support@make.as
Chat: within Make
Help center: support.make.as
System status: status.make.as.

Frequently asked questions

How do I authenticate with the Make Sender API?
→ Using HTTP Basic Auth. The username is your API username, and the password is your API key. Both are generated in your Make account settings.

What format does the API use?
→ JSON over HTTPS. The exception is messages with attachments, which must be sent as multipart/form-data.

What is the rate limit for the Make Sender API?
→ 200 requests per minute per API key. Exceeding this returns a 429 Too Many Requests status.

Can I use templates from Make when sending via the API?
→ Yes. Provide the template name in the template parameter and variables in t:variables. Templates support Liquid, allowing conditionals and loops.

How do I send the same email to multiple recipients with personalized content?
→ Pass multiple addresses in the to field, and include individual recipient data in recipient-variables. Alternatively, you can send to a list where contacts have custom fields.

How do I feed delivery statuses back into my own system?
→ Configure webhooks under Settings → Webhooks in Make to receive events like delivered, permanent_fail, opened, clicked, and complained.

How do I verify that a webhook is sent by Make?
→ Each payload is signed with an HMAC-SHA256 signature generated from the timestamp and token, using your signing key. Compare this with the signature field and reject outdated timestamps.

Can I import a suppression list from another provider?
→ Yes. Use POST /suppressions/import with a CSV, Excel, or JSON file up to 5 MB.

Where is data stored?
→ On servers located in Oslo. Make is a Norwegian company and does not use US cloud providers.

Is Make Sender an alternative to Mailgun, SendGrid, and Postmark?
→ Yes. Make Sender addresses the same transactional email requirements, combined with Norwegian data storage and support.

Resources

Set up and verify a sending domain

Looking for an SMTP server? Learn more here.

Get started with a 30-day trial

Try Make for free

Questions? Contact us