# Domains API

> Add sending domains, read their DNS records and verification status, and verify them.

Base URL: `https://api.emailit.com/v2`. Authenticate with `Authorization: Bearer <API key>`.

## Create a domain — POST /domains

> Add a sending domain to the workspace and get the SPF, DKIM, return-path, DMARC, tracking and inbound DNS records to publish before you verify it.

# Create a domain

Adds a sending domain and returns the DNS records to publish for it.

`POST /domains`

Requires a `full` API key. Emailit generates a 2048-bit DKIM key for the domain. Publish the records in `dns_records` at your DNS provider, then call [Verify a domain](/docs/api-reference/domains/verify/). You can send from the domain once it's verified. See [Add a domain](/docs/domains/add-a-domain/) and [DNS records](/docs/domains/dns-records/).

The number of domains depends on your plan: 3 on Pay as you go (25 after your first credit purchase), 100 on Pro and 1,000 on Business. Fires a `domain.created` event.

## Body parameters

- `name` (string, required): The domain to send from, such as `acme.com` or `mail.acme.com`, without `http://`, `https://` or `www.`. Stored in lowercase. Your `from` addresses must use exactly this domain.

- `tracking_key` (string): The subdomain label for the open and click tracking CNAME. Defaults to `go`, which gives `go.acme.com`. Letters, digits and hyphens.

- `inbound_key` (string): The subdomain label for receiving email. Defaults to `inbound`, which gives `inbound.acme.com`. Letters, digits and hyphens.

- `dmarc_reports` (boolean): Collect DMARC reports for the domain. Emailit creates a reporting address and adds it to the suggested DMARC record. Available on Pro, Business and Custom plans. See [DMARC](/docs/dmarc/).

- `track_loads` (boolean): Must be `false` when you create a domain. Turn tracking on with [Update a domain](/docs/api-reference/domains/update/) once the tracking CNAME is verified.

- `track_clicks` (boolean): Same as `track_loads`, for click tracking.

The older `outgoing`, `incoming` and `use_for_any` flags are accepted for compatibility and have no effect.

## Returns

Returns `201` with the [domain object](/docs/api-reference/domains/get/), including `dns_records`. A new domain has the status `pending`, or `pending_review` on Pay as you go until its first DNS check.

**Request** `POST /domains`

**Node.js**

```javascript
import { Emailit } from '@emailit/node';
const emailit = new Emailit('your_api_key');

const domain = await emailit.domains.create({ name: 'acme.com' });
```

**Python**

```python
from emailit import EmailitClient
client = EmailitClient("your_api_key")

domain = client.domains.create({"name": "acme.com"})
```

**PHP**

```php
$emailit = Emailit::client('your_api_key');

$domain = $emailit->domains()->create(['name' => 'acme.com']);
```

**Ruby**

```ruby
require "emailit"
client = Emailit::EmailitClient.new("your_api_key")

domain = client.domains.create(name: "acme.com")
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"

client := emailit.NewClient("your_api_key")

domain, err := client.Domains.Create(&emailit.CreateDomainRequest{Name: "acme.com"})
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

let domain = emailit.domains.create(emailit::types::CreateDomainParams::new("acme.com")).await?;
```

**Java**

```java
import com.emailit.*;
import com.emailit.params.*;

EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject domain = emailit.domains().create(DomainCreateParams.builder().setName("acme.com").build());
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var domain = emailit.Domains.Create(new DomainCreateOptions { Name = "acme.com" });
```

**Laravel**

```php
use Emailit\Laravel\Facades\Emailit;

$domain = Emailit::domains()->create(['name' => 'acme.com']);
```

**cURL**

```bash
curl https://api.emailit.com/v2/domains \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": "acme.com"}'
```

**cURL**

```bash
curl https://api.emailit.com/v2/domains \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "acme.com",
    "tracking_key": "links",
    "inbound_key": "reply",
    "dmarc_reports": true
  }'
```

**201**

```json
{
  "object": "domain",
  "id": "dom_4K468YrjOkR1wwdhqiO0G9XEUey",
  "name": "acme.com",
  "verification_token": "vt_4KY8weirBN9sxnfbIt78tsFWteY",
  "verification_method": "dns",
  "verified_at": null,
  "manually_verified_at": null,
  "manual_review_required": false,
  "verification_status": "pending",
  "dkim_identifier_string": "emailit",
  "dns_checked_at": null,
  "spf_status": "pending",
  "spf_error": null,
  "dkim_status": "pending",
  "dkim_error": null,
  "mx_status": "pending",
  "mx_error": null,
  "return_path_status": "pending",
  "return_path_error": null,
  "dmarc_status": "pending",
  "dmarc_error": null,
  "tracking_status": "pending",
  "tracking_error": null,
  "tracking_key": null,
  "inbound_status": "pending",
  "inbound_error": null,
  "inbound_key": null,
  "track_loads": 0,
  "track_clicks": 0,
  "dmarc_reports": false,
  "dmarc_address": null,
  "created_at": "2026-10-01T09:12:03.551208Z",
  "updated_at": "2026-10-01T09:12:03.551208Z",
  "dns_records": [
    {
      "required": true,
      "type": "MX",
      "name": "emailit.acme.com",
      "value": "feedback-smtp.ffdc-1.emailit.com",
      "priority": 10,
      "ttl": "auto",
      "status": "pending",
      "error": null
    },
    {
      "required": true,
      "type": "TXT",
      "name": "emailit.acme.com",
      "value": "v=spf1 include:_spf.emailit.com ~all",
      "priority": null,
      "ttl": "auto",
      "status": "pending",
      "error": null
    },
    {
      "required": true,
      "type": "TXT",
      "name": "emailit._domainkey.acme.com",
      "value": "v=DKIM1; t=s; h=sha256; p=MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAx3kQ...IDAQAB;",
      "priority": null,
      "ttl": "auto",
      "status": "pending",
      "error": null
    },
    {
      "required": false,
      "type": "TXT",
      "name": "_dmarc.acme.com",
      "value": "v=DMARC1; p=none;",
      "priority": null,
      "ttl": "auto",
      "status": "pending",
      "error": null
    },
    {
      "required": false,
      "type": "CNAME",
      "name": "go.acme.com",
      "value": "go.emailitmail.com",
      "priority": null,
      "ttl": "auto",
      "status": "pending",
      "error": null
    },
    {
      "required": false,
      "type": "MX",
      "name": "inbound.acme.com",
      "value": "inbound.emailitmail.com",
      "priority": 10,
      "ttl": "auto",
      "status": "pending",
      "error": null
    }
  ]
}
```

**400**

```json
{
  "error": "The domain must be in apex format (e.g., domain.com) without http://, https://, or www."
}
```

**403**

```json
{
  "error": "plan_required",
  "required_plan": "pro"
}
```

**409**

```json
{
  "error": "Domain with this name already exists",
  "existing": {
    "object": "domain",
    "id": "dom_4K468YrjOkR1wwdhqiO0G9XEUey",
    "name": "acme.com"
  }
}
```

**422 Limit**

```json
{
  "error": "Pay as you go includes 3 domain(s)."
}
```

**422 Tracking**

```json
{
  "error": "Tracking requires a verified custom CNAME. New messages are not rewritten to a shared tracking URL."
}
```

---
Source: https://emailit.com/docs/api-reference/domains/create/

## Retrieve a domain — GET /domains/{id}

> Retrieve a sending domain by ID or name with its verification status, the status of each DNS record and the records to publish.

# Retrieve a domain

Retrieves a sending domain with its verification status and DNS records.

`GET /domains/{id}`

Requires a `full` API key. Record statuses reflect the last DNS check, which runs when you call [Verify a domain](/docs/api-reference/domains/verify/) and once a day automatically.

## Path parameters

- `id` (string, required): The domain ID (`dom_…`, or `sd_…` and `sed_…` for older domains) or the domain name, such as `acme.com`.

## Returns

Returns the domain object.

- `object` (string): Always `domain`.

- `id` (string): The domain ID.

- `name` (string): The domain name.

- `verification_status` (string): `verified` when the domain can send. `pending` while SPF, DKIM or the return path isn't correct yet. `pending_review` on Pay as you go when the domain needs a manual review by Emailit before it can be verified, for example because it was registered less than 30 days ago.

- `verified_at` (string | null): When the last DNS check passed, or `null` if the domain isn't verified. A failed check clears it.

- `manual_review_required` (boolean): Whether the domain is waiting for Emailit's manual review.

- `manually_verified_at` (string | null): When Emailit approved the domain manually, or `null`.

- `dns_checked_at` (string | null): When the DNS records were last checked.

- `spf_status, dkim_status, return_path_status` (string): Status of the three required records: `pending` (not checked yet), `ok`, `missing` or `invalid`. All three must be `ok` for the domain to be verified.

- `mx_status` (string): Same as `return_path_status`.

- `dmarc_status` (string): Status of the DMARC record: `pending`, `ok`, `missing`, `invalid` or `error`. Optional for verification.

- `tracking_status` (string): Status of the tracking CNAME. Must be `ok` before you can turn on tracking.

- `inbound_status` (string): Status of the inbound MX record. Needed to [receive email](/docs/inbound/) on the domain.

- `spf_error, dkim_error, mx_error, return_path_error, dmarc_error, tracking_error, inbound_error` (string | null): What's wrong with each record after a failed check, or `null`.

- `tracking_key` (string | null): The tracking subdomain label, or `null` for the default `go`.

- `inbound_key` (string | null): The inbound subdomain label, or `null` for the default `inbound`.

- `track_loads` (integer): `1` if open tracking is on by default for emails from this domain, `0` if not.

- `track_clicks` (integer): `1` if click tracking is on by default, `0` if not.

- `dmarc_reports` (boolean): Whether Emailit collects DMARC reports for the domain.

- `dmarc_address` (string | null): The address that receives DMARC reports, or `null` when `dmarc_reports` is off.

- `verification_token, verification_method, dkim_identifier_string` (string): Internal verification details. `verification_method` is `dns` and `dkim_identifier_string` is the DKIM selector, `emailit`.

- `created_at, updated_at` (string): When the domain was added and last changed.

- `dns_records` (object[]): The records to publish. Each has `type` (`MX`, `TXT` or `CNAME`), `name`, `value`, `priority` (for MX records), `ttl` (`auto`), `required` (whether it's needed for verification), and its current `status` and `error`.

| Record | Type | Name | Value | Required |
| --- | --- | --- | --- | --- |
| Return path | MX | `emailit.acme.com` | `feedback-smtp.ffdc-1.emailit.com`, priority 10 | Yes |
| SPF | TXT | `emailit.acme.com` | `v=spf1 include:_spf.emailit.com ~all` | Yes |
| DKIM | TXT | `emailit._domainkey.acme.com` | `v=DKIM1; t=s; h=sha256; p=…` | Yes |
| DMARC | TXT | `_dmarc.acme.com` | `v=DMARC1; p=none;`, plus report addresses when `dmarc_reports` is on | No |
| Tracking | CNAME | `go.acme.com` | `go.emailitmail.com` | No |
| Inbound | MX | `inbound.acme.com` | `inbound.emailitmail.com`, priority 10 | No |

**Request** `GET /domains/{id}`

**Node.js**

```javascript
import { Emailit } from '@emailit/node';
const emailit = new Emailit('your_api_key');

const domain = await emailit.domains.get('dom_4K468YrjOkR1wwdhqiO0G9XEUey');
```

**Python**

```python
from emailit import EmailitClient
client = EmailitClient("your_api_key")

domain = client.domains.get("dom_4K468YrjOkR1wwdhqiO0G9XEUey")
```

**PHP**

```php
$emailit = Emailit::client('your_api_key');

$domain = $emailit->domains()->get('dom_4K468YrjOkR1wwdhqiO0G9XEUey');
```

**Ruby**

```ruby
require "emailit"
client = Emailit::EmailitClient.new("your_api_key")

domain = client.domains.get("dom_4K468YrjOkR1wwdhqiO0G9XEUey")
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

domain, err := client.Domains.Get("dom_4K468YrjOkR1wwdhqiO0G9XEUey")
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

let domain = emailit.domains.get("dom_4K468YrjOkR1wwdhqiO0G9XEUey").await?;
```

**Java**

```java
import com.emailit.*;
import com.emailit.params.*;

EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject domain = emailit.domains().get("dom_4K468YrjOkR1wwdhqiO0G9XEUey");
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var domain = emailit.Domains.Get("dom_4K468YrjOkR1wwdhqiO0G9XEUey");
```

**Laravel**

```php
use Emailit\Laravel\Facades\Emailit;

$domain = Emailit::domains()->get('dom_4K468YrjOkR1wwdhqiO0G9XEUey');
```

**cURL**

```bash
curl https://api.emailit.com/v2/domains/dom_4K468YrjOkR1wwdhqiO0G9XEUey \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**200**

```json
{
  "object": "domain",
  "id": "dom_4K468YrjOkR1wwdhqiO0G9XEUey",
  "name": "acme.com",
  "verification_token": "vt_4KY8weirBN9sxnfbIt78tsFWteY",
  "verification_method": "dns",
  "verified_at": "2026-10-01T03:00:12.000000Z",
  "manually_verified_at": null,
  "manual_review_required": false,
  "verification_status": "verified",
  "dkim_identifier_string": "emailit",
  "dns_checked_at": "2026-10-01T03:00:12.000000Z",
  "spf_status": "ok",
  "spf_error": null,
  "dkim_status": "ok",
  "dkim_error": null,
  "mx_status": "ok",
  "mx_error": null,
  "return_path_status": "ok",
  "return_path_error": null,
  "dmarc_status": "ok",
  "dmarc_error": null,
  "tracking_status": "ok",
  "tracking_error": null,
  "tracking_key": null,
  "inbound_status": "invalid",
  "inbound_error": "queryMx ENOTFOUND inbound.acme.com",
  "inbound_key": null,
  "track_loads": 1,
  "track_clicks": 1,
  "dmarc_reports": true,
  "dmarc_address": "4KXUJdXRVlVgbkWQm4GHLy8BleP@dmarc.emailitmail.com",
  "created_at": "2026-09-14T08:02:51.000000Z",
  "updated_at": "2026-10-01T03:00:12.000000Z",
  "dns_records": [
    {
      "required": true,
      "type": "MX",
      "name": "emailit.acme.com",
      "value": "feedback-smtp.ffdc-1.emailit.com",
      "priority": 10,
      "ttl": "auto",
      "status": "ok",
      "error": null
    },
    {
      "required": true,
      "type": "TXT",
      "name": "emailit.acme.com",
      "value": "v=spf1 include:_spf.emailit.com ~all",
      "priority": null,
      "ttl": "auto",
      "status": "ok",
      "error": null
    },
    {
      "required": true,
      "type": "TXT",
      "name": "emailit._domainkey.acme.com",
      "value": "v=DKIM1; t=s; h=sha256; p=MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAx3kQ...IDAQAB;",
      "priority": null,
      "ttl": "auto",
      "status": "ok",
      "error": null
    },
    {
      "required": false,
      "type": "TXT",
      "name": "_dmarc.acme.com",
      "value": "v=DMARC1; p=none; rua=mailto:4KXUJdXRVlVgbkWQm4GHLy8BleP@dmarc.emailitmail.com; ruf=mailto:4KXUJdXRVlVgbkWQm4GHLy8BleP@dmarc.emailitmail.com;",
      "priority": null,
      "ttl": "auto",
      "status": "ok",
      "error": null
    },
    {
      "required": false,
      "type": "CNAME",
      "name": "go.acme.com",
      "value": "go.emailitmail.com",
      "priority": null,
      "ttl": "auto",
      "status": "ok",
      "error": null
    },
    {
      "required": false,
      "type": "MX",
      "name": "inbound.acme.com",
      "value": "inbound.emailitmail.com",
      "priority": 10,
      "ttl": "auto",
      "status": "invalid",
      "error": "queryMx ENOTFOUND inbound.acme.com"
    }
  ]
}
```

**404**

```json
{
  "error": "Domain not found"
}
```

---
Source: https://emailit.com/docs/api-reference/domains/get/

## Verify a domain — POST /domains/{id}/verify

> Check a sending domain's DNS records now and update its verification status. SPF, DKIM and the return path must pass before you can send.

# Verify a domain

Looks up the domain's DNS records now, saves the result and returns the domain with its new statuses.

`POST /domains/{id}/verify`

Requires a `full` API key. Call it after you publish the records from [Create a domain](/docs/api-reference/domains/create/), and again whenever you change them. DNS changes can take a while to propagate, so if a record shows `missing`, wait a few minutes and retry.

The domain becomes `verified` when all three required records are `ok`:

- **SPF:** a TXT record at `emailit.<domain>` that includes `_spf.emailit.com`.
- **DKIM:** a TXT record at `emailit._domainkey.<domain>` with the domain's public key.
- **Return path:** a single MX record at `emailit.<domain>` pointing to `feedback-smtp.ffdc-1.emailit.com`.

On Pay as you go, a domain registered less than 30 days ago gets `pending_review` instead, and Emailit reviews it manually. The DMARC, tracking and inbound records are checked too, but they don't affect verification.

Emailit also re-checks every domain once a day. If a required record stops passing, the domain is no longer verified, sends from it fail, and the workspace owner gets an email. See [Domain verification](/docs/domains/verification/).

## Path parameters

- `id` (string, required): The domain ID or the domain name.

## Returns

Returns the [domain object](/docs/api-reference/domains/get/) with the result of this check in `verification_status`, each `*_status` and `*_error` field, and `dns_records`. This response doesn't include `dmarc_reports` and `dmarc_address`; read them with [Retrieve a domain](/docs/api-reference/domains/get/).

**Request** `POST /domains/{id}/verify`

**Node.js**

```javascript
import { Emailit } from '@emailit/node';
const emailit = new Emailit('your_api_key');

const domain = await emailit.domains.verify('dom_4K468YrjOkR1wwdhqiO0G9XEUey');
```

**Python**

```python
from emailit import EmailitClient
client = EmailitClient("your_api_key")

domain = client.domains.verify("dom_4K468YrjOkR1wwdhqiO0G9XEUey")
```

**PHP**

```php
$emailit = Emailit::client('your_api_key');

$domain = $emailit->domains()->verify('dom_4K468YrjOkR1wwdhqiO0G9XEUey');
```

**Ruby**

```ruby
require "emailit"
client = Emailit::EmailitClient.new("your_api_key")

domain = client.domains.verify("dom_4K468YrjOkR1wwdhqiO0G9XEUey")
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

domain, err := client.Domains.Verify("dom_4K468YrjOkR1wwdhqiO0G9XEUey")
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

let domain = emailit.domains.verify("dom_4K468YrjOkR1wwdhqiO0G9XEUey").await?;
```

**Java**

```java
import com.emailit.*;
import com.emailit.params.*;

EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject domain = emailit.domains().verify("dom_4K468YrjOkR1wwdhqiO0G9XEUey");
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var domain = emailit.Domains.Verify("dom_4K468YrjOkR1wwdhqiO0G9XEUey");
```

**Laravel**

```php
use Emailit\Laravel\Facades\Emailit;

$domain = Emailit::domains()->verify('dom_4K468YrjOkR1wwdhqiO0G9XEUey');
```

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/domains/dom_4K468YrjOkR1wwdhqiO0G9XEUey/verify \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**200 Pending**

```json
{
  "object": "domain",
  "id": "dom_4K468YrjOkR1wwdhqiO0G9XEUey",
  "name": "acme.com",
  "verification_token": "vt_4KY8weirBN9sxnfbIt78tsFWteY",
  "verification_method": "dns",
  "verified_at": null,
  "manually_verified_at": null,
  "manual_review_required": false,
  "dkim_identifier_string": "emailit",
  "dns_checked_at": "2026-10-01T09:20:41.000000Z",
  "spf_status": "ok",
  "spf_error": null,
  "dkim_status": "missing",
  "dkim_error": "queryTxt ENOTFOUND emailit._domainkey.acme.com",
  "mx_status": "ok",
  "mx_error": null,
  "return_path_status": "ok",
  "return_path_error": null,
  "dmarc_status": "error",
  "dmarc_error": "queryTxt ENOTFOUND _dmarc.acme.com",
  "tracking_status": "invalid",
  "tracking_error": "queryCname ENOTFOUND go.acme.com",
  "tracking_key": null,
  "inbound_status": "invalid",
  "inbound_error": "queryMx ENOTFOUND inbound.acme.com",
  "inbound_key": null,
  "track_loads": 0,
  "track_clicks": 0,
  "created_at": "2026-10-01T09:12:03.000000Z",
  "updated_at": "2026-10-01T09:20:41.000000Z",
  "dns_records": [
    {
      "required": true,
      "type": "MX",
      "name": "emailit.acme.com",
      "value": "feedback-smtp.ffdc-1.emailit.com",
      "priority": 10,
      "ttl": "auto",
      "status": "ok",
      "error": null
    },
    {
      "required": true,
      "type": "TXT",
      "name": "emailit.acme.com",
      "value": "v=spf1 include:_spf.emailit.com ~all",
      "priority": null,
      "ttl": "auto",
      "status": "ok",
      "error": null
    },
    {
      "required": true,
      "type": "TXT",
      "name": "emailit._domainkey.acme.com",
      "value": "v=DKIM1; t=s; h=sha256; p=MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAx3kQ...IDAQAB;",
      "priority": null,
      "ttl": "auto",
      "status": "missing",
      "error": "queryTxt ENOTFOUND emailit._domainkey.acme.com"
    },
    {
      "required": false,
      "type": "TXT",
      "name": "_dmarc.acme.com",
      "value": "v=DMARC1; p=none;",
      "priority": null,
      "ttl": "auto",
      "status": "error",
      "error": "queryTxt ENOTFOUND _dmarc.acme.com"
    },
    {
      "required": false,
      "type": "CNAME",
      "name": "go.acme.com",
      "value": "go.emailitmail.com",
      "priority": null,
      "ttl": "auto",
      "status": "invalid",
      "error": "queryCname ENOTFOUND go.acme.com"
    },
    {
      "required": false,
      "type": "MX",
      "name": "inbound.acme.com",
      "value": "inbound.emailitmail.com",
      "priority": 10,
      "ttl": "auto",
      "status": "invalid",
      "error": "queryMx ENOTFOUND inbound.acme.com"
    }
  ],
  "verification_status": "pending"
}
```

**404**

```json
{
  "error": "Domain not found"
}
```

---
Source: https://emailit.com/docs/api-reference/domains/verify/

## Update a domain — POST /domains/{id}

> Turn open and click tracking on or off, change the tracking and inbound subdomains, or enable DMARC reports for a sending domain.

# Update a domain

Updates the settings of a sending domain. Only the fields you send change.

`POST /domains/{id}`

Requires a `full` API key. Fires a `domain.updated` event.

## Path parameters

- `id` (string, required): The domain ID or the domain name.

## Body parameters

- `track_loads` (boolean): Turn open tracking on or off by default for emails from this domain. Turning it on requires a verified tracking CNAME (`tracking_status` is `ok`). See [Custom tracking domain](/docs/tracking/custom-tracking-domain/).

- `track_clicks` (boolean): Turn click tracking on or off by default. Same requirement as `track_loads`.

- `tracking_key` (string | null): A new subdomain label for the tracking CNAME, or `null` for the default `go`. Changing it resets `tracking_status` to `pending`, so publish the new CNAME and [verify](/docs/api-reference/domains/verify/) again.

- `inbound_key` (string | null): A new subdomain label for receiving email, or `null` for the default `inbound`. Changing it resets `inbound_status` to `pending`.

- `dmarc_reports` (boolean): Collect DMARC reports for the domain. Turning it on adds a reporting address to the suggested DMARC record, so update your `_dmarc` record afterward. Pro, Business and Custom plans only. Turning it off keeps the address for later.

- `name` (string): A new domain name. The DNS records move to the new name, so publish them there and verify again before you send from it.

The older `outgoing`, `incoming` and `use_for_any` flags are accepted and have no effect. Unknown fields are ignored. A request without any of these fields returns `400`.

## Returns

Returns the updated [domain object](/docs/api-reference/domains/get/), including `dns_records`.

**Request** `POST /domains/{id}`

**Node.js**

```javascript
import { Emailit } from '@emailit/node';
const emailit = new Emailit('your_api_key');

const domain = await emailit.domains.update('dom_4K468YrjOkR1wwdhqiO0G9XEUey', { track_clicks: false });
```

**Python**

```python
from emailit import EmailitClient
client = EmailitClient("your_api_key")

domain = client.domains.update("dom_4K468YrjOkR1wwdhqiO0G9XEUey", {"track_clicks": False})
```

**PHP**

```php
$emailit = Emailit::client('your_api_key');

$domain = $emailit->domains()->update('dom_4K468YrjOkR1wwdhqiO0G9XEUey', ['track_clicks' => false]);
```

**Ruby**

```ruby
require "emailit"
client = Emailit::EmailitClient.new("your_api_key")

domain = client.domains.update("dom_4K468YrjOkR1wwdhqiO0G9XEUey", track_clicks: false)
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

domain, err := client.Domains.Update("dom_4K468YrjOkR1wwdhqiO0G9XEUey", &emailit.UpdateDomainRequest{TrackClicks: false})
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

let domain = emailit.domains.update("dom_4K468YrjOkR1wwdhqiO0G9XEUey", emailit::types::UpdateDomainParams { track_clicks: Some(false), ..Default::default() }).await?;
```

**Java**

```java
import com.emailit.*;
import com.emailit.params.*;

EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject domain = emailit.domains().update("dom_4K468YrjOkR1wwdhqiO0G9XEUey", DomainUpdateParams.builder().setTrackClicks(false).build());
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var domain = emailit.Domains.Update("dom_4K468YrjOkR1wwdhqiO0G9XEUey", new DomainUpdateOptions { TrackClicks = false });
```

**Laravel**

```php
use Emailit\Laravel\Facades\Emailit;

$domain = Emailit::domains()->update('dom_4K468YrjOkR1wwdhqiO0G9XEUey', ['track_clicks' => false]);
```

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/domains/dom_4K468YrjOkR1wwdhqiO0G9XEUey \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"track_clicks": false}'
```

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/domains/acme.com \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"track_loads": true, "track_clicks": true}'
```

**200**

```json
{
  "object": "domain",
  "id": "dom_4K468YrjOkR1wwdhqiO0G9XEUey",
  "name": "acme.com",
  "verification_token": "vt_4KY8weirBN9sxnfbIt78tsFWteY",
  "verification_method": "dns",
  "verified_at": "2026-10-01T03:00:12.000000Z",
  "manually_verified_at": null,
  "manual_review_required": false,
  "verification_status": "verified",
  "dkim_identifier_string": "emailit",
  "dns_checked_at": "2026-10-01T03:00:12.000000Z",
  "spf_status": "ok",
  "spf_error": null,
  "dkim_status": "ok",
  "dkim_error": null,
  "mx_status": "ok",
  "mx_error": null,
  "return_path_status": "ok",
  "return_path_error": null,
  "dmarc_status": "ok",
  "dmarc_error": null,
  "tracking_status": "ok",
  "tracking_error": null,
  "tracking_key": null,
  "inbound_status": "invalid",
  "inbound_error": "queryMx ENOTFOUND inbound.acme.com",
  "inbound_key": null,
  "track_loads": 1,
  "track_clicks": 0,
  "dmarc_reports": false,
  "dmarc_address": null,
  "created_at": "2026-09-14T08:02:51.000000Z",
  "updated_at": "2026-10-01T10:44:20.000000Z",
  "dns_records": [
    {
      "required": true,
      "type": "MX",
      "name": "emailit.acme.com",
      "value": "feedback-smtp.ffdc-1.emailit.com",
      "priority": 10,
      "ttl": "auto",
      "status": "ok",
      "error": null
    },
    {
      "required": true,
      "type": "TXT",
      "name": "emailit.acme.com",
      "value": "v=spf1 include:_spf.emailit.com ~all",
      "priority": null,
      "ttl": "auto",
      "status": "ok",
      "error": null
    },
    {
      "required": true,
      "type": "TXT",
      "name": "emailit._domainkey.acme.com",
      "value": "v=DKIM1; t=s; h=sha256; p=MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAx3kQ...IDAQAB;",
      "priority": null,
      "ttl": "auto",
      "status": "ok",
      "error": null
    },
    {
      "required": false,
      "type": "TXT",
      "name": "_dmarc.acme.com",
      "value": "v=DMARC1; p=none;",
      "priority": null,
      "ttl": "auto",
      "status": "ok",
      "error": null
    },
    {
      "required": false,
      "type": "CNAME",
      "name": "go.acme.com",
      "value": "go.emailitmail.com",
      "priority": null,
      "ttl": "auto",
      "status": "ok",
      "error": null
    },
    {
      "required": false,
      "type": "MX",
      "name": "inbound.acme.com",
      "value": "inbound.emailitmail.com",
      "priority": 10,
      "ttl": "auto",
      "status": "invalid",
      "error": "queryMx ENOTFOUND inbound.acme.com"
    }
  ]
}
```

**400**

```json
{
  "error": "No valid fields provided for update. Provide at least one of: name, outgoing, incoming, use_for_any, track_loads, track_clicks, tracking_key, inbound_key, dmarc_reports"
}
```

**403**

```json
{
  "error": "plan_required",
  "required_plan": "pro"
}
```

**404**

```json
{
  "error": "Domain not found"
}
```

**409**

```json
{
  "error": "Another domain with this name already exists"
}
```

**422**

```json
{
  "error": "Tracking requires a verified custom CNAME. New messages are not rewritten to a shared tracking URL."
}
```

---
Source: https://emailit.com/docs/api-reference/domains/update/

## List domains — GET /domains

> List the sending domains of a workspace with their verification and DNS status, plus how many domains your plan allows.

# List domains

Returns a page of sending domains, newest first, with your plan's domain allowance.

`GET /domains`

Requires a `full` API key. List items don't include `dns_records`; use [Retrieve a domain](/docs/api-reference/domains/get/) for those.

## Query parameters

- `page` (integer): The page to return.

- `limit` (integer): Domains per page, from 1 to 100.

- `search` (string): Case-insensitive match on the domain name.

- `match` (string): `all` or `or`. How the filters below combine.

- `order` (string): A filter key to sort by.

- `direction` (string): `asc` or `desc`.

## Filters

Add filters as `key.condition=value`, for example `dkim_status.exact=ok`. See [Filtering](/docs/api-reference/filtering/).

| Key | Type | Values and notes |
| --- | --- | --- |
| `name` | string | |
| `created_at` | date | |
| `spf_status` | enum | `ok`, `missing`, `invalid` |
| `dkim_status` | enum | `ok`, `missing`, `invalid` |
| `return_path_status` | enum | `ok`, `missing`, `invalid` |

Every key is also a sort key.

## Returns

- `data` (object[]): The [domain objects](/docs/api-reference/domains/get/) on this page, without `dns_records`.

- `next_page_url` (string | null): Path of the next page, or `null`. See [Pagination](/docs/api-reference/pagination/).

- `previous_page_url` (string | null): Path of the previous page, or `null`.

- `domain_limit` (integer | null): How many sending domains your plan allows, or `null` for no limit.

- `domain_count` (integer): How many sending domains the workspace has, across all pages.

- `plan_name` (string | null): The name of your plan, such as `Pay as you go` or `Pro`.

**Request** `GET /domains`

**Node.js**

```javascript
import { Emailit } from '@emailit/node';
const emailit = new Emailit('your_api_key');

const domains = await emailit.domains.list();
```

**Python**

```python
from emailit import EmailitClient
client = EmailitClient("your_api_key")

domains = client.domains.list()
```

**PHP**

```php
$emailit = Emailit::client('your_api_key');

$domains = $emailit->domains()->list();
```

**Ruby**

```ruby
require "emailit"
client = Emailit::EmailitClient.new("your_api_key")

domains = client.domains.list
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

domains, err := client.Domains.List(nil)
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

let domains = emailit.domains.list(None).await?;
```

**Java**

```java
import com.emailit.*;
import com.emailit.params.*;

EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject domains = emailit.domains().list();
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var domains = emailit.Domains.List();
```

**Laravel**

```php
use Emailit\Laravel\Facades\Emailit;

$domains = Emailit::domains()->list();
```

**cURL**

```bash
curl https://api.emailit.com/v2/domains \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**cURL**

```bash
curl -G https://api.emailit.com/v2/domains \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -d dkim_status.not_exact=ok \
  -d spf_status.not_exact=ok \
  -d match=or
```

**200**

```json
{
  "data": [
    {
      "object": "domain",
      "id": "dom_4K468YrjOkR1wwdhqiO0G9XEUey",
      "name": "acme.com",
      "verification_token": "vt_4KY8weirBN9sxnfbIt78tsFWteY",
      "verification_method": "dns",
      "verified_at": "2026-10-01T03:00:12.000000Z",
      "manually_verified_at": null,
      "manual_review_required": false,
      "verification_status": "verified",
      "dkim_identifier_string": "emailit",
      "dns_checked_at": "2026-10-01T03:00:12.000000Z",
      "spf_status": "ok",
      "spf_error": null,
      "dkim_status": "ok",
      "dkim_error": null,
      "mx_status": "ok",
      "mx_error": null,
      "return_path_status": "ok",
      "return_path_error": null,
      "dmarc_status": "ok",
      "dmarc_error": null,
      "tracking_status": "ok",
      "tracking_error": null,
      "tracking_key": null,
      "inbound_status": "invalid",
      "inbound_error": "queryMx ENOTFOUND inbound.acme.com",
      "inbound_key": null,
      "track_loads": 1,
      "track_clicks": 1,
      "dmarc_reports": true,
      "dmarc_address": "4KXUJdXRVlVgbkWQm4GHLy8BleP@dmarc.emailitmail.com",
      "created_at": "2026-09-14T08:02:51.000000Z",
      "updated_at": "2026-10-01T03:00:12.000000Z"
    }
  ],
  "next_page_url": null,
  "previous_page_url": null,
  "domain_limit": 100,
  "domain_count": 1,
  "plan_name": "Pro"
}
```

---
Source: https://emailit.com/docs/api-reference/domains/list/

## Delete a domain — DELETE /domains/{id}

> Permanently delete a sending domain from the workspace. You can no longer send from it, and the delete can't be undone.

# Delete a domain

Permanently deletes a sending domain.

`DELETE /domains/{id}`

Requires a `full` API key. After the delete, sends from the domain fail with `Domain not verified`, and API keys restricted to the domain can't send anymore. The domain's DKIM key, sending health history and any stored Cloudflare connection are removed too. Emails already sent stay in your logs. Fires a `domain.deleted` event.

To send from the domain again, [create it](/docs/api-reference/domains/create/) again. It gets a new DKIM key, so you'll need to update the DKIM record.

## Path parameters

- `id` (string, required): The domain ID or the domain name.

## Returns

- `object` (string): Always `domain`.

- `id` (string): The ID of the deleted domain.

- `name` (string): The domain name.

- `deleted` (boolean): Always `true`.

**Request** `DELETE /domains/{id}`

**Node.js**

```javascript
import { Emailit } from '@emailit/node';
const emailit = new Emailit('your_api_key');

await emailit.domains.delete('dom_4K468YrjOkR1wwdhqiO0G9XEUey');
```

**Python**

```python
from emailit import EmailitClient
client = EmailitClient("your_api_key")

client.domains.delete("dom_4K468YrjOkR1wwdhqiO0G9XEUey")
```

**PHP**

```php
$emailit = Emailit::client('your_api_key');

$emailit->domains()->delete('dom_4K468YrjOkR1wwdhqiO0G9XEUey');
```

**Ruby**

```ruby
require "emailit"
client = Emailit::EmailitClient.new("your_api_key")

client.domains.delete("dom_4K468YrjOkR1wwdhqiO0G9XEUey")
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

err := client.Domains.Delete("dom_4K468YrjOkR1wwdhqiO0G9XEUey")
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

emailit.domains.delete("dom_4K468YrjOkR1wwdhqiO0G9XEUey").await?;
```

**Java**

```java
import com.emailit.*;
import com.emailit.params.*;

EmailitClient emailit = new EmailitClient("your_api_key");

emailit.domains().delete("dom_4K468YrjOkR1wwdhqiO0G9XEUey");
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

emailit.Domains.Delete("dom_4K468YrjOkR1wwdhqiO0G9XEUey");
```

**Laravel**

```php
use Emailit\Laravel\Facades\Emailit;

Emailit::domains()->delete('dom_4K468YrjOkR1wwdhqiO0G9XEUey');
```

**cURL**

```bash
curl -X DELETE https://api.emailit.com/v2/domains/dom_4K468YrjOkR1wwdhqiO0G9XEUey \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**200**

```json
{
  "object": "domain",
  "id": "dom_4K468YrjOkR1wwdhqiO0G9XEUey",
  "name": "acme.com",
  "deleted": true
}
```

**404**

```json
{
  "error": "Domain not found"
}
```

---
Source: https://emailit.com/docs/api-reference/domains/delete/