MENU navbar-image

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
}

Request   

GET api/v1/api-token-details

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"
        }
    ]
}

Request   

GET api/v1/account-details

Account Notifications

Get All Account Notifications

requires authentication

This endpoint retrieves all account notifications.

Example request:
curl --request GET \
    --get "https://app.addy.io/api/v1/account-notifications" \
    --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-notifications"
);

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-notifications',
    [
        '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-notifications'
headers = {
  'Authorization': 'Bearer {token}',
  'Content-Type': 'application/json',
  'X-Requested-With': 'XMLHttpRequest'
}

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

Example response (200):


{
    "id": "a83b1763-7a63-4306-93cd-3b2e051db704",
    "category": "Announcement",
    "title": "Notification title",
    "text": "Notification text",
    "link": "https://addy.io/",
    "link_text": "Read More",
    "created_at": "2019-10-01 09:00:00"
}

Request   

GET api/v1/account-notifications

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
        }
    ]
}

Request   

POST api/v1/aliases/get/bulk

Body Parameters

ids  string[]  

An array of the alias ids (max 25)

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"
        ]
    }
}

Request   

POST api/v1/aliases/activate/bulk

Body Parameters

ids  string[]  

An array of the alias ids (max 25)

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"
        ]
    }
}

Request   

POST api/v1/aliases/deactivate/bulk

Body Parameters

ids  string[]  

An array of the alias ids (max 25)

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"
        ]
    }
}

Request   

POST api/v1/aliases/delete/bulk

Body Parameters

ids  string[]  

An array of the alias ids (max 25)

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"
        ]
    }
}

Request   

POST api/v1/aliases/restore/bulk

Body Parameters

ids  string[]  

An array of the alias ids (max 25)

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"
        ]
    }
}

Request   

POST api/v1/aliases/forget/bulk

Body Parameters

ids  string[]  

An array of the alias ids (max 25)

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"
        ]
    }
}

Request   

POST api/v1/aliases/recipients/bulk

Body Parameters

ids  string[]  

An array of the alias ids (max 25)

recipient_ids  string[]  

An array of recipient ids to add

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": "« 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 »",
                "active": false
            }
        ],
        "path": "https://app.addy.io/api/v1/aliases",
        "per_page": 10,
        "to": 2,
        "total": 2
    }
}

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, last_used, 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
    }
}

Request   

GET api/v1/aliases/{id}

URL Parameters

id  string  

The id of the alias to retrieve

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
    }
}

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
    }
}

Request   

PATCH api/v1/aliases/{id}

URL Parameters

id  string  

The id of the alias to update

Body Parameters

description  string optional  

The description of the alias

from_name  string optional  

The from name of the alias

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
    }
}

Request   

PATCH api/v1/aliases/{id}/restore

URL Parameters

id  string  

The id of the alias to restore

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]

Request   

DELETE api/v1/aliases/{id}

URL Parameters

id  string  

The id of the alias to delete

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]

Request   

DELETE api/v1/aliases/{id}/forget

URL Parameters

id  string  

The id of the alias to forget

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
    }
}

Request   

POST api/v1/active-aliases

Body Parameters

id  string  

The id for the alias

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]

Request   

DELETE api/v1/active-aliases/{id}

URL Parameters

id  string  

The id of the alias to deactivate

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
    }
}

Request   

POST api/v1/alias-recipients

Body Parameters

alias_id  string  

The id of the alias

recipient_ids  string[]  

An array of recipient ids to add

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
}

Request   

GET api/v1/app-version

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"
}

Request   

GET api/v1/domain-options

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,
            "auto_create_regex": null,
            "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,
            "auto_create_regex": null,
            "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"
        }
    ]
}

Request   

GET api/v1/domains

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,
        "auto_create_regex": null,
        "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"
    }
}

Request   

GET api/v1/domains/{id}

URL Parameters

id  string  

The id of the domain to retrieve

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,
        "auto_create_regex": null,
        "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"
    }
}

Request   

POST api/v1/domains

Body Parameters

domain  string  

The domain name of the domain

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\",
    \"auto_create_regex\": \"^prefix\"
}"

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",
    "auto_create_regex": "^prefix"
};

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',
            'auto_create_regex' => '^prefix',
        ],
    ]
);
$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",
    "auto_create_regex": "^prefix"
}
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,
        "auto_create_regex": "^prefix",
        "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"
    }
}

Request   

PATCH api/v1/domains/{id}

URL Parameters

id  string  

The id of the domain to update

Body Parameters

description  string optional  

The description of the domain

from_name  string optional  

The from name of the domain

auto_create_regex  string optional  

The regular expression that when matched can create aliases on-the-fly

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]

Request   

DELETE api/v1/domains/{id}

URL Parameters

id  string  

The id of the domain to delete

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,
        "auto_create_regex": null,
        "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"
    }
}

Request   

PATCH api/v1/domains/{id}/default-recipient

URL Parameters

id  string  

The id of the domain to update

Body Parameters

default_recipient  string optional  

The id of the recipient

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,
        "auto_create_regex": null,
        "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"
    }
}

Request   

POST api/v1/active-domains

Body Parameters

id  string  

The id for the domain

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]

Request   

DELETE api/v1/active-domains/{id}

URL Parameters

id  string  

The id of the domain to deactivate

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,
        "auto_create_regex": null,
        "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"
    }
}

Request   

POST api/v1/catch-all-domains

Body Parameters

id  string  

The id for the domain

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]

Request   

DELETE api/v1/catch-all-domains/{id}

URL Parameters

id  string  

The id of the domain to disable catch-all

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"
        }
    ]
}

Request   

GET api/v1/failed-deliveries

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"
    }
}

Request   

GET api/v1/failed-deliveries/{id}

URL Parameters

id  string  

The id of the failed delivery to retrieve

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]

Request   

DELETE api/v1/failed-deliveries/{id}

URL Parameters

id  string  

The id of the failed delivery to delete

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"
        }
    ]
}

Request   

GET api/v1/recipients

Query Parameters

filter[verified]  string optional  

Choose to return recipients that are verified or unverified. Options: true, false.

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"
    }
}

Request   

GET api/v1/recipients/{id}

URL Parameters

id  string  

The id of the recipient to retrieve

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"
    }
}

Request   

POST api/v1/recipients

Body Parameters

email  string  

The email of the recipient

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]

Request   

DELETE api/v1/recipients/{id}

URL Parameters

id  string  

The id of the recipient to delete

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):


{}

Request   

POST api/v1/recipients/email/resend

Body Parameters

recipient_id  string  

The ID of the recipient

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"
    }
}

Request   

PATCH api/v1/recipient-keys/{id}

URL Parameters

id  string  

The id of the recipient to add the key for

Body Parameters

key_data  string  

The public key data for the recipient

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]

Request   

DELETE api/v1/recipient-keys/{id}

URL Parameters

id  string  

The id of the recipient to remove the key for

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"
    }
}

Request   

POST api/v1/encrypted-recipients

Body Parameters

id  string  

The id for the recipient

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]

Request   

DELETE api/v1/encrypted-recipients/{id}

URL Parameters

id  string  

The id of the recipient to disable encryption for

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"
    }
}

Request   

POST api/v1/inline-encrypted-recipients

Body Parameters

id  string  

The id for the recipient

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]

Request   

DELETE api/v1/inline-encrypted-recipients/{id}

URL Parameters

id  string  

The id of the recipient to disable inline encryption for

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"
    }
}

Request   

POST api/v1/protected-headers-recipients

Body Parameters

id  string  

The id for the recipient

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]

Request   

DELETE api/v1/protected-headers-recipients/{id}

URL Parameters

id  string  

The id of the recipient to disable protected headers for

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"
    }
}

Request   

POST api/v1/allowed-recipients

Body Parameters

id  string  

The id for the recipient

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]

Request   

DELETE api/v1/allowed-recipients/{id}

URL Parameters

id  string  

The id of the recipient to disallow replies/sends for

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,
            "applied": 5,
            "last_applied": "2019-10-01 09:00:00",
            "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,
            "applied": 3,
            "last_applied": "2019-10-01 09:00:00",
            "created_at": "2019-10-01 09:00:00",
            "updated_at": "2019-10-01 09:00:00"
        }
    ]
}

Request   

GET api/v1/rules

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,
        "applied": 5,
        "last_applied": "2019-10-01 09:00:00",
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00"
    }
}

Request   

GET api/v1/rules/{id}

URL Parameters

id  string  

The id of the rule to retrieve

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,
        "applied": 0,
        "last_applied": null,
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00"
    }
}

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, alias_description.

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, matches regex, does not match regex.

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, removeAttachments, forwardTo.

value  string  

The value for the action, for forwardTo this is a recipient ID.

operator  string optional  

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

forwards  boolean optional  

Whether to apply rule to forwarded messages.

replies  boolean optional  

Whether to apply rule to replies from aliases.

sends  boolean optional  

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,
        "applied": 5,
        "last_applied": "2019-10-01 09:00:00",
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00"
    }
}

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, alias_description.

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, matches regex, does not match regex.

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, removeAttachments, forwardTo.

value  string  

The value for the action, for forwardTo this is a recipient ID.

operator  string optional  

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

forwards  boolean optional  

Whether to apply rule to forwarded messages.

replies  boolean optional  

Whether to apply rule to replies from aliases.

sends  boolean optional  

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]

Request   

DELETE api/v1/rules/{id}

URL Parameters

id  string  

The id of the rule to delete

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):


{}

Request   

POST api/v1/reorder-rules

Body Parameters

ids  string[]  

The new order of the rules

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,
        "applied": 5,
        "last_applied": "2019-10-01 09:00:00",
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00"
    }
}

Request   

POST api/v1/active-rules

Body Parameters

id  string  

The id for the rule

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]

Request   

DELETE api/v1/active-rules/{id}

URL Parameters

id  string  

The id of the rule to deactivate

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,
            "auto_create_regex": null,
            "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,
            "auto_create_regex": null,
            "can_login": true,
            "created_at": "2019-10-01 09:00:00",
            "updated_at": "2019-10-01 09:00:00"
        }
    ]
}

Request   

GET api/v1/usernames

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,
        "auto_create_regex": null,
        "can_login": true,
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00"
    }
}

Request   

GET api/v1/usernames/{id}

URL Parameters

id  string  

The id of the username to retrieve

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,
        "auto_create_regex": "^prefix",
        "can_login": true,
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00"
    }
}

Request   

POST api/v1/usernames

Body Parameters

username  string  

The username for the username

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\",
    \"auto_create_regex\": \"^prefix\"
}"

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",
    "auto_create_regex": "^prefix"
};

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',
            'auto_create_regex' => '^prefix',
        ],
    ]
);
$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",
    "auto_create_regex": "^prefix"
}
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,
        "auto_create_regex": null,
        "can_login": true,
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00"
    }
}

Request   

PATCH api/v1/usernames/{id}

URL Parameters

id  string  

The id of the username to update

Body Parameters

description  string optional  

The description of the username

from_name  string optional  

The from name of the username

auto_create_regex  string optional  

The regular expression that when matched can create aliases on-the-fly

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]

Request   

DELETE api/v1/usernames/{id}

URL Parameters

id  string  

The id of the username to delete

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,
        "auto_create_regex": null,
        "can_login": true,
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00"
    }
}

Request   

PATCH api/v1/usernames/{id}/default-recipient

URL Parameters

id  string  

The id of the username to update

Body Parameters

default_recipient  string optional  

The id of the recipient

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,
        "auto_create_regex": null,
        "can_login": true,
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00"
    }
}

Request   

POST api/v1/active-usernames

Body Parameters

id  string  

The id for the username

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]

Request   

DELETE api/v1/active-usernames/{id}

URL Parameters

id  string  

The id of the username to deactivate

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,
        "auto_create_regex": null,
        "can_login": true,
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00"
    }
}

Request   

POST api/v1/catch-all-usernames

Body Parameters

id  string  

The id for the username

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]

Request   

DELETE api/v1/catch-all-usernames/{id}

URL Parameters

id  string  

The id of the username to disable catch-all

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,
        "auto_create_regex": null,
        "can_login": true,
        "created_at": "2019-10-01 09:00:00",
        "updated_at": "2019-10-01 09:00:00"
    }
}

Request   

POST api/v1/loginable-usernames

Body Parameters

id  string  

The id for the username

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]

Request   

DELETE api/v1/loginable-usernames/{id}

URL Parameters

id  string  

The id of the username

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