Introduction

Welcome to the addy.io API! You can use our API to access API endpoints, which can get information on your aliases, recipients, domains and additional usernames.

Base URL

https://app.addy.io

Authenticating requests

To authenticate requests, include an Authorization header with the value "Bearer {YOUR_AUTH_KEY}".

All authenticated endpoints are marked with a requires authentication badge in the documentation below.

You can retrieve your API key by visiting your account settings and clicking Create New API Key.

API Token

Get details about the current API token

requires authentication

This endpoint retrieves details about the current API token.

Example request:

curl --request GET \
    --get "https://app.addy.io/api/v1/api-token-details" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest"

const url = new URL(
    "https://app.addy.io/api/v1/api-token-details"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.addy.io/api/v1/api-token-details',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/api-token-details'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (200):


{
    "name": "Firefox Extension",
    "created_at": "2019-10-01 09:00:00",
    "expires_at": null
}

Received response:

Request failed with error:

Account Details

Get All Account Details

requires authentication

This endpoint retrieves all account details.

Example request:

curl --request GET \
    --get "https://app.addy.io/api/v1/account-details" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest"

const url = new URL(
    "https://app.addy.io/api/v1/account-details"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.addy.io/api/v1/account-details',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/account-details'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (200):


{
    "data": [
        {
            "id": "50c9e585-e7f5-41c4-9016-9014c15454bc",
            "username": "johndoe",
            "from_name": "John Doe",
            "email_subject": "Private Subject",
            "banner_location": "off",
            "bandwidth": 10485760,
            "username_count": 2,
            "username_limit": 3,
            "default_recipient_id": "46eebc50-f7f8-46d7-beb9-c37f04c29a84",
            "default_alias_domain": "anonaddy.me",
            "default_alias_format": "random_words",
            "subscription": "pro",
            "subscription_ends_at": null,
            "bandwidth_limit": 0,
            "recipient_count": 12,
            "recipient_limit": 20,
            "active_domain_count": 4,
            "active_domain_limit": 10,
            "active_shared_domain_alias_count": 50,
            "active_shared_domain_alias_limit": 0,
            "active_rule_count": 4,
            "active_rule_limit": 5,
            "total_emails_forwarded": 488,
            "total_emails_blocked": 6,
            "total_emails_replied": 95,
            "total_emails_sent": 17,
            "total_aliases": 529,
            "total_active_aliases": 481,
            "total_inactive_aliases": 19,
            "total_deleted_aliases": 29,
            "created_at": "2019-10-01 09:00:00",
            "updated_at": "2019-10-01 09:00:00"
        }
    ]
}

Received response:

Request failed with error:

Alias Bulk Actions

Bulk Get Specific Aliases

requires authentication

This endpoint gets specific aliases.

Example request:

curl --request POST \
    "https://app.addy.io/api/v1/aliases/get/bulk" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"ids\": [
        \"50c9e585-e7f5-41c4-9016-9014c15454bc\",
        \"c549db7d-5fac-4b09-9443-9e47f644d29f\"
    ]
}"

const url = new URL(
    "https://app.addy.io/api/v1/aliases/get/bulk"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

let body = {
    "ids": [
        "50c9e585-e7f5-41c4-9016-9014c15454bc",
        "c549db7d-5fac-4b09-9443-9e47f644d29f"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.addy.io/api/v1/aliases/get/bulk',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'ids' => [
                '50c9e585-e7f5-41c4-9016-9014c15454bc',
                'c549db7d-5fac-4b09-9443-9e47f644d29f',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/aliases/get/bulk'
payload = {
    "ids": [
        "50c9e585-e7f5-41c4-9016-9014c15454bc",
        "c549db7d-5fac-4b09-9443-9e47f644d29f"
    ]
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200):


{
    "data": [
        {
            "id": "50c9e585-e7f5-41c4-9016-9014c15454bc",
            "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
            "aliasable_id": null,
            "aliasable_type": null,
            "local_part": "first",
            "extension": null,
            "domain": "johndoe.anonaddy.com",
            "email": "first@johndoe.anonaddy.com",
            "active": true,
            "description": null,
            "from_name": null,
            "emails_forwarded": 5,
            "emails_blocked": 0,
            "emails_replied": 0,
            "emails_sent": 0,
            "recipients": [],
            "last_forwarded": "2019-10-01 09:00:00",
            "last_blocked": null,
            "last_replied": null,
            "last_sent": null,
            "created_at": "2019-10-01 09:00:00",
            "updated_at": "2019-10-01 09:00:00",
            "deleted_at": null
        },
        {
            "id": "c549db7d-5fac-4b09-9443-9e47f644d29f",
            "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
            "domain_id": null,
            "local_part": "second",
            "extension": null,
            "domain": "johndoe.anonaddy.com",
            "email": "second@johndoe.anonaddy.com",
            "active": true,
            "description": null,
            "from_name": null,
            "emails_forwarded": 2,
            "emails_blocked": 1,
            "emails_replied": 0,
            "emails_sent": 0,
            "recipients": [],
            "last_forwarded": "2019-10-01 09:00:00",
            "last_blocked": null,
            "last_replied": null,
            "last_sent": null,
            "created_at": "2019-10-01 09:00:00",
            "updated_at": "2019-10-01 09:00:00",
            "deleted_at": null
        }
    ]
}

Received response:

Request failed with error:

Bulk Activate Specific Aliases

requires authentication

This endpoint activates specific aliases.

Example request:

curl --request POST \
    "https://app.addy.io/api/v1/aliases/activate/bulk" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"ids\": [
        \"50c9e585-e7f5-41c4-9016-9014c15454bc\",
        \"c549db7d-5fac-4b09-9443-9e47f644d29f\"
    ]
}"

const url = new URL(
    "https://app.addy.io/api/v1/aliases/activate/bulk"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

let body = {
    "ids": [
        "50c9e585-e7f5-41c4-9016-9014c15454bc",
        "c549db7d-5fac-4b09-9443-9e47f644d29f"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.addy.io/api/v1/aliases/activate/bulk',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'ids' => [
                '50c9e585-e7f5-41c4-9016-9014c15454bc',
                'c549db7d-5fac-4b09-9443-9e47f644d29f',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/aliases/activate/bulk'
payload = {
    "ids": [
        "50c9e585-e7f5-41c4-9016-9014c15454bc",
        "c549db7d-5fac-4b09-9443-9e47f644d29f"
    ]
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200):


{
    "data": {
        "message": "2 aliases activated successfully",
        "ids": [
            "50c9e585-e7f5-41c4-9016-9014c15454bc",
            "c549db7d-5fac-4b09-9443-9e47f644d29f"
        ]
    }
}

Received response:

Request failed with error:

Bulk Deactivate Specific Aliases

requires authentication

This endpoint deactivates specific aliases.

Example request:

curl --request POST \
    "https://app.addy.io/api/v1/aliases/deactivate/bulk" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"ids\": [
        \"50c9e585-e7f5-41c4-9016-9014c15454bc\",
        \"c549db7d-5fac-4b09-9443-9e47f644d29f\"
    ]
}"

const url = new URL(
    "https://app.addy.io/api/v1/aliases/deactivate/bulk"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

let body = {
    "ids": [
        "50c9e585-e7f5-41c4-9016-9014c15454bc",
        "c549db7d-5fac-4b09-9443-9e47f644d29f"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.addy.io/api/v1/aliases/deactivate/bulk',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'ids' => [
                '50c9e585-e7f5-41c4-9016-9014c15454bc',
                'c549db7d-5fac-4b09-9443-9e47f644d29f',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/aliases/deactivate/bulk'
payload = {
    "ids": [
        "50c9e585-e7f5-41c4-9016-9014c15454bc",
        "c549db7d-5fac-4b09-9443-9e47f644d29f"
    ]
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200):


{
    "data": {
        "message": "2 aliases deactivated successfully",
        "ids": [
            "50c9e585-e7f5-41c4-9016-9014c15454bc",
            "c549db7d-5fac-4b09-9443-9e47f644d29f"
        ]
    }
}

Received response:

Request failed with error:

Bulk Delete Specific Aliases

requires authentication

This endpoint deletes specific aliases.

Example request:

curl --request POST \
    "https://app.addy.io/api/v1/aliases/delete/bulk" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"ids\": [
        \"50c9e585-e7f5-41c4-9016-9014c15454bc\",
        \"c549db7d-5fac-4b09-9443-9e47f644d29f\"
    ]
}"

const url = new URL(
    "https://app.addy.io/api/v1/aliases/delete/bulk"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

let body = {
    "ids": [
        "50c9e585-e7f5-41c4-9016-9014c15454bc",
        "c549db7d-5fac-4b09-9443-9e47f644d29f"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.addy.io/api/v1/aliases/delete/bulk',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'ids' => [
                '50c9e585-e7f5-41c4-9016-9014c15454bc',
                'c549db7d-5fac-4b09-9443-9e47f644d29f',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/aliases/delete/bulk'
payload = {
    "ids": [
        "50c9e585-e7f5-41c4-9016-9014c15454bc",
        "c549db7d-5fac-4b09-9443-9e47f644d29f"
    ]
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200):


{
    "data": {
        "message": "2 aliases deleted successfully",
        "ids": [
            "50c9e585-e7f5-41c4-9016-9014c15454bc",
            "c549db7d-5fac-4b09-9443-9e47f644d29f"
        ]
    }
}

Received response:

Request failed with error:

Bulk Restore Specific Aliases

requires authentication

This endpoint restores specific aliases.

Example request:

curl --request POST \
    "https://app.addy.io/api/v1/aliases/restore/bulk" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"ids\": [
        \"50c9e585-e7f5-41c4-9016-9014c15454bc\",
        \"c549db7d-5fac-4b09-9443-9e47f644d29f\"
    ]
}"

const url = new URL(
    "https://app.addy.io/api/v1/aliases/restore/bulk"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

let body = {
    "ids": [
        "50c9e585-e7f5-41c4-9016-9014c15454bc",
        "c549db7d-5fac-4b09-9443-9e47f644d29f"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.addy.io/api/v1/aliases/restore/bulk',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'ids' => [
                '50c9e585-e7f5-41c4-9016-9014c15454bc',
                'c549db7d-5fac-4b09-9443-9e47f644d29f',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/aliases/restore/bulk'
payload = {
    "ids": [
        "50c9e585-e7f5-41c4-9016-9014c15454bc",
        "c549db7d-5fac-4b09-9443-9e47f644d29f"
    ]
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200):


{
    "data": {
        "message": "2 aliases restored successfully",
        "ids": [
            "50c9e585-e7f5-41c4-9016-9014c15454bc",
            "c549db7d-5fac-4b09-9443-9e47f644d29f"
        ]
    }
}

Received response:

Request failed with error:

Bulk Forget Specific Aliases

requires authentication

This endpoint forgets specific aliases.

Example request:

curl --request POST \
    "https://app.addy.io/api/v1/aliases/forget/bulk" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"ids\": [
        \"50c9e585-e7f5-41c4-9016-9014c15454bc\",
        \"c549db7d-5fac-4b09-9443-9e47f644d29f\"
    ]
}"

const url = new URL(
    "https://app.addy.io/api/v1/aliases/forget/bulk"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

let body = {
    "ids": [
        "50c9e585-e7f5-41c4-9016-9014c15454bc",
        "c549db7d-5fac-4b09-9443-9e47f644d29f"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.addy.io/api/v1/aliases/forget/bulk',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'ids' => [
                '50c9e585-e7f5-41c4-9016-9014c15454bc',
                'c549db7d-5fac-4b09-9443-9e47f644d29f',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/aliases/forget/bulk'
payload = {
    "ids": [
        "50c9e585-e7f5-41c4-9016-9014c15454bc",
        "c549db7d-5fac-4b09-9443-9e47f644d29f"
    ]
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200):


{
    "data": {
        "message": "2 aliases forgotten successfully",
        "ids": [
            "50c9e585-e7f5-41c4-9016-9014c15454bc",
            "c549db7d-5fac-4b09-9443-9e47f644d29f"
        ]
    }
}

Received response:

Request failed with error:

Bulk Update Recipients for Specific Aliases

requires authentication

This endpoint updates the recipients for specific aliases.

Example request:

curl --request POST \
    "https://app.addy.io/api/v1/aliases/recipients/bulk" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"ids\": [
        \"50c9e585-e7f5-41c4-9016-9014c15454bc\",
        \"c549db7d-5fac-4b09-9443-9e47f644d29f\"
    ],
    \"recipient_ids\": [
        \"46eebc50-f7f8-46d7-beb9-c37f04c29a84\"
    ]
}"

const url = new URL(
    "https://app.addy.io/api/v1/aliases/recipients/bulk"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

let body = {
    "ids": [
        "50c9e585-e7f5-41c4-9016-9014c15454bc",
        "c549db7d-5fac-4b09-9443-9e47f644d29f"
    ],
    "recipient_ids": [
        "46eebc50-f7f8-46d7-beb9-c37f04c29a84"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.addy.io/api/v1/aliases/recipients/bulk',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'ids' => [
                '50c9e585-e7f5-41c4-9016-9014c15454bc',
                'c549db7d-5fac-4b09-9443-9e47f644d29f',
            ],
            'recipient_ids' => [
                '46eebc50-f7f8-46d7-beb9-c37f04c29a84',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/aliases/recipients/bulk'
payload = {
    "ids": [
        "50c9e585-e7f5-41c4-9016-9014c15454bc",
        "c549db7d-5fac-4b09-9443-9e47f644d29f"
    ],
    "recipient_ids": [
        "46eebc50-f7f8-46d7-beb9-c37f04c29a84"
    ]
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200):


{
    "data": {
        "message": "recipients updated for 2 aliases successfully",
        "ids": [
            "50c9e585-e7f5-41c4-9016-9014c15454bc",
            "c549db7d-5fac-4b09-9443-9e47f644d29f"
        ]
    }
}

Received response:

Request failed with error:

Aliases

Get All Aliases

requires authentication

This endpoint retrieves all aliases.

Example request:

curl --request GET \
    --get "https://app.addy.io/api/v1/aliases?filter%5Bdeleted%5D=with&filter%5Bactive%5D=true&filter%5Bsearch%5D=johndoe&sort=-email&page%5Bnumber%5D=1&page%5Bsize%5D=10&with=recipients&recipient=46eebc50-f7f8-46d7-beb9-c37f04c29a84&domain=0ad7a75a-1517-4b86-bb8a-9443d4965e60&username=2777dee6-1721-45c0-8d01-698b6be2335f" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest"

const url = new URL(
    "https://app.addy.io/api/v1/aliases"
);

const params = {
    "filter[deleted]": "with",
    "filter[active]": "true",
    "filter[search]": "johndoe",
    "sort": "-email",
    "page[number]": "1",
    "page[size]": "10",
    "with": "recipients",
    "recipient": "46eebc50-f7f8-46d7-beb9-c37f04c29a84",
    "domain": "0ad7a75a-1517-4b86-bb8a-9443d4965e60",
    "username": "2777dee6-1721-45c0-8d01-698b6be2335f",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.addy.io/api/v1/aliases',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'query' => [
            'filter[deleted]'=> 'with',
            'filter[active]'=> 'true',
            'filter[search]'=> 'johndoe',
            'sort'=> '-email',
            'page[number]'=> '1',
            'page[size]'=> '10',
            'with'=> 'recipients',
            'recipient'=> '46eebc50-f7f8-46d7-beb9-c37f04c29a84',
            'domain'=> '0ad7a75a-1517-4b86-bb8a-9443d4965e60',
            'username'=> '2777dee6-1721-45c0-8d01-698b6be2335f',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/aliases'
params = {
  'filter[deleted]': 'with',
  'filter[active]': 'true',
  'filter[search]': 'johndoe',
  'sort': '-email',
  'page[number]': '1',
  'page[size]': '10',
  'with': 'recipients',
  'recipient': '46eebc50-f7f8-46d7-beb9-c37f04c29a84',
  'domain': '0ad7a75a-1517-4b86-bb8a-9443d4965e60',
  'username': '2777dee6-1721-45c0-8d01-698b6be2335f',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Example response (200):


{
    "data": [
        {
            "id": "50c9e585-e7f5-41c4-9016-9014c15454bc",
            "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
            "aliasable_id": null,
            "aliasable_type": null,
            "local_part": "first",
            "extension": null,
            "domain": "johndoe.anonaddy.com",
            "email": "first@johndoe.anonaddy.com",
            "active": true,
            "description": null,
            "from_name": null,
            "emails_forwarded": 5,
            "emails_blocked": 0,
            "emails_replied": 0,
            "emails_sent": 0,
            "recipients": [],
            "last_forwarded": "2019-10-01 09:00:00",
            "last_blocked": null,
            "last_replied": null,
            "last_sent": null,
            "created_at": "2019-10-01 09:00:00",
            "updated_at": "2019-10-01 09:00:00",
            "deleted_at": null
        },
        {
            "id": "c549db7d-5fac-4b09-9443-9e47f644d29f",
            "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
            "domain_id": null,
            "local_part": "second",
            "extension": null,
            "domain": "johndoe.anonaddy.com",
            "email": "second@johndoe.anonaddy.com",
            "active": true,
            "description": null,
            "from_name": null,
            "emails_forwarded": 2,
            "emails_blocked": 1,
            "emails_replied": 0,
            "emails_sent": 0,
            "recipients": [],
            "last_forwarded": "2019-10-01 09:00:00",
            "last_blocked": null,
            "last_replied": null,
            "last_sent": null,
            "created_at": "2019-10-01 09:00:00",
            "updated_at": "2019-10-01 09:00:00",
            "deleted_at": null
        }
    ],
    "links": {
        "first": "https://app.addy.io/api/v1/aliases?filter%5Bdeleted%5D=with&filter%5Bsearch%5D=johndoe&page%5Bsize%5D=10&page%5Bnumber%5D=1",
        "last": "https://app.addy.io/api/v1/aliases?filter%5Bdeleted%5D=with&filter%5Bsearch%5D=johndoe&page%5Bsize%5D=10&page%5Bnumber%5D=1",
        "prev": null,
        "next": null
    },
    "meta": {
        "current_page": 1,
        "from": 1,
        "last_page": 1,
        "links": [
            {
                "url": null,
                "label": "&laquo; Previous",
                "active": false
            },
            {
                "url": "https://app.addy.io/api/v1/aliases?filter%5Bdeleted%5D=with&filter%5Bsearch%5D=johndoe&page%5Bsize%5D=10&page%5Bnumber%5D=1",
                "label": "1",
                "active": true
            },
            {
                "url": null,
                "label": "Next &raquo;",
                "active": false
            }
        ],
        "path": "https://app.addy.io/api/v1/aliases",
        "per_page": 10,
        "to": 2,
        "total": 2
    }
}

Received response:

Request failed with error:

Request

GET api/v1/aliases

Query Parameters

filter[deleted] string optional

Choose to return alias with deleted or only deleted. Options: with, only.

filter[active] string optional

Choose to return active or inactive aliases. Options: true, false.

filter[search] string optional

Search aliases by email and description.

sort string optional

Choose what to sort the aliases by, prepend "-" for descending results. Options: local_part, domain, email, emails_forwarded, emails_blocked, emails_replied, emails_sent, last_forwarded, last_blocked, last_replied, last_sent, active, created_at, updated_at, deleted_at

page[number] integer optional

Paginate the alias results.

page[size] integer optional

Paginate the alias results, default 100, min 1 max 100.

with string optional

Return aliases with their attached recipients. Options: recipients

recipient string optional

Return aliases using the recipient with the specified ID.

domain string optional

Return aliases using the custom domain with the specified ID.

username string optional

Return aliases using the username with the specified ID.

Get a Specific Alias

requires authentication

This endpoint retrieves a specific alias.

Example request:

curl --request GET \
    --get "https://app.addy.io/api/v1/aliases/50c9e585-e7f5-41c4-9016-9014c15454bc" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest"

const url = new URL(
    "https://app.addy.io/api/v1/aliases/50c9e585-e7f5-41c4-9016-9014c15454bc"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.addy.io/api/v1/aliases/50c9e585-e7f5-41c4-9016-9014c15454bc',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/aliases/50c9e585-e7f5-41c4-9016-9014c15454bc'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (200):


{
    "data": {
        "id": "50c9e585-e7f5-41c4-9016-9014c15454bc",
        "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
        "aliasable_id": null,
        "aliasable_type": null,
        "local_part": "first",
        "extension": null,
        "domain": "johndoe.anonaddy.com",
        "email": "first@johndoe.anonaddy.com",
        "active": true,
        "description": null,
        "from_name": null,
        "emails_forwarded": 5,
        "emails_blocked": 0,
        "emails_replied": 0,
        "emails_sent": 0,
        "recipients": [],
        "last_forwarded": "2019-10-01 09:00:00",
        "last_blocked": null,
        "last_replied": null,
        "last_sent": null,
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00",
        "deleted_at": null
    }
}

Received response:

Request failed with error:

Create New Alias

requires authentication

This endpoint creates a new alias.

Example request:

curl --request POST \
    "https://app.addy.io/api/v1/aliases" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"domain\": \"anonaddy.me\",
    \"description\": \"For example.com\",
    \"format\": \"uuid\",
    \"local_part\": \"hello\",
    \"recipient_ids\": [
        \"46eebc50-f7f8-46d7-beb9-c37f04c29a84\"
    ]
}"

const url = new URL(
    "https://app.addy.io/api/v1/aliases"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

let body = {
    "domain": "anonaddy.me",
    "description": "For example.com",
    "format": "uuid",
    "local_part": "hello",
    "recipient_ids": [
        "46eebc50-f7f8-46d7-beb9-c37f04c29a84"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.addy.io/api/v1/aliases',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'domain' => 'anonaddy.me',
            'description' => 'For example.com',
            'format' => 'uuid',
            'local_part' => 'hello',
            'recipient_ids' => [
                '46eebc50-f7f8-46d7-beb9-c37f04c29a84',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/aliases'
payload = {
    "domain": "anonaddy.me",
    "description": "For example.com",
    "format": "uuid",
    "local_part": "hello",
    "recipient_ids": [
        "46eebc50-f7f8-46d7-beb9-c37f04c29a84"
    ]
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (201):


{
    "data": {
        "id": "50c9e585-e7f5-41c4-9016-9014c15454bc",
        "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
        "aliasable_id": null,
        "aliasable_type": null,
        "local_part": "50c9e585-e7f5-41c4-9016-9014c15454bc",
        "extension": null,
        "domain": "anonaddy.me",
        "email": "50c9e585-e7f5-41c4-9016-9014c15454bc@anonaddy.me",
        "active": true,
        "description": "For example.com",
        "from_name": null,
        "emails_forwarded": 5,
        "emails_blocked": 0,
        "emails_replied": 0,
        "emails_sent": 0,
        "recipients": [],
        "last_forwarded": "2019-10-01 09:00:00",
        "last_blocked": null,
        "last_replied": null,
        "last_sent": null,
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00",
        "deleted_at": null
    }
}

Received response:

Request failed with error:

Request

POST api/v1/aliases

Body Parameters

domain string

The domain of the alias

description string optional

The description of the alias

format string optional

The chosen format for the alias. Options: random_characters, uuid, random_words, custom (the custom format is not available for shared domains)

local_part string optional

The chosen local part for the alias (only required if you have the format as custom)

recipient_ids string[] optional

An array of recipient ids to add (the default recipient will be used if none provided)

Update a Specific Alias

requires authentication

This endpoint updates a specific alias.

Example request:

curl --request PATCH \
    "https://app.addy.io/api/v1/aliases/50c9e585-e7f5-41c4-9016-9014c15454bc" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"description\": \"New description\",
    \"from_name\": \"John Doe\"
}"

const url = new URL(
    "https://app.addy.io/api/v1/aliases/50c9e585-e7f5-41c4-9016-9014c15454bc"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

let body = {
    "description": "New description",
    "from_name": "John Doe"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'https://app.addy.io/api/v1/aliases/50c9e585-e7f5-41c4-9016-9014c15454bc',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'description' => 'New description',
            'from_name' => 'John Doe',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/aliases/50c9e585-e7f5-41c4-9016-9014c15454bc'
payload = {
    "description": "New description",
    "from_name": "John Doe"
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Example response (200):


{
    "data": {
        "id": "50c9e585-e7f5-41c4-9016-9014c15454bc",
        "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
        "aliasable_id": null,
        "aliasable_type": null,
        "local_part": "first",
        "extension": null,
        "domain": "johndoe.anonaddy.com",
        "email": "first@johndoe.anonaddy.com",
        "active": true,
        "description": "New description",
        "from_name": "John Doe",
        "emails_forwarded": 5,
        "emails_blocked": 0,
        "emails_replied": 0,
        "emails_sent": 0,
        "recipients": [],
        "last_forwarded": "2019-10-01 09:00:00",
        "last_blocked": null,
        "last_replied": null,
        "last_sent": null,
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00",
        "deleted_at": null
    }
}

Received response:

Request failed with error:

Restore a Specific Deleted Alias

requires authentication

This endpoint restores a specific deleted alias.

Example request:

curl --request PATCH \
    "https://app.addy.io/api/v1/aliases/50c9e585-e7f5-41c4-9016-9014c15454bc/restore" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest"

const url = new URL(
    "https://app.addy.io/api/v1/aliases/50c9e585-e7f5-41c4-9016-9014c15454bc/restore"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

fetch(url, {
    method: "PATCH",
    headers,
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'https://app.addy.io/api/v1/aliases/50c9e585-e7f5-41c4-9016-9014c15454bc/restore',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/aliases/50c9e585-e7f5-41c4-9016-9014c15454bc/restore'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('PATCH', url, headers=headers)
response.json()

Example response (200):


{
    "data": {
        "id": "50c9e585-e7f5-41c4-9016-9014c15454bc",
        "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
        "aliasable_id": null,
        "aliasable_type": null,
        "local_part": "first",
        "extension": null,
        "domain": "johndoe.anonaddy.com",
        "email": "first@johndoe.anonaddy.com",
        "active": true,
        "description": "New description",
        "from_name": null,
        "emails_forwarded": 5,
        "emails_blocked": 0,
        "emails_replied": 0,
        "emails_sent": 0,
        "recipients": [],
        "last_forwarded": "2019-10-01 09:00:00",
        "last_blocked": null,
        "last_replied": null,
        "last_sent": null,
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00",
        "deleted_at": null
    }
}

Received response:

Request failed with error:

Delete a Specific Alias

requires authentication

This endpoint deletes a specific alias.

Example request:

curl --request DELETE \
    "https://app.addy.io/api/v1/aliases/50c9e585-e7f5-41c4-9016-9014c15454bc" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest"

const url = new URL(
    "https://app.addy.io/api/v1/aliases/50c9e585-e7f5-41c4-9016-9014c15454bc"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://app.addy.io/api/v1/aliases/50c9e585-e7f5-41c4-9016-9014c15454bc',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/aliases/50c9e585-e7f5-41c4-9016-9014c15454bc'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Example response (204):

[Empty response]

Received response:

Request failed with error:

Forget a Specific Alias

requires authentication

This endpoint forgets a specific alias.

Example request:

curl --request DELETE \
    "https://app.addy.io/api/v1/aliases/50c9e585-e7f5-41c4-9016-9014c15454bc/forget" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest"

const url = new URL(
    "https://app.addy.io/api/v1/aliases/50c9e585-e7f5-41c4-9016-9014c15454bc/forget"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://app.addy.io/api/v1/aliases/50c9e585-e7f5-41c4-9016-9014c15454bc/forget',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/aliases/50c9e585-e7f5-41c4-9016-9014c15454bc/forget'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Example response (204):

[Empty response]

Received response:

Request failed with error:

Activate a Specific Alias

requires authentication

This endpoint activates a specific alias.

Example request:

curl --request POST \
    "https://app.addy.io/api/v1/active-aliases" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"id\": \"50c9e585-e7f5-41c4-9016-9014c15454bc\"
}"

const url = new URL(
    "https://app.addy.io/api/v1/active-aliases"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

let body = {
    "id": "50c9e585-e7f5-41c4-9016-9014c15454bc"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.addy.io/api/v1/active-aliases',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'id' => '50c9e585-e7f5-41c4-9016-9014c15454bc',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/active-aliases'
payload = {
    "id": "50c9e585-e7f5-41c4-9016-9014c15454bc"
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200):


{
    "data": {
        "id": "50c9e585-e7f5-41c4-9016-9014c15454bc",
        "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
        "aliasable_id": null,
        "aliasable_type": null,
        "local_part": "50c9e585-e7f5-41c4-9016-9014c15454bc",
        "extension": null,
        "domain": "anonaddy.me",
        "email": "50c9e585-e7f5-41c4-9016-9014c15454bc@anonaddy.me",
        "active": true,
        "description": null,
        "from_name": null,
        "emails_forwarded": 5,
        "emails_blocked": 0,
        "emails_replied": 0,
        "emails_sent": 0,
        "recipients": [],
        "last_forwarded": "2019-10-01 09:00:00",
        "last_blocked": null,
        "last_replied": null,
        "last_sent": null,
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00",
        "deleted_at": null
    }
}

Received response:

Request failed with error:

Deactivate a Specific Alias

requires authentication

This endpoint deactivates a specific alias.

Example request:

curl --request DELETE \
    "https://app.addy.io/api/v1/active-aliases/50c9e585-e7f5-41c4-9016-9014c15454bc" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest"

const url = new URL(
    "https://app.addy.io/api/v1/active-aliases/50c9e585-e7f5-41c4-9016-9014c15454bc"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://app.addy.io/api/v1/active-aliases/50c9e585-e7f5-41c4-9016-9014c15454bc',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/active-aliases/50c9e585-e7f5-41c4-9016-9014c15454bc'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Example response (204):

[Empty response]

Received response:

Request failed with error:

Update Recipients for a Specific Alias

requires authentication

This endpoint updates the recipients for a specific alias.

Example request:

curl --request POST \
    "https://app.addy.io/api/v1/alias-recipients" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"alias_id\": \"50c9e585-e7f5-41c4-9016-9014c15454bc\",
    \"recipient_ids\": [
        \"46eebc50-f7f8-46d7-beb9-c37f04c29a84\"
    ]
}"

const url = new URL(
    "https://app.addy.io/api/v1/alias-recipients"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

let body = {
    "alias_id": "50c9e585-e7f5-41c4-9016-9014c15454bc",
    "recipient_ids": [
        "46eebc50-f7f8-46d7-beb9-c37f04c29a84"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.addy.io/api/v1/alias-recipients',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'alias_id' => '50c9e585-e7f5-41c4-9016-9014c15454bc',
            'recipient_ids' => [
                '46eebc50-f7f8-46d7-beb9-c37f04c29a84',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/alias-recipients'
payload = {
    "alias_id": "50c9e585-e7f5-41c4-9016-9014c15454bc",
    "recipient_ids": [
        "46eebc50-f7f8-46d7-beb9-c37f04c29a84"
    ]
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200):


{
    "data": {
        "id": "50c9e585-e7f5-41c4-9016-9014c15454bc",
        "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
        "aliasable_id": null,
        "aliasable_type": null,
        "local_part": "first",
        "extension": null,
        "domain": "johndoe.anonaddy.com",
        "email": "first@johndoe.anonaddy.com",
        "active": true,
        "description": null,
        "from_name": null,
        "emails_forwarded": 5,
        "emails_blocked": 0,
        "emails_replied": 0,
        "emails_sent": 0,
        "recipients": [
            {
                "id": "46eebc50-f7f8-46d7-beb9-c37f04c29a84",
                "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
                "email": "me@example.com",
                "can_reply_send": true,
                "should_encrypt": false,
                "inline_encryption": false,
                "protected_headers": false,
                "fingerprint": null,
                "email_verified_at": "2019-10-01 09:00:00",
                "aliases": [],
                "created_at": "2019-10-01 09:00:00",
                "updated_at": "2019-10-01 09:00:00"
            }
        ],
        "last_forwarded": "2019-10-01 09:00:00",
        "last_blocked": null,
        "last_replied": null,
        "last_sent": null,
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00",
        "deleted_at": null
    }
}

Received response:

Request failed with error:

App Version

Get The Current addy.io App Version

requires authentication

This endpoint retrieves details about the current addy.io version (only available for self-hosted instances).

Example request:

curl --request GET \
    --get "https://app.addy.io/api/v1/app-version" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest"

const url = new URL(
    "https://app.addy.io/api/v1/app-version"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.addy.io/api/v1/app-version',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/app-version'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (200):


{
    "version": "0.1.4",
    "major": 0,
    "minor": 1,
    "patch": 4
}

Received response:

Request failed with error:

Domain Options

Get All Domain Options

requires authentication

This endpoint retrieves all domain options.

Example request:

curl --request GET \
    --get "https://app.addy.io/api/v1/domain-options" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest"

const url = new URL(
    "https://app.addy.io/api/v1/domain-options"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.addy.io/api/v1/domain-options',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/domain-options'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (200):


{
    "data": [
        "anonaddy.me",
        "johndoe.anonaddy.com",
        "johndoe.anonaddy.me"
    ],
    "sharedDomains": [
        "anonaddy.me"
    ],
    "defaultAliasDomain": "anonaddy.me",
    "defaultAliasFormat": "random_words"
}

Received response:

Request failed with error:

Domains

Get All Domains

requires authentication

This endpoint retrieves all domains.

Example request:

curl --request GET \
    --get "https://app.addy.io/api/v1/domains" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest"

const url = new URL(
    "https://app.addy.io/api/v1/domains"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.addy.io/api/v1/domains',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/domains'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (200):


{
    "data": [
        {
            "id": "0ad7a75a-1517-4b86-bb8a-9443d4965e60",
            "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
            "domain": "example.com",
            "description": null,
            "from_name": null,
            "aliases_count": 5,
            "default_recipient": null,
            "active": true,
            "catch_all": true,
            "domain_verified_at": "2019-10-01 09:00:00",
            "domain_mx_validated_at": "2019-10-01 09:00:00",
            "domain_sending_verified_at": "2019-10-01 09:00:00",
            "created_at": "2019-10-01 09:00:00",
            "updated_at": "2019-10-01 09:00:00"
        },
        {
            "id": "9a7308d9-fcde-4510-b853-6b09e87b42af",
            "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
            "domain": "example.me",
            "description": null,
            "from_name": null,
            "aliases_count": 1,
            "default_recipient": null,
            "active": true,
            "catch_all": true,
            "domain_verified_at": null,
            "domain_mx_validated_at": null,
            "domain_sending_verified_at": null,
            "created_at": "2019-10-01 09:00:00",
            "updated_at": "2019-10-01 09:00:00"
        }
    ]
}

Received response:

Request failed with error:

Get a Specific Domain

requires authentication

This endpoint retrieves a specific domain.

Example request:

curl --request GET \
    --get "https://app.addy.io/api/v1/domains/0ad7a75a-1517-4b86-bb8a-9443d4965e60" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest"

const url = new URL(
    "https://app.addy.io/api/v1/domains/0ad7a75a-1517-4b86-bb8a-9443d4965e60"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.addy.io/api/v1/domains/0ad7a75a-1517-4b86-bb8a-9443d4965e60',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/domains/0ad7a75a-1517-4b86-bb8a-9443d4965e60'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (200):


{
    "data": {
        "id": "0ad7a75a-1517-4b86-bb8a-9443d4965e60",
        "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
        "domain": "example.com",
        "description": null,
        "from_name": null,
        "aliases_count": 5,
        "default_recipient": null,
        "active": true,
        "catch_all": true,
        "domain_verified_at": "2019-10-01 09:00:00",
        "domain_mx_validated_at": "2019-10-01 09:00:00",
        "domain_sending_verified_at": "2019-10-01 09:00:00",
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00"
    }
}

Received response:

Request failed with error:

Create New Domain

requires authentication

This endpoint creates a new domain.

Example request:

curl --request POST \
    "https://app.addy.io/api/v1/domains" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"domain\": \"example.com\"
}"

const url = new URL(
    "https://app.addy.io/api/v1/domains"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

let body = {
    "domain": "example.com"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.addy.io/api/v1/domains',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'domain' => 'example.com',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/domains'
payload = {
    "domain": "example.com"
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (201):


{
    "data": {
        "id": "0ad7a75a-1517-4b86-bb8a-9443d4965e60",
        "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
        "domain": "example.com",
        "description": null,
        "from_name": null,
        "aliases_count": 5,
        "default_recipient": null,
        "active": true,
        "catch_all": true,
        "domain_verified_at": "2019-10-01 09:00:00",
        "domain_mx_validated_at": "2019-10-01 09:00:00",
        "domain_sending_verified_at": "2019-10-01 09:00:00",
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00"
    }
}

Received response:

Request failed with error:

Update a Specific Domain

requires authentication

This endpoint updates a specific domain.

Example request:

curl --request PATCH \
    "https://app.addy.io/api/v1/domains/0ad7a75a-1517-4b86-bb8a-9443d4965e60" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"description\": \"New description\",
    \"from_name\": \"Mr Example\"
}"

const url = new URL(
    "https://app.addy.io/api/v1/domains/0ad7a75a-1517-4b86-bb8a-9443d4965e60"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

let body = {
    "description": "New description",
    "from_name": "Mr Example"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'https://app.addy.io/api/v1/domains/0ad7a75a-1517-4b86-bb8a-9443d4965e60',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'description' => 'New description',
            'from_name' => 'Mr Example',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/domains/0ad7a75a-1517-4b86-bb8a-9443d4965e60'
payload = {
    "description": "New description",
    "from_name": "Mr Example"
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Example response (200):


{
    "data": {
        "id": "0ad7a75a-1517-4b86-bb8a-9443d4965e60",
        "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
        "domain": "example.com",
        "description": "New description",
        "from_name": "Mr Example",
        "aliases_count": 5,
        "default_recipient": null,
        "active": true,
        "catch_all": true,
        "domain_verified_at": "2019-10-01 09:00:00",
        "domain_mx_validated_at": "2019-10-01 09:00:00",
        "domain_sending_verified_at": "2019-10-01 09:00:00",
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00"
    }
}

Received response:

Request failed with error:

Delete a Specific Domain

requires authentication

This endpoint deletes a specific domain.

Example request:

curl --request DELETE \
    "https://app.addy.io/api/v1/domains/0ad7a75a-1517-4b86-bb8a-9443d4965e60" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest"

const url = new URL(
    "https://app.addy.io/api/v1/domains/0ad7a75a-1517-4b86-bb8a-9443d4965e60"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://app.addy.io/api/v1/domains/0ad7a75a-1517-4b86-bb8a-9443d4965e60',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/domains/0ad7a75a-1517-4b86-bb8a-9443d4965e60'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Example response (204):

[Empty response]

Received response:

Request failed with error:

Update Default Recipient for a Specific Domain

requires authentication

This endpoint updates the default recipient for a specific domain.

Example request:

curl --request PATCH \
    "https://app.addy.io/api/v1/domains/0ad7a75a-1517-4b86-bb8a-9443d4965e60/default-recipient" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"default_recipient\": \"46eebc50-f7f8-46d7-beb9-c37f04c29a84\"
}"

const url = new URL(
    "https://app.addy.io/api/v1/domains/0ad7a75a-1517-4b86-bb8a-9443d4965e60/default-recipient"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

let body = {
    "default_recipient": "46eebc50-f7f8-46d7-beb9-c37f04c29a84"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'https://app.addy.io/api/v1/domains/0ad7a75a-1517-4b86-bb8a-9443d4965e60/default-recipient',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'default_recipient' => '46eebc50-f7f8-46d7-beb9-c37f04c29a84',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/domains/0ad7a75a-1517-4b86-bb8a-9443d4965e60/default-recipient'
payload = {
    "default_recipient": "46eebc50-f7f8-46d7-beb9-c37f04c29a84"
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Example response (200):


{
    "data": {
        "id": "0ad7a75a-1517-4b86-bb8a-9443d4965e60",
        "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
        "domain": "example.com",
        "description": null,
        "from_name": null,
        "aliases_count": 5,
        "default_recipient": {
            "id": "46eebc50-f7f8-46d7-beb9-c37f04c29a84",
            "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
            "email": "me@example.com",
            "can_reply_send": true,
            "should_encrypt": false,
            "inline_encryption": false,
            "protected_headers": false,
            "fingerprint": null,
            "email_verified_at": "2019-10-01 09:00:00",
            "created_at": "2019-10-01 09:00:00",
            "updated_at": "2019-10-01 09:00:00"
        },
        "active": true,
        "catch_all": true,
        "domain_verified_at": "2019-10-01 09:00:00",
        "domain_mx_validated_at": "2019-10-01 09:00:00",
        "domain_sending_verified_at": "2019-10-01 09:00:00",
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00"
    }
}

Received response:

Request failed with error:

Activate a Specific Domain

requires authentication

This endpoint activates a specific domain.

Example request:

curl --request POST \
    "https://app.addy.io/api/v1/active-domains" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"id\": \"0ad7a75a-1517-4b86-bb8a-9443d4965e60\"
}"

const url = new URL(
    "https://app.addy.io/api/v1/active-domains"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

let body = {
    "id": "0ad7a75a-1517-4b86-bb8a-9443d4965e60"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.addy.io/api/v1/active-domains',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'id' => '0ad7a75a-1517-4b86-bb8a-9443d4965e60',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/active-domains'
payload = {
    "id": "0ad7a75a-1517-4b86-bb8a-9443d4965e60"
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200):


{
    "data": {
        "id": "0ad7a75a-1517-4b86-bb8a-9443d4965e60",
        "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
        "domain": "example.com",
        "description": null,
        "from_name": null,
        "aliases_count": 5,
        "default_recipient": null,
        "active": true,
        "catch_all": true,
        "domain_verified_at": "2019-10-01 09:00:00",
        "domain_mx_validated_at": "2019-10-01 09:00:00",
        "domain_sending_verified_at": "2019-10-01 09:00:00",
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00"
    }
}

Received response:

Request failed with error:

Deactivate a Specific Domain

requires authentication

This endpoint deactivates a specific domain.

Example request:

curl --request DELETE \
    "https://app.addy.io/api/v1/active-domains/0ad7a75a-1517-4b86-bb8a-9443d4965e60" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest"

const url = new URL(
    "https://app.addy.io/api/v1/active-domains/0ad7a75a-1517-4b86-bb8a-9443d4965e60"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://app.addy.io/api/v1/active-domains/0ad7a75a-1517-4b86-bb8a-9443d4965e60',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/active-domains/0ad7a75a-1517-4b86-bb8a-9443d4965e60'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Example response (204):

[Empty response]

Received response:

Request failed with error:

Enable catch-all for a Specific Domain

requires authentication

This endpoint enables catch-all a specific domain.

Example request:

curl --request POST \
    "https://app.addy.io/api/v1/catch-all-domains" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"id\": \"0ad7a75a-1517-4b86-bb8a-9443d4965e60\"
}"

const url = new URL(
    "https://app.addy.io/api/v1/catch-all-domains"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

let body = {
    "id": "0ad7a75a-1517-4b86-bb8a-9443d4965e60"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.addy.io/api/v1/catch-all-domains',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'id' => '0ad7a75a-1517-4b86-bb8a-9443d4965e60',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/catch-all-domains'
payload = {
    "id": "0ad7a75a-1517-4b86-bb8a-9443d4965e60"
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200):


{
    "data": {
        "id": "0ad7a75a-1517-4b86-bb8a-9443d4965e60",
        "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
        "domain": "example.com",
        "from_name": null,
        "description": null,
        "aliases_count": 5,
        "default_recipient": null,
        "active": true,
        "catch_all": true,
        "domain_verified_at": "2019-10-01 09:00:00",
        "domain_mx_validated_at": "2019-10-01 09:00:00",
        "domain_sending_verified_at": "2019-10-01 09:00:00",
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00"
    }
}

Received response:

Request failed with error:

Disable catch-all for a Specific Domain

requires authentication

This endpoint disables catch-all for a specific domain.

Example request:

curl --request DELETE \
    "https://app.addy.io/api/v1/catch-all-domains/0ad7a75a-1517-4b86-bb8a-9443d4965e60" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest"

const url = new URL(
    "https://app.addy.io/api/v1/catch-all-domains/0ad7a75a-1517-4b86-bb8a-9443d4965e60"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://app.addy.io/api/v1/catch-all-domains/0ad7a75a-1517-4b86-bb8a-9443d4965e60',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/catch-all-domains/0ad7a75a-1517-4b86-bb8a-9443d4965e60'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Example response (204):

[Empty response]

Received response:

Request failed with error:

Failed Deliveries

Get All Failed Deliveries

requires authentication

This endpoint retrieves all failed deliveries.

Example request:

curl --request GET \
    --get "https://app.addy.io/api/v1/failed-deliveries" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest"

const url = new URL(
    "https://app.addy.io/api/v1/failed-deliveries"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.addy.io/api/v1/failed-deliveries',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/failed-deliveries'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (200):


{
    "data": [
        {
            "id": "0222b9fe-59d0-4066-a711-c44ad42f1734",
            "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
            "recipient_id": "46eebc50-f7f8-46d7-beb9-c37f04c29a84",
            "recipient_email": "user@recipient.com",
            "alias_id": "50c9e585-e7f5-41c4-9016-9014c15454bc",
            "alias_email": "alias@anonaddy.com",
            "bounce_type": "spam",
            "remote_mta": "mail.icloud.com",
            "sender": "sender@example.com",
            "email_type": "F",
            "status": "5.7.1",
            "code": "smtp; 554 5.7.1 [CS01] Message rejected due to local policy. Please visit https://support.apple.com/en-us/HT204137",
            "attempted_at": "2019-10-01 09:00:00",
            "created_at": "2019-10-01 09:00:00",
            "updated_at": "2019-10-01 09:00:00"
        },
        {
            "id": "f6d1cfe6-46b6-4068-5881-b7cd07dac8a2",
            "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
            "recipient_id": "46eebc50-f7f8-46d7-beb9-c37f04c29a84",
            "recipient_email": "user@recipient.com",
            "alias_id": "50c9e585-e7f5-41c4-9016-9014c15454bc",
            "alias_email": "alias@anonaddy.com",
            "bounce_type": "hard",
            "remote_mta": "mail.example.com",
            "sender": "sender@example.com",
            "email_type": "F",
            "status": "5.7.1",
            "code": "smtp; 550 5.7.1 <does-not-exist@example.com>: Recipient address rejected: Recipient not found",
            "attempted_at": "2019-10-01 09:00:00",
            "created_at": "2019-10-01 09:00:00",
            "updated_at": "2019-10-01 09:00:00"
        }
    ]
}

Received response:

Request failed with error:

Get a Specific Failed Delivery

requires authentication

This endpoint retrieves a specific failed delivery.

Example request:

curl --request GET \
    --get "https://app.addy.io/api/v1/failed-deliveries/46eebc50-f7f8-46d7-beb9-c37f04c29a84" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest"

const url = new URL(
    "https://app.addy.io/api/v1/failed-deliveries/46eebc50-f7f8-46d7-beb9-c37f04c29a84"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.addy.io/api/v1/failed-deliveries/46eebc50-f7f8-46d7-beb9-c37f04c29a84',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/failed-deliveries/46eebc50-f7f8-46d7-beb9-c37f04c29a84'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (200):


{
    "data": {
        "id": "0222b9fe-59d0-4066-a711-c44ad42f1734",
        "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
        "recipient_id": "46eebc50-f7f8-46d7-beb9-c37f04c29a84",
        "recipient_email": "user@recipient.com",
        "alias_id": "50c9e585-e7f5-41c4-9016-9014c15454bc",
        "alias_email": "alias@anonaddy.com",
        "bounce_type": "spam",
        "remote_mta": "mail.icloud.com",
        "sender": "sender@example.com",
        "email_type": "F",
        "status": "5.7.1",
        "code": "smtp; 554 5.7.1 [CS01] Message rejected due to local policy. Please visit https://support.apple.com/en-us/HT204137",
        "attempted_at": "2019-10-01 09:00:00",
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00"
    }
}

Received response:

Request failed with error:

Delete a Specific Failed Delivery

requires authentication

This endpoint deletes a specific failed delivery.

Example request:

curl --request DELETE \
    "https://app.addy.io/api/v1/failed-deliveries/46eebc50-f7f8-46d7-beb9-c37f04c29a84" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest"

const url = new URL(
    "https://app.addy.io/api/v1/failed-deliveries/46eebc50-f7f8-46d7-beb9-c37f04c29a84"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://app.addy.io/api/v1/failed-deliveries/46eebc50-f7f8-46d7-beb9-c37f04c29a84',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/failed-deliveries/46eebc50-f7f8-46d7-beb9-c37f04c29a84'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Example response (204):

[Empty response]

Received response:

Request failed with error:

Recipients

Get All Recipients

requires authentication

This endpoint retrieves all recipients.

Example request:

curl --request GET \
    --get "https://app.addy.io/api/v1/recipients?filter%5Bverified%5D=true" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest"

const url = new URL(
    "https://app.addy.io/api/v1/recipients"
);

const params = {
    "filter[verified]": "true",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.addy.io/api/v1/recipients',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'query' => [
            'filter[verified]'=> 'true',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/recipients'
params = {
  'filter[verified]': 'true',
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Example response (200):


{
    "data": [
        {
            "id": "46eebc50-f7f8-46d7-beb9-c37f04c29a84",
            "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
            "email": "me@example.com",
            "can_reply_send": true,
            "should_encrypt": false,
            "inline_encryption": false,
            "protected_headers": false,
            "fingerprint": null,
            "email_verified_at": "2019-10-01 09:00:00",
            "aliases_count": 5,
            "created_at": "2019-10-01 09:00:00",
            "updated_at": "2019-10-01 09:00:00"
        },
        {
            "id": "8f515035-efed-4daa-b708-9692a155fa14",
            "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
            "email": "hello@example.com",
            "can_reply_send": true,
            "should_encrypt": false,
            "inline_encryption": false,
            "protected_headers": false,
            "fingerprint": null,
            "email_verified_at": "2019-10-01 09:00:00",
            "aliases_count": 0,
            "created_at": "2019-10-01 09:00:00",
            "updated_at": "2019-10-01 09:00:00"
        }
    ]
}

Received response:

Request failed with error:

Get a Specific Recipient

requires authentication

This endpoint retrieves a specific recipient.

Example request:

curl --request GET \
    --get "https://app.addy.io/api/v1/recipients/46eebc50-f7f8-46d7-beb9-c37f04c29a84" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest"

const url = new URL(
    "https://app.addy.io/api/v1/recipients/46eebc50-f7f8-46d7-beb9-c37f04c29a84"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.addy.io/api/v1/recipients/46eebc50-f7f8-46d7-beb9-c37f04c29a84',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/recipients/46eebc50-f7f8-46d7-beb9-c37f04c29a84'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (200):


{
    "data": {
        "id": "46eebc50-f7f8-46d7-beb9-c37f04c29a84",
        "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
        "email": "me@example.com",
        "can_reply_send": true,
        "should_encrypt": false,
        "inline_encryption": false,
        "protected_headers": false,
        "fingerprint": null,
        "email_verified_at": null,
        "aliases_count": 5,
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00"
    }
}

Received response:

Request failed with error:

Create New Recipient

requires authentication

This endpoint creates a new recipient.

Example request:

curl --request POST \
    "https://app.addy.io/api/v1/recipients" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"email\": \"me@example.com\"
}"

const url = new URL(
    "https://app.addy.io/api/v1/recipients"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

let body = {
    "email": "me@example.com"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.addy.io/api/v1/recipients',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'email' => 'me@example.com',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/recipients'
payload = {
    "email": "me@example.com"
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (201):


{
    "data": {
        "id": "46eebc50-f7f8-46d7-beb9-c37f04c29a84",
        "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
        "email": "me@example.com",
        "can_reply_send": true,
        "should_encrypt": false,
        "inline_encryption": false,
        "protected_headers": false,
        "fingerprint": null,
        "email_verified_at": null,
        "aliases_count": 0,
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00"
    }
}

Received response:

Request failed with error:

Delete a Specific Recipient

requires authentication

This endpoint deletes a specific recipient.

Example request:

curl --request DELETE \
    "https://app.addy.io/api/v1/recipients/46eebc50-f7f8-46d7-beb9-c37f04c29a84" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest"

const url = new URL(
    "https://app.addy.io/api/v1/recipients/46eebc50-f7f8-46d7-beb9-c37f04c29a84"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://app.addy.io/api/v1/recipients/46eebc50-f7f8-46d7-beb9-c37f04c29a84',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/recipients/46eebc50-f7f8-46d7-beb9-c37f04c29a84'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Example response (204):

[Empty response]

Received response:

Request failed with error:

Resend the verification email for a recipient

requires authentication

This endpoint can be used to resend the verification email when adding a new recipient

Example request:

curl --request POST \
    "https://app.addy.io/api/v1/recipients/email/resend" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"recipient_id\": \"46eebc50-f7f8-46d7-beb9-c37f04c29a84\"
}"

const url = new URL(
    "https://app.addy.io/api/v1/recipients/email/resend"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

let body = {
    "recipient_id": "46eebc50-f7f8-46d7-beb9-c37f04c29a84"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.addy.io/api/v1/recipients/email/resend',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'recipient_id' => '46eebc50-f7f8-46d7-beb9-c37f04c29a84',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/recipients/email/resend'
payload = {
    "recipient_id": "46eebc50-f7f8-46d7-beb9-c37f04c29a84"
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200):

{}

Received response:

Request failed with error:

Add Public Key for a Specific Recipient

requires authentication

This endpoint adds a public GPG/OpenPGP key for a specific recipient. Make sure to escape the json using something like - https://jsonformatter.org/json-escape

Example request:

curl --request PATCH \
    "https://app.addy.io/api/v1/recipient-keys/46eebc50-f7f8-46d7-beb9-c37f04c29a84" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"key_data\": \"-----BEGIN PGP PUBLIC KEY BLOCK-----\"
}"

const url = new URL(
    "https://app.addy.io/api/v1/recipient-keys/46eebc50-f7f8-46d7-beb9-c37f04c29a84"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

let body = {
    "key_data": "-----BEGIN PGP PUBLIC KEY BLOCK-----"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'https://app.addy.io/api/v1/recipient-keys/46eebc50-f7f8-46d7-beb9-c37f04c29a84',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'key_data' => '-----BEGIN PGP PUBLIC KEY BLOCK-----',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/recipient-keys/46eebc50-f7f8-46d7-beb9-c37f04c29a84'
payload = {
    "key_data": "-----BEGIN PGP PUBLIC KEY BLOCK-----"
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Example response (200):


{
    "data": {
        "id": "46eebc50-f7f8-46d7-beb9-c37f04c29a84",
        "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
        "email": "me@example.com",
        "can_reply_send": true,
        "should_encrypt": true,
        "inline_encryption": false,
        "protected_headers": false,
        "fingerprint": "70E400B5064061EB84181DABEDADE14D67325B36",
        "email_verified_at": "2019-10-01 09:00:00",
        "aliases_count": 5,
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00"
    }
}

Received response:

Request failed with error:

Remove Public Key for a Specific Recipient

requires authentication

This endpoint remnoves a public GPG/OpenPGP key for a specific recipient.

Example request:

curl --request DELETE \
    "https://app.addy.io/api/v1/recipient-keys/46eebc50-f7f8-46d7-beb9-c37f04c29a84" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest"

const url = new URL(
    "https://app.addy.io/api/v1/recipient-keys/46eebc50-f7f8-46d7-beb9-c37f04c29a84"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://app.addy.io/api/v1/recipient-keys/46eebc50-f7f8-46d7-beb9-c37f04c29a84',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/recipient-keys/46eebc50-f7f8-46d7-beb9-c37f04c29a84'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Example response (204):

[Empty response]

Received response:

Request failed with error:

Enable Encryption for a Specific Recipient

requires authentication

This endpoint enables encryption for a specific recipient.

Example request:

curl --request POST \
    "https://app.addy.io/api/v1/encrypted-recipients" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"id\": \"46eebc50-f7f8-46d7-beb9-c37f04c29a84\"
}"

const url = new URL(
    "https://app.addy.io/api/v1/encrypted-recipients"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

let body = {
    "id": "46eebc50-f7f8-46d7-beb9-c37f04c29a84"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.addy.io/api/v1/encrypted-recipients',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'id' => '46eebc50-f7f8-46d7-beb9-c37f04c29a84',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/encrypted-recipients'
payload = {
    "id": "46eebc50-f7f8-46d7-beb9-c37f04c29a84"
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200):


{
    "data": {
        "id": "46eebc50-f7f8-46d7-beb9-c37f04c29a84",
        "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
        "email": "me@example.com",
        "can_reply_send": true,
        "should_encrypt": true,
        "inline_encryption": false,
        "protected_headers": false,
        "fingerprint": "70E400B5064061EB84181DABEDADE14D67325B36",
        "email_verified_at": "2019-10-01 09:00:00",
        "aliases_count": 5,
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00"
    }
}

Received response:

Request failed with error:

Disable Encryption for a Specific Recipient

requires authentication

This endpoint disables encryption for a specific recipient.

Example request:

curl --request DELETE \
    "https://app.addy.io/api/v1/encrypted-recipients/46eebc50-f7f8-46d7-beb9-c37f04c29a84" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest"

const url = new URL(
    "https://app.addy.io/api/v1/encrypted-recipients/46eebc50-f7f8-46d7-beb9-c37f04c29a84"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://app.addy.io/api/v1/encrypted-recipients/46eebc50-f7f8-46d7-beb9-c37f04c29a84',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/encrypted-recipients/46eebc50-f7f8-46d7-beb9-c37f04c29a84'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Example response (204):

[Empty response]

Received response:

Request failed with error:

Enable Inline (PGP/Inline) Encryption for a Specific Recipient

requires authentication

This endpoint enables inline encryption for a specific recipient.

Example request:

curl --request POST \
    "https://app.addy.io/api/v1/inline-encrypted-recipients" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"id\": \"46eebc50-f7f8-46d7-beb9-c37f04c29a84\"
}"

const url = new URL(
    "https://app.addy.io/api/v1/inline-encrypted-recipients"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

let body = {
    "id": "46eebc50-f7f8-46d7-beb9-c37f04c29a84"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.addy.io/api/v1/inline-encrypted-recipients',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'id' => '46eebc50-f7f8-46d7-beb9-c37f04c29a84',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/inline-encrypted-recipients'
payload = {
    "id": "46eebc50-f7f8-46d7-beb9-c37f04c29a84"
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200):


{
    "data": {
        "id": "46eebc50-f7f8-46d7-beb9-c37f04c29a84",
        "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
        "email": "me@example.com",
        "can_reply_send": true,
        "should_encrypt": true,
        "inline_encryption": true,
        "protected_headers": false,
        "fingerprint": "70E400B5064061EB84181DABEDADE14D67325B36",
        "email_verified_at": "2019-10-01 09:00:00",
        "aliases_count": 5,
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00"
    }
}

Received response:

Request failed with error:

Disable Inline (PGP/Inline) Encryption for a Specific Recipient

requires authentication

This endpoint disables inline encryption for a specific recipient.

Example request:

curl --request DELETE \
    "https://app.addy.io/api/v1/inline-encrypted-recipients/46eebc50-f7f8-46d7-beb9-c37f04c29a84" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest"

const url = new URL(
    "https://app.addy.io/api/v1/inline-encrypted-recipients/46eebc50-f7f8-46d7-beb9-c37f04c29a84"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://app.addy.io/api/v1/inline-encrypted-recipients/46eebc50-f7f8-46d7-beb9-c37f04c29a84',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/inline-encrypted-recipients/46eebc50-f7f8-46d7-beb9-c37f04c29a84'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Example response (204):

[Empty response]

Received response:

Request failed with error:

Enable Protected Headers (hide subject) for a Specific Recipient

requires authentication

This endpoint enables protected headers which hides the message subject for a specific recipient.

Example request:

curl --request POST \
    "https://app.addy.io/api/v1/protected-headers-recipients" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"id\": \"46eebc50-f7f8-46d7-beb9-c37f04c29a84\"
}"

const url = new URL(
    "https://app.addy.io/api/v1/protected-headers-recipients"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

let body = {
    "id": "46eebc50-f7f8-46d7-beb9-c37f04c29a84"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.addy.io/api/v1/protected-headers-recipients',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'id' => '46eebc50-f7f8-46d7-beb9-c37f04c29a84',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/protected-headers-recipients'
payload = {
    "id": "46eebc50-f7f8-46d7-beb9-c37f04c29a84"
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200):


{
    "data": {
        "id": "46eebc50-f7f8-46d7-beb9-c37f04c29a84",
        "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
        "email": "me@example.com",
        "can_reply_send": true,
        "should_encrypt": true,
        "inline_encryption": false,
        "protected_headers": true,
        "fingerprint": "70E400B5064061EB84181DABEDADE14D67325B36",
        "email_verified_at": "2019-10-01 09:00:00",
        "aliases_count": 5,
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00"
    }
}

Received response:

Request failed with error:

Disable Protected Headers (hide subject) for a Specific Recipient

requires authentication

This endpoint disables protected headers for a specific recipient.

Example request:

curl --request DELETE \
    "https://app.addy.io/api/v1/protected-headers-recipients/46eebc50-f7f8-46d7-beb9-c37f04c29a84" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest"

const url = new URL(
    "https://app.addy.io/api/v1/protected-headers-recipients/46eebc50-f7f8-46d7-beb9-c37f04c29a84"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://app.addy.io/api/v1/protected-headers-recipients/46eebc50-f7f8-46d7-beb9-c37f04c29a84',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/protected-headers-recipients/46eebc50-f7f8-46d7-beb9-c37f04c29a84'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Example response (204):

[Empty response]

Received response:

Request failed with error:

Allow a Specific Recipient to reply/send from your aliases

requires authentication

This endpoint allows a specific recipient to reply/send.

Example request:

curl --request POST \
    "https://app.addy.io/api/v1/allowed-recipients" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"id\": \"46eebc50-f7f8-46d7-beb9-c37f04c29a84\"
}"

const url = new URL(
    "https://app.addy.io/api/v1/allowed-recipients"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

let body = {
    "id": "46eebc50-f7f8-46d7-beb9-c37f04c29a84"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.addy.io/api/v1/allowed-recipients',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'id' => '46eebc50-f7f8-46d7-beb9-c37f04c29a84',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/allowed-recipients'
payload = {
    "id": "46eebc50-f7f8-46d7-beb9-c37f04c29a84"
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200):


{
    "data": {
        "id": "46eebc50-f7f8-46d7-beb9-c37f04c29a84",
        "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
        "email": "me@example.com",
        "can_reply_send": true,
        "should_encrypt": true,
        "inline_encryption": false,
        "protected_headers": false,
        "fingerprint": "70E400B5064061EB84181DABEDADE14D67325B36",
        "email_verified_at": "2019-10-01 09:00:00",
        "aliases_count": 5,
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00"
    }
}

Received response:

Request failed with error:

Disallow a Specific Recipient to reply/send from your aliases

requires authentication

This endpoint disallows a specific recipient to reply/send.

Example request:

curl --request DELETE \
    "https://app.addy.io/api/v1/allowed-recipients/46eebc50-f7f8-46d7-beb9-c37f04c29a84" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest"

const url = new URL(
    "https://app.addy.io/api/v1/allowed-recipients/46eebc50-f7f8-46d7-beb9-c37f04c29a84"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://app.addy.io/api/v1/allowed-recipients/46eebc50-f7f8-46d7-beb9-c37f04c29a84',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/allowed-recipients/46eebc50-f7f8-46d7-beb9-c37f04c29a84'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Example response (204):

[Empty response]

Received response:

Request failed with error:

Rules

Get All Rules

requires authentication

This endpoint retrieves all rules.

Example request:

curl --request GET \
    --get "https://app.addy.io/api/v1/rules" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest"

const url = new URL(
    "https://app.addy.io/api/v1/rules"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.addy.io/api/v1/rules',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/rules'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (200):


{
    "data": [
        {
            "id": "50c9e585-e7f5-41c4-9016-9014c15454bc",
            "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
            "name": "First Rule",
            "order": 0,
            "conditions": [
                {
                    "type": "sender",
                    "match": "is not",
                    "values": [
                        "will@anonaddy.com"
                    ]
                }
            ],
            "actions": [
                {
                    "type": "subject",
                    "value": "New Subject"
                }
            ],
            "operator": "AND",
            "forwards": true,
            "replies": false,
            "sends": false,
            "active": true,
            "created_at": "2019-10-01 09:00:00",
            "updated_at": "2019-10-01 09:00:00"
        },
        {
            "id": "c549db7d-5fac-4b09-9443-9e47f644d29f",
            "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
            "name": "Second Rule",
            "order": 0,
            "conditions": [
                {
                    "type": "sender",
                    "match": "is exactly",
                    "values": [
                        "will@anonaddy.com"
                    ]
                }
            ],
            "actions": [
                {
                    "type": "subject",
                    "value": "Another Subject"
                }
            ],
            "operator": "OR",
            "forwards": true,
            "replies": false,
            "sends": false,
            "active": true,
            "created_at": "2019-10-01 09:00:00",
            "updated_at": "2019-10-01 09:00:00"
        }
    ]
}

Received response:

Request failed with error:

Get a Specific Rule

requires authentication

This endpoint retrieves a specific rule.

Example request:

curl --request GET \
    --get "https://app.addy.io/api/v1/rules/50c9e585-e7f5-41c4-9016-9014c15454bc" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest"

const url = new URL(
    "https://app.addy.io/api/v1/rules/50c9e585-e7f5-41c4-9016-9014c15454bc"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.addy.io/api/v1/rules/50c9e585-e7f5-41c4-9016-9014c15454bc',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/rules/50c9e585-e7f5-41c4-9016-9014c15454bc'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (200):


{
    "data": {
        "id": "50c9e585-e7f5-41c4-9016-9014c15454bc",
        "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
        "name": "First Rule",
        "order": 0,
        "conditions": [
            {
                "type": "sender",
                "match": "is exactly",
                "values": [
                    "will@anonaddy.com"
                ]
            }
        ],
        "actions": [
            {
                "type": "subject",
                "value": "New Subject!"
            }
        ],
        "operator": "AND",
        "forwards": true,
        "replies": false,
        "sends": false,
        "active": true,
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00"
    }
}

Received response:

Request failed with error:

Create New Rule

requires authentication

This endpoint creates a new rule.

Example request:

curl --request POST \
    "https://app.addy.io/api/v1/rules" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"name\": \"First Rule\",
    \"conditions\": [
        {
            \"type\": \"sender\",
            \"match\": \"is exactly\",
            \"values\": [
                \"will@anonaddy.com\"
            ]
        }
    ],
    \"actions\": [
        {
            \"type\": \"subject\",
            \"value\": \"New Subject!\"
        }
    ],
    \"operator\": \"AND\",
    \"forwards\": true,
    \"replies\": false,
    \"sends\": false
}"

const url = new URL(
    "https://app.addy.io/api/v1/rules"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

let body = {
    "name": "First Rule",
    "conditions": [
        {
            "type": "sender",
            "match": "is exactly",
            "values": [
                "will@anonaddy.com"
            ]
        }
    ],
    "actions": [
        {
            "type": "subject",
            "value": "New Subject!"
        }
    ],
    "operator": "AND",
    "forwards": true,
    "replies": false,
    "sends": false
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.addy.io/api/v1/rules',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'name' => 'First Rule',
            'conditions' => [
                [
                    'type' => 'sender',
                    'match' => 'is exactly',
                    'values' => [
                        'will@anonaddy.com',
                    ],
                ],
            ],
            'actions' => [
                [
                    'type' => 'subject',
                    'value' => 'New Subject!',
                ],
            ],
            'operator' => 'AND',
            'forwards' => true,
            'replies' => false,
            'sends' => false,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/rules'
payload = {
    "name": "First Rule",
    "conditions": [
        {
            "type": "sender",
            "match": "is exactly",
            "values": [
                "will@anonaddy.com"
            ]
        }
    ],
    "actions": [
        {
            "type": "subject",
            "value": "New Subject!"
        }
    ],
    "operator": "AND",
    "forwards": true,
    "replies": false,
    "sends": false
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (201):


{
    "data": {
        "id": "50c9e585-e7f5-41c4-9016-9014c15454bc",
        "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
        "name": "First Rule",
        "order": 0,
        "conditions": [
            {
                "type": "sender",
                "match": "is exactly",
                "values": [
                    "will@anonaddy.com"
                ]
            }
        ],
        "actions": [
            {
                "type": "subject",
                "value": "New Subject!"
            }
        ],
        "operator": "AND",
        "forwards": true,
        "replies": false,
        "sends": false,
        "active": true,
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00"
    }
}

Received response:

Request failed with error:

Request

POST api/v1/rules

Body Parameters

name string

The name of the rule

conditions object

The conditions for the rule.

type string

The type for the condition, options - sender, subject, alias.

match string optional

The match type for the condition, options - is exactly, is not, contains, does not contain, starts with, does not start with, ends with, does not end with.

values string[]

The array of values you would like to match.

actions object

The actions for the rule.

type string

The type for the action, options - subject, displayFrom, encryption, banner, block.

value string

The value for the action.

operator string optional

The chosen operator for the rule, options - AND, OR

forwards boolean optional true false

Whether to apply rule to forwarded messages.

replies boolean optional true false

Whether to apply rule to replies from aliases.

sends boolean optional true false

Whether to apply rule to sends from aliases.

Update a Specific Rule

requires authentication

This endpoint updates a specific rule.

Example request:

curl --request PATCH \
    "https://app.addy.io/api/v1/rules/50c9e585-e7f5-41c4-9016-9014c15454bc" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"name\": \"New Name\",
    \"conditions\": [
        {
            \"type\": \"sender\",
            \"match\": \"is exactly\",
            \"values\": [
                \"will@anonaddy.com\"
            ]
        }
    ],
    \"actions\": [
        {
            \"type\": \"subject\",
            \"value\": \"New Subject!\"
        }
    ],
    \"operator\": \"AND\",
    \"forwards\": true,
    \"replies\": false,
    \"sends\": false
}"

const url = new URL(
    "https://app.addy.io/api/v1/rules/50c9e585-e7f5-41c4-9016-9014c15454bc"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

let body = {
    "name": "New Name",
    "conditions": [
        {
            "type": "sender",
            "match": "is exactly",
            "values": [
                "will@anonaddy.com"
            ]
        }
    ],
    "actions": [
        {
            "type": "subject",
            "value": "New Subject!"
        }
    ],
    "operator": "AND",
    "forwards": true,
    "replies": false,
    "sends": false
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'https://app.addy.io/api/v1/rules/50c9e585-e7f5-41c4-9016-9014c15454bc',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'name' => 'New Name',
            'conditions' => [
                [
                    'type' => 'sender',
                    'match' => 'is exactly',
                    'values' => [
                        'will@anonaddy.com',
                    ],
                ],
            ],
            'actions' => [
                [
                    'type' => 'subject',
                    'value' => 'New Subject!',
                ],
            ],
            'operator' => 'AND',
            'forwards' => true,
            'replies' => false,
            'sends' => false,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/rules/50c9e585-e7f5-41c4-9016-9014c15454bc'
payload = {
    "name": "New Name",
    "conditions": [
        {
            "type": "sender",
            "match": "is exactly",
            "values": [
                "will@anonaddy.com"
            ]
        }
    ],
    "actions": [
        {
            "type": "subject",
            "value": "New Subject!"
        }
    ],
    "operator": "AND",
    "forwards": true,
    "replies": false,
    "sends": false
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Example response (200):


{
    "data": {
        "id": "50c9e585-e7f5-41c4-9016-9014c15454bc",
        "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
        "name": "New Name",
        "order": 0,
        "conditions": [
            {
                "type": "sender",
                "match": "is exactly",
                "values": [
                    "will@anonaddy.com"
                ]
            }
        ],
        "actions": [
            {
                "type": "subject",
                "value": "New Subject!"
            }
        ],
        "operator": "AND",
        "forwards": true,
        "replies": false,
        "sends": false,
        "active": true,
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00"
    }
}

Received response:

Request failed with error:

Request

PATCH api/v1/rules/{id}

URL Parameters

id string

The id of the rule to update

Body Parameters

name string

The name of the rule

conditions object

The conditions for the rule.

type string

The type for the condition, options - sender, subject, alias.

match string optional

The match type for the condition, options - is exactly, is not, contains, does not contain, starts with, does not start with, ends with, does not end with.

values string[]

The array of values you would like to match.

actions object

The actions for the rule.

type string

The type for the action, options - subject, displayFrom, encryption, banner, block.

value string

The value for the action.

operator string optional

The chosen operator for the rule, options - AND, OR

forwards boolean optional true false

Whether to apply rule to forwarded messages.

replies boolean optional true false

Whether to apply rule to replies from aliases.

sends boolean optional true false

Whether to apply rule to sends from aliases.

Delete a Specific Rule

requires authentication

This endpoint deletes a specific rule.

Example request:

curl --request DELETE \
    "https://app.addy.io/api/v1/rules/50c9e585-e7f5-41c4-9016-9014c15454bc" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest"

const url = new URL(
    "https://app.addy.io/api/v1/rules/50c9e585-e7f5-41c4-9016-9014c15454bc"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://app.addy.io/api/v1/rules/50c9e585-e7f5-41c4-9016-9014c15454bc',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/rules/50c9e585-e7f5-41c4-9016-9014c15454bc'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Example response (204):

[Empty response]

Received response:

Request failed with error:

Update the order of the Rules

requires authentication

This endpoint updates the order of the rules.

Example request:

curl --request POST \
    "https://app.addy.io/api/v1/reorder-rules" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"ids\": [
        \"c549db7d-5fac-4b09-9443-9e47f644d29f\",
        \"50c9e585-e7f5-41c4-9016-9014c15454bc\"
    ]
}"

const url = new URL(
    "https://app.addy.io/api/v1/reorder-rules"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

let body = {
    "ids": [
        "c549db7d-5fac-4b09-9443-9e47f644d29f",
        "50c9e585-e7f5-41c4-9016-9014c15454bc"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.addy.io/api/v1/reorder-rules',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'ids' => [
                'c549db7d-5fac-4b09-9443-9e47f644d29f',
                '50c9e585-e7f5-41c4-9016-9014c15454bc',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/reorder-rules'
payload = {
    "ids": [
        "c549db7d-5fac-4b09-9443-9e47f644d29f",
        "50c9e585-e7f5-41c4-9016-9014c15454bc"
    ]
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200):

{}

Received response:

Request failed with error:

Activate a Specific Rule

requires authentication

This endpoint activates a specific Rule.

Example request:

curl --request POST \
    "https://app.addy.io/api/v1/active-rules" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"id\": \"50c9e585-e7f5-41c4-9016-9014c15454bc\"
}"

const url = new URL(
    "https://app.addy.io/api/v1/active-rules"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

let body = {
    "id": "50c9e585-e7f5-41c4-9016-9014c15454bc"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.addy.io/api/v1/active-rules',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'id' => '50c9e585-e7f5-41c4-9016-9014c15454bc',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/active-rules'
payload = {
    "id": "50c9e585-e7f5-41c4-9016-9014c15454bc"
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200):


{
    "data": {
        "id": "50c9e585-e7f5-41c4-9016-9014c15454bc",
        "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
        "name": "First Rule",
        "order": 0,
        "conditions": [
            {
                "type": "sender",
                "match": "is exactly",
                "values": [
                    "will@anonaddy.com"
                ]
            }
        ],
        "actions": [
            {
                "type": "subject",
                "value": "New Subject!"
            }
        ],
        "operator": "AND",
        "forwards": true,
        "replies": false,
        "sends": false,
        "active": true,
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00"
    }
}

Received response:

Request failed with error:

Deactivate a Specific Rule

requires authentication

This endpoint deactivates a specific rule.

Example request:

curl --request DELETE \
    "https://app.addy.io/api/v1/active-rules/50c9e585-e7f5-41c4-9016-9014c15454bc" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest"

const url = new URL(
    "https://app.addy.io/api/v1/active-rules/50c9e585-e7f5-41c4-9016-9014c15454bc"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://app.addy.io/api/v1/active-rules/50c9e585-e7f5-41c4-9016-9014c15454bc',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/active-rules/50c9e585-e7f5-41c4-9016-9014c15454bc'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Example response (204):

[Empty response]

Received response:

Request failed with error:

Usernames

Get All Usernames

requires authentication

This endpoint retrieves all usernames.

Example request:

curl --request GET \
    --get "https://app.addy.io/api/v1/usernames" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest"

const url = new URL(
    "https://app.addy.io/api/v1/usernames"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.addy.io/api/v1/usernames',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/usernames'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (200):


{
    "data": [
        {
            "id": "2777dee6-1721-45c0-8d01-698b6be2335f",
            "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
            "username": "johndoe",
            "description": null,
            "from_name": null,
            "aliases_count": 5,
            "default_recipient": null,
            "active": true,
            "catch_all": true,
            "can_login": true,
            "created_at": "2019-10-01 09:00:00",
            "updated_at": "2019-10-01 09:00:00"
        },
        {
            "id": "ede18c01-9de2-40f4-8cce-c1e9f623ef2d",
            "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
            "username": "janedoe",
            "description": null,
            "from_name": null,
            "aliases_count": 0,
            "default_recipient": null,
            "active": true,
            "catch_all": true,
            "can_login": true,
            "created_at": "2019-10-01 09:00:00",
            "updated_at": "2019-10-01 09:00:00"
        }
    ]
}

Received response:

Request failed with error:

Get a Specific Username

requires authentication

This endpoint retrieves a specific username.

Example request:

curl --request GET \
    --get "https://app.addy.io/api/v1/usernames/2777dee6-1721-45c0-8d01-698b6be2335f" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest"

const url = new URL(
    "https://app.addy.io/api/v1/usernames/2777dee6-1721-45c0-8d01-698b6be2335f"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://app.addy.io/api/v1/usernames/2777dee6-1721-45c0-8d01-698b6be2335f',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/usernames/2777dee6-1721-45c0-8d01-698b6be2335f'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (200):


{
    "data": {
        "id": "2777dee6-1721-45c0-8d01-698b6be2335f",
        "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
        "username": "johndoe",
        "description": null,
        "from_name": null,
        "aliases_count": 5,
        "default_recipient": null,
        "active": true,
        "catch_all": true,
        "can_login": true,
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00"
    }
}

Received response:

Request failed with error:

Create New Username

requires authentication

This endpoint creates a new username.

Example request:

curl --request POST \
    "https://app.addy.io/api/v1/usernames" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"username\": \"johndoe\"
}"

const url = new URL(
    "https://app.addy.io/api/v1/usernames"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

let body = {
    "username": "johndoe"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.addy.io/api/v1/usernames',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'username' => 'johndoe',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/usernames'
payload = {
    "username": "johndoe"
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (201):


{
    "data": {
        "id": "2777dee6-1721-45c0-8d01-698b6be2335f",
        "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
        "username": "johndoe",
        "description": null,
        "from_name": null,
        "aliases_count": 0,
        "default_recipient": null,
        "active": true,
        "catch_all": true,
        "can_login": true,
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00"
    }
}

Received response:

Request failed with error:

Update a Specific Username

requires authentication

This endpoint updates a specific username.

Example request:

curl --request PATCH \
    "https://app.addy.io/api/v1/usernames/2777dee6-1721-45c0-8d01-698b6be2335f" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"description\": \"New description\",
    \"from_name\": \"John\"
}"

const url = new URL(
    "https://app.addy.io/api/v1/usernames/2777dee6-1721-45c0-8d01-698b6be2335f"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

let body = {
    "description": "New description",
    "from_name": "John"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'https://app.addy.io/api/v1/usernames/2777dee6-1721-45c0-8d01-698b6be2335f',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'description' => 'New description',
            'from_name' => 'John',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/usernames/2777dee6-1721-45c0-8d01-698b6be2335f'
payload = {
    "description": "New description",
    "from_name": "John"
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Example response (200):


{
    "data": {
        "id": "2777dee6-1721-45c0-8d01-698b6be2335f",
        "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
        "username": "johndoe",
        "description": "New description",
        "from_name": "John",
        "aliases_count": 5,
        "default_recipient": null,
        "active": true,
        "catch_all": true,
        "can_login": true,
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00"
    }
}

Received response:

Request failed with error:

Delete a Specific Username

requires authentication

This endpoint deletes a specific username.

Example request:

curl --request DELETE \
    "https://app.addy.io/api/v1/usernames/2777dee6-1721-45c0-8d01-698b6be2335f" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest"

const url = new URL(
    "https://app.addy.io/api/v1/usernames/2777dee6-1721-45c0-8d01-698b6be2335f"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://app.addy.io/api/v1/usernames/2777dee6-1721-45c0-8d01-698b6be2335f',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/usernames/2777dee6-1721-45c0-8d01-698b6be2335f'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Example response (204):

[Empty response]

Received response:

Request failed with error:

Update Default Recipient for a Specific Username

requires authentication

This endpoint updates the default recipient for a specific username.

Example request:

curl --request PATCH \
    "https://app.addy.io/api/v1/usernames/2777dee6-1721-45c0-8d01-698b6be2335f/default-recipient" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"default_recipient\": \"46eebc50-f7f8-46d7-beb9-c37f04c29a84\"
}"

const url = new URL(
    "https://app.addy.io/api/v1/usernames/2777dee6-1721-45c0-8d01-698b6be2335f/default-recipient"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

let body = {
    "default_recipient": "46eebc50-f7f8-46d7-beb9-c37f04c29a84"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'https://app.addy.io/api/v1/usernames/2777dee6-1721-45c0-8d01-698b6be2335f/default-recipient',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'default_recipient' => '46eebc50-f7f8-46d7-beb9-c37f04c29a84',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/usernames/2777dee6-1721-45c0-8d01-698b6be2335f/default-recipient'
payload = {
    "default_recipient": "46eebc50-f7f8-46d7-beb9-c37f04c29a84"
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Example response (200):


{
    "data": {
        "id": "2777dee6-1721-45c0-8d01-698b6be2335f",
        "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
        "username": "johndoe",
        "description": null,
        "from_name": null,
        "aliases_count": 5,
        "default_recipient": {
            "id": "46eebc50-f7f8-46d7-beb9-c37f04c29a84",
            "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
            "email": "me@example.com",
            "can_reply_send": true,
            "should_encrypt": false,
            "inline_encryption": false,
            "protected_headers": false,
            "fingerprint": null,
            "email_verified_at": "2019-10-01 09:00:00",
            "created_at": "2019-10-01 09:00:00",
            "updated_at": "2019-10-01 09:00:00"
        },
        "active": true,
        "catch_all": true,
        "can_login": true,
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00"
    }
}

Received response:

Request failed with error:

Activate a Specific Username

requires authentication

This endpoint activates a specific username.

Example request:

curl --request POST \
    "https://app.addy.io/api/v1/active-usernames" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"id\": \"2777dee6-1721-45c0-8d01-698b6be2335f\"
}"

const url = new URL(
    "https://app.addy.io/api/v1/active-usernames"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

let body = {
    "id": "2777dee6-1721-45c0-8d01-698b6be2335f"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.addy.io/api/v1/active-usernames',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'id' => '2777dee6-1721-45c0-8d01-698b6be2335f',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/active-usernames'
payload = {
    "id": "2777dee6-1721-45c0-8d01-698b6be2335f"
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200):


{
    "data": {
        "id": "2777dee6-1721-45c0-8d01-698b6be2335f",
        "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
        "username": "johndoe",
        "description": null,
        "from_name": null,
        "aliases_count": 5,
        "default_recipient": null,
        "active": true,
        "catch_all": true,
        "can_login": true,
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00"
    }
}

Received response:

Request failed with error:

Deactivate a Specific Username

requires authentication

This endpoint deactivates a specific username.

Example request:

curl --request DELETE \
    "https://app.addy.io/api/v1/active-usernames/2777dee6-1721-45c0-8d01-698b6be2335f" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest"

const url = new URL(
    "https://app.addy.io/api/v1/active-usernames/2777dee6-1721-45c0-8d01-698b6be2335f"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://app.addy.io/api/v1/active-usernames/2777dee6-1721-45c0-8d01-698b6be2335f',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/active-usernames/2777dee6-1721-45c0-8d01-698b6be2335f'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Example response (204):

[Empty response]

Received response:

Request failed with error:

Enable catch-all for a Specific Username

requires authentication

This endpoint enables catch-all a specific username.

Example request:

curl --request POST \
    "https://app.addy.io/api/v1/catch-all-usernames" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"id\": \"2777dee6-1721-45c0-8d01-698b6be2335f\"
}"

const url = new URL(
    "https://app.addy.io/api/v1/catch-all-usernames"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

let body = {
    "id": "2777dee6-1721-45c0-8d01-698b6be2335f"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.addy.io/api/v1/catch-all-usernames',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'id' => '2777dee6-1721-45c0-8d01-698b6be2335f',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/catch-all-usernames'
payload = {
    "id": "2777dee6-1721-45c0-8d01-698b6be2335f"
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200):


{
    "data": {
        "id": "2777dee6-1721-45c0-8d01-698b6be2335f",
        "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
        "username": "johndoe",
        "description": null,
        "from_name": null,
        "aliases_count": 5,
        "default_recipient": null,
        "active": true,
        "catch_all": true,
        "can_login": true,
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00"
    }
}

Received response:

Request failed with error:

Disable catch-all for a Specific Username

requires authentication

This endpoint disables catch-all for a specific username.

Example request:

curl --request DELETE \
    "https://app.addy.io/api/v1/catch-all-usernames/2777dee6-1721-45c0-8d01-698b6be2335f" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest"

const url = new URL(
    "https://app.addy.io/api/v1/catch-all-usernames/2777dee6-1721-45c0-8d01-698b6be2335f"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://app.addy.io/api/v1/catch-all-usernames/2777dee6-1721-45c0-8d01-698b6be2335f',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/catch-all-usernames/2777dee6-1721-45c0-8d01-698b6be2335f'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Example response (204):

[Empty response]

Received response:

Request failed with error:

Allow login for a Specific Username

requires authentication

This endpoint gives a specific username the ability to login to your account.

Example request:

curl --request POST \
    "https://app.addy.io/api/v1/loginable-usernames" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"id\": \"2777dee6-1721-45c0-8d01-698b6be2335f\"
}"

const url = new URL(
    "https://app.addy.io/api/v1/loginable-usernames"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

let body = {
    "id": "2777dee6-1721-45c0-8d01-698b6be2335f"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://app.addy.io/api/v1/loginable-usernames',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'id' => '2777dee6-1721-45c0-8d01-698b6be2335f',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/loginable-usernames'
payload = {
    "id": "2777dee6-1721-45c0-8d01-698b6be2335f"
}
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200):


{
    "data": {
        "id": "2777dee6-1721-45c0-8d01-698b6be2335f",
        "user_id": "ca0a4e09-c266-4f6f-845c-958db5090f09",
        "username": "johndoe",
        "description": null,
        "from_name": null,
        "aliases_count": 5,
        "default_recipient": null,
        "active": true,
        "catch_all": true,
        "can_login": true,
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00"
    }
}

Received response:

Request failed with error:

Disallow login for a Specific Username

requires authentication

This endpoint prevents a specific username from being able to login to your account.

Example request:

curl --request DELETE \
    "https://app.addy.io/api/v1/loginable-usernames/2777dee6-1721-45c0-8d01-698b6be2335f" \
    --header "Authorization: Bearer {token}" \
    --header "Content-Type: application/json" \
    --header "X-Requested-With: XMLHttpRequest"

const url = new URL(
    "https://app.addy.io/api/v1/loginable-usernames/2777dee6-1721-45c0-8d01-698b6be2335f"
);

const headers = {
    "Authorization": "Bearer {token}",
    "Content-Type": "application/json",
    "X-Requested-With": "XMLHttpRequest",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());


$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://app.addy.io/api/v1/loginable-usernames/2777dee6-1721-45c0-8d01-698b6be2335f',
    [
        'headers' => [
            'Authorization' => 'Bearer {token}',
            'Content-Type' => 'application/json',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://app.addy.io/api/v1/loginable-usernames/2777dee6-1721-45c0-8d01-698b6be2335f'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Example response (204):

[Empty response]

Received response:

Request failed with error:

Errors

The addy.io API uses the following error codes:

Error Code	Meaning
400	Bad Request -- Your request sucks
401	Unauthenticated -- Your API key is wrong
403	Forbidden -- You do not have permission to access the requested resource
404	Not Found -- The specified resource could not be found
405	Method Not Allowed -- You tried to access an endpoint with an invalid method
422	Validation Error -- The given data was invalid
429	Too Many Requests -- You're sending too many requests or have reached your limit for new aliases
500	Internal Server Error -- We had a problem with our server. Try again later
503	Service Unavailable -- We're temporarially offline for maintanance. Please try again later