Email Alias API Integration: Automate Alias Management with REST 邮件别名API集成：通过REST实现别名自动化管理 Integración de API de Alias de Correo: Automatiza la Gestión de Alias con REST Intégration API d'alias email : automatisez la gestion des alias avec REST メールエイリアスAPI統合ガイド：RESTでエイリアス管理を自動化する方法 E-Mail-Alias-API-Integration: Alias-Verwaltung per REST automatisieren Integração com API de Aliases de E-mail: Automatize o Gerenciamento com REST 이메일 별칭 API 통합: REST로 별칭 관리를 자동화하는 방법 Интеграция Email Alias API: автоматизируйте управление алиасами с помощью REST دمج واجهة برمجة تطبيقات البريد الإلكتروني البديل: أتمتة إدارة الأسماء البديلة باستخدام REST
Managing email aliases manually works for a handful of addresses. But when you scale to hundreds or thousands of aliases across multiple domains and teams, manual updates become a bottleneck. You need an API that lets you create, update, and delete aliases programmatically. This guide walks through everything you need to build an automated alias management system using REST API, with working code examples in Python and Node.js.
An email alias API lets you create, update, and delete aliases programmatically without touching a dashboard.
Instead of logging into a web interface every time a new customer signs up or a team member leaves, you can trigger alias operations from your own application logic. A typical SaaS company using GridInbox might create 200 to 500 aliases per week for onboarding new clients, then delete them when subscriptions end. That volume is unmanageable without automation.
Email Alias API: A RESTful interface that allows external applications to programmatically create, read, update, and delete email aliases on a mail server or alias management platform.
Modern alias platforms like GridInbox expose endpoints for every operation you would perform in a UI. This includes creating aliases, attaching them to specific domains, setting forwarding destinations, and managing permissions for team access.
Authentication for alias APIs uses API keys or OAuth tokens sent in request headers.
Every API call must be authenticated. Most providers, including GridInbox, use a simple API key passed as a Bearer token in the Authorization header. Never expose your API key in client-side code or version control. Store it in environment variables or a secrets manager.
Here is a basic authentication example in Python using the requests library:
import requests
API_KEY = "your_gridinbox_api_key"
BASE_URL = "https://api.gridinbox.com/v1"
headers = {
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json"
}
In Node.js, you can achieve the same with axios or the built-in fetch:
const API_KEY = process.env.GRIDINBOX_API_KEY;
const BASE_URL = "https://api.gridinbox.com/v1";
const headers = {
"Authorization": `Bearer ${API_KEY}`,
"Content-Type": "application/json"
};
Always use HTTPS. Never hardcode credentials. Rotate keys regularly, at least every 90 days.
Creating an email alias via API requires sending a POST request with the alias name, domain, and forwarding rules.
The most common operation is creating a new alias. You specify the local part (the part before the @), the domain, and where emails should be forwarded. Some platforms also let you set a display name and enable bidirectional sending.
Here is a Python function to create an alias with GridInbox:
def create_alias(local_part, domain, forward_to, display_name=None):
payload = {
"local_part": local_part,
"domain": domain,
"forward_to": forward_to,
"display_name": display_name or local_part
}
response = requests.post(
f"{BASE_URL}/aliases",
headers=headers,
json=payload
)
response.raise_for_status()
return response.json()
# Example: create [email protected] forwarding to [email protected]
result = create_alias("support", "mycompany.com", "[email protected]")
print(result["id"]) # e.g., "alias_abc123"
And the same operation in Node.js:
async function createAlias(localPart, domain, forwardTo, displayName) {
const payload = {
local_part: localPart,
domain: domain,
forward_to: forwardTo,
display_name: displayName || localPart
};
const response = await fetch(`${BASE_URL}/aliases`, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
});
if (!response.ok) throw new Error(`HTTP ${response.status}`);
return await response.json();
}
// Example
createAlias("billing", "mycompany.com", "[email protected]")
.then(data => console.log(data.id));
Remember to handle rate limits. GridInbox allows 1000 requests per minute per API key. If you are creating aliases in bulk, batch them with a delay of 60 milliseconds between calls to stay under the limit.
Managing aliases at scale means you need to list, update, and delete them using GET, PATCH, and DELETE endpoints.
Once you have created aliases, you will need to manage them. The API supports full CRUD operations. Listing aliases lets you audit your current state. Updating is useful when a team member changes roles and needs a different forwarding address. Deleting cleans up stale aliases.
Listing all aliases for a domain
# Python
response = requests.get(
f"{BASE_URL}/aliases?domain=mycompany.com",
headers=headers
)
aliases = response.json()
print(f"Found {len(aliases)} aliases")
// Node.js
const response = await fetch(
`${BASE_URL}/aliases?domain=mycompany.com`,
{ headers }
);
const aliases = await response.json();
console.log(`Found ${aliases.length} aliases`);
Updating an existing alias
To change where an alias forwards, use a PATCH request:
# Python
update_payload = {
"forward_to": "[email protected]"
}
response = requests.patch(
f"{BASE_URL}/aliases/{alias_id}",
headers=headers,
json=update_payload
)
// Node.js
const updatePayload = {
forward_to: "[email protected]"
};
const response = await fetch(
`${BASE_URL}/aliases/${aliasId}`,
{
method: "PATCH",
headers: headers,
body: JSON.stringify(updatePayload)
}
);
Deleting an alias
When an employee leaves or a project ends, delete the alias to prevent email bounces and security risks:
# Python
response = requests.delete(
f"{BASE_URL}/aliases/{alias_id}",
headers=headers
)
if response.status_code == 204:
print("Alias deleted successfully")
// Node.js
const response = await fetch(
`${BASE_URL}/aliases/${aliasId}`,
{ method: "DELETE", headers }
);
if (response.status === 204) {
console.log("Alias deleted");
}
GridInbox also supports bulk operations. You can delete up to 50 aliases in a single request by sending an array of IDs. Check the API documentation for the exact endpoint.
Integrating alias management into your SaaS workflow reduces manual overhead and prevents email delivery failures.
Automated alias management fits naturally into several common workflows. For example, when a new user signs up for your SaaS product, you can automatically create a personalized alias like [email protected] and forward it to their real email. When they cancel, you delete the alias. This keeps your email ecosystem clean and manageable.
Another common pattern is team onboarding. When you hire a developer, you create aliases for each of the services they need access to: [email protected], [email protected], [email protected]. When they leave, you delete those aliases so no one else receives their mail.
GridInbox supports team shared inboxes with role-based access control (RBAC). This means you can assign an alias to a team and let multiple people reply from the same address. The API lets you manage team membership programmatically, too.
Here is a more advanced example: synchronizing aliases from a CRM. Suppose you have 10,000 customers in Salesforce. You want each one to have a unique alias for sending automated invoices. A script can loop through your customer list, create aliases, and store the alias IDs in your database. The whole process takes under 10 minutes with the API.
# Pseudocode for CRM sync
customers = get_customers_from_crm()
for customer in customers:
alias_id = create_alias(
local_part=f"invoice-{customer.id}",
domain="invoices.mycompany.com",
forward_to=customer.email
)
save_to_database(customer.id, alias_id)
This approach scales to any number of aliases. GridInbox offers unlimited aliases on its paid plans, so you never hit an artificial ceiling.
Error handling and idempotency are critical for reliable API integration.
APIs fail. Network timeouts happen. Rate limits get hit. Your integration must handle these gracefully. Always check HTTP status codes. A 409 Conflict means the alias already exists. A 429 Too Many Requests means you need to back off. A 422 Unprocessable Entity means your payload has invalid data.
Implement retry logic with exponential backoff. For example, wait 1 second after the first failure, 2 seconds after the second, 4 after the third, up to a maximum of 60 seconds. Log all failures for debugging.
Idempotency is also important. If your script crashes halfway through creating aliases, you do not want duplicates when it restarts. Use idempotency keys. GridInbox supports an Idempotency-Key header. Send a unique key with each POST request. If the same key is used again within 24 hours, the API returns the original result instead of creating a duplicate.
# Python with idempotency key
import uuid
idempotency_key = str(uuid.uuid4())
headers["Idempotency-Key"] = idempotency_key
response = requests.post(f"{BASE_URL}/aliases", headers=headers, json=payload)
Real world performance: a small team can manage 10,000 aliases with under 50 lines of automation code.
We tested this with GridInbox. A Python script that creates 1000 aliases with a 60ms delay between requests completes in about 60 seconds. The same script using bulk endpoints (when available) finishes in under 10 seconds. Listing all aliases for a domain with 5000 aliases returns results in under 200 milliseconds.
GridInbox processes over 10 million alias operations per month across its customer base, with a 99.95% uptime SLA on the API. Error rates are below 0.1% for properly authenticated requests.
For a typical SaaS company with 5000 active customers, creating one alias per customer and managing them through the lifecycle of each account requires less than 100 lines of code total. The time saved compared to manual management is roughly 40 hours per month for a team of two DevOps engineers.
Frequently Asked Questions
What is an email alias API?
An email alias API is a RESTful interface that lets you programmatically create, read, update, and delete email aliases without using a web dashboard. It enables automation of alias management in your own applications.
How do I create an email alias with a REST API?
Send a POST request to the aliases endpoint with a JSON payload containing the local part, domain, and forwarding address. Include your API key in the Authorization header. The API returns the alias ID and details.
Can I manage email aliases programmatically with Python?
Yes. Use the requests library to make HTTP calls to the alias API. You can create, list, update, and delete aliases with simple function calls. GridInbox provides Python code examples in its documentation.
How do I handle rate limits when creating aliases in bulk?
Add a small delay between requests, typically 50 to 100 milliseconds. Use exponential backoff for retries when you receive a 429 status code. GridInbox allows 1000 requests per minute per API key.
What is the difference between an email alias and an email forwarder?
An email alias is an address that can both send and receive email on behalf of a domain, while a forwarder only redirects incoming mail to another address. GridInbox supports bidirectional aliases that can send replies from the alias address.
Is it safe to delete an alias via API?
Yes, but only after confirming no active workflows depend on it. Deleting an alias immediately stops email delivery to that address. Always log deletions and consider a soft delete or archival step in your automation.
手动管理邮件别名在地址数量较少时还能应付。但当跨多个域和团队扩展到数百甚至数千个别名时，手动更新就成了瓶颈。你需要一个API，能够以编程方式创建、更新和删除别名。本指南将带你了解使用REST API构建自动化别名管理系统所需的一切，并提供Python和Node.js的实用代码示例。
邮件别名API让你无需接触控制面板，即可通过编程方式创建、更新和删除别名。
每当有新客户注册或团队成员离职时，你无需登录网页界面，而是可以直接从自己的应用程序逻辑中触发别名操作。一家使用GridInbox的典型SaaS公司，每周可能需要创建200到500个别名来为新客户提供入职支持，然后在订阅结束时删除它们。没有自动化，这样的工作量根本无法管理。
邮件别名API：一种RESTful接口，允许外部应用程序以编程方式在邮件服务器或别名管理平台上创建、读取、更新和删除邮件别名。
像GridInbox这样的现代别名平台，会为你通常在UI中执行的每一项操作都提供相应的端点。这包括创建别名、将其关联到特定域名、设置转发目标以及管理团队访问权限。
别名API的身份验证使用在请求头中发送的API密钥或OAuth令牌。
每次API调用都必须经过身份验证。包括GridInbox在内的大多数提供商，都使用一个简单的API密钥，作为Bearer令牌放在Authorization请求头中传递。切勿在客户端代码或版本控制系统中暴露你的API密钥。应将其存储在环境变量或密钥管理器中。
以下是使用Python的requests库进行基本身份验证的示例：
import requests
API_KEY = "your_gridinbox_api_key"
BASE_URL = "https://api.gridinbox.com/v1"
headers = {
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json"
}
在Node.js中，你可以使用axios或内置的fetch实现相同的功能：
const API_KEY = process.env.GRIDINBOX_API_KEY;
const BASE_URL = "https://api.gridinbox.com/v1";
const headers = {
"Authorization": `Bearer ${API_KEY}`,
"Content-Type": "application/json"
};
始终使用HTTPS。切勿硬编码凭据。定期轮换密钥，至少每90天一次。
通过API创建邮件别名需要发送一个POST请求，其中包含别名名称、域名和转发规则。
最常见的操作是创建新别名。你需要指定本地部分（@符号之前的部分）、域名以及邮件应转发到的地址。某些平台还允许你设置显示名称并启用双向发送功能。
以下是使用GridInbox创建别名的Python函数：
def create_alias(local_part, domain, forward_to, display_name=None):
payload = {
"local_part": local_part,
"domain": domain,
"forward_to": forward_to,
"display_name": display_name or local_part
}
response = requests.post(
f"{BASE_URL}/aliases",
headers=headers,
json=payload
)
response.raise_for_status()
return response.json()
# 示例：创建 [email protected] 并转发至 [email protected]
result = create_alias("support", "mycompany.com", "[email protected]")
print(result["id"]) # 例如："alias_abc123"
以及Node.js中的相同操作：
async function createAlias(localPart, domain, forwardTo, displayName) {
const payload = {
local_part: localPart,
domain: domain,
forward_to: forwardTo,
display_name: displayName || localPart
};
const response = await fetch(`${BASE_URL}/aliases`, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
});
if (!response.ok) throw new Error(`HTTP ${response.status}`);
return await response.json();
}
// 示例
createAlias("billing", "mycompany.com", "[email protected]")
.then(data => console.log(data.id));
请记住处理速率限制。GridInbox每个API密钥每分钟允许1000次请求。如果你要批量创建别名，请在每次调用之间延迟60毫秒，以保持在限制范围内。
大规模管理别名意味着你需要使用GET、PATCH和DELETE端点来列出、更新和删除它们。
创建别名后，你需要对它们进行管理。API支持完整的CRUD操作。列出别名可以让你审计当前状态。当团队成员角色变更，需要不同的转发地址时，更新操作非常有用。删除操作则可以清理过时的别名。
列出某个域名的所有别名
# Python
response = requests.get(
f"{BASE_URL}/aliases?domain=mycompany.com",
headers=headers
)
aliases = response.json()
print(f"找到 {len(aliases)} 个别名")
// Node.js
const response = await fetch(
`${BASE_URL}/aliases?domain=mycompany.com`,
{ headers }
);
const aliases = await response.json();
console.log(`找到 ${aliases.length} 个别名`);
更新现有别名
要更改别名的转发目标，请使用PATCH请求：
# Python
update_payload = {
"forward_to": "[email protected]"
}
response = requests.patch(
f"{BASE_URL}/aliases/{alias_id}",
headers=headers,
json=update_payload
)
// Node.js
const updatePayload = {
forward_to: "[email protected]"
};
const response = await fetch(
`${BASE_URL}/aliases/${aliasId}`,
{
method: "PATCH",
headers: headers,
body: JSON.stringify(updatePayload)
}
);
删除别名
当员工离职或项目结束时，删除别名可以防止邮件退回和安全风险：
# Python
response = requests.delete(
f"{BASE_URL}/aliases/{alias_id}",
headers=headers
)
if response.status_code == 204:
print("别名已成功删除")
// Node.js
const response = await fetch(
`${BASE_URL}/aliases/${aliasId}`,
{ method: "DELETE", headers }
);
if (response.status === 204) {
console.log("别名已删除");
}
GridInbox还支持批量操作。你可以通过发送一个ID数组，在单个请求中删除最多50个别名。请查阅API文档了解确切的端点。
将别名管理集成到你的SaaS工作流中，可以减少人工开销并防止邮件投递失败。
自动化别名管理可以自然地融入几种常见的工作流。例如，当新用户注册你的SaaS产品时，你可以自动创建一个个性化别名，如[email protected]，并将其转发到他们的真实邮箱。当他们取消订阅时，你再删除该别名。这能让你的邮件生态系统保持干净和易于管理。
另一种常见模式是团队入职。当你招聘一名开发人员时，你可以为他们需要访问的每项服务创建别名：[email protected]、[email protected]、[email protected]。当他们离职时，你删除这些别名，这样就没有其他人会收到他们的邮件了。
GridInbox支持带有基于角色的访问控制（RBAC）的团队共享收件箱。这意味着你可以将别名分配给一个团队，并允许多人使用同一个地址回复邮件。API还允许你以编程方式管理团队成员资格。
这里有一个更高级的示例：从CRM同步别名。假设你在Salesforce中有10,000个客户。你希望每个客户都有一个唯一的别名，用于发送自动化发票。一个脚本可以遍历你的客户列表，创建别名，并将别名ID存储在你的数据库中。使用API，整个过程不到10分钟即可完成。
# CRM同步的伪代码
customers = get_customers_from_crm()
for customer in customers:
alias_id = create_alias(
local_part=f"invoice-{customer.id}",
domain="invoices.mycompany.com",
forward_to=customer.email
)
save_to_database(customer.id, alias_id)
这种方法可以扩展到任意数量的别名。GridInbox在其付费计划中提供无限别名，因此你永远不会遇到人为设置的上限。
错误处理和幂等性对于可靠的API集成至关重要。
API会失败。网络超时会发生。速率限制会被触发。你的集成必须优雅地处理这些情况。始终检查HTTP状态码。409冲突表示别名已存在。429请求过多表示你需要退避。422不可处理的实体表示你的负载包含无效数据。
使用指数退避实现重试逻辑。例如，第一次失败后等待1秒，第二次失败后等待2秒，第三次后等待4秒，最多等待60秒。记录所有失败信息以便调试。
幂等性也很重要。如果你的脚本在创建别名过程中崩溃，重启时你不希望产生重复项。请使用幂等性键。GridInbox支持Idempotency-Key请求头。每次POST请求都发送一个唯一的键。如果在24小时内再次使用相同的键，API将返回原始结果，而不是创建重复项。
# 使用幂等性键的Python示例
import uuid
idempotency_key = str(uuid.uuid4())
headers["Idempotency-Key"] = idempotency_key
response = requests.post(f"{BASE_URL}/aliases", headers=headers, json=payload)
实际性能：一个小团队可以用不到50行的自动化代码管理10,000个别名。
我们使用GridInbox对此进行了测试。一个Python脚本以60毫秒的间隔创建1000个别名，大约需要60秒完成。使用批量端点（如果可用）时，同样的脚本在不到10秒内完成。列出包含5000个别名的域的所有别名，结果在200毫秒内返回。
GridInbox每月在其客户群中处理超过1000万次别名操作，API的可用性SLA为99.95%。对于正确验证的请求，错误率低于0.1%。
对于一家拥有5000名活跃客户的典型SaaS公司，为每个客户创建一个别名并在整个账户生命周期内进行管理，总共需要的代码不到100行。与手动管理相比，每月可为两名DevOps工程师组成的团队节省大约40小时的工作时间。
常见问题解答
什么是邮件别名API？
邮件别名API是一种RESTful接口，允许你以编程方式创建、读取、更新和删除邮件别名，而无需使用网页控制面板。它使你能够在自己的应用程序中实现别名管理的自动化。
如何使用REST API创建邮件别名？
向别名端点发送一个POST请求，请求体为包含本地部分、域名和转发地址的JSON负载。在Authorization请求头中包含你的API密钥。API将返回别名ID和详细信息。
我可以用Python以编程方式管理邮件别名吗？
可以。使用requests库向别名API发出HTTP调用。你可以通过简单的函数调用来创建、列出、更新和删除别名。GridInbox在其文档中提供了Python代码示例。
批量创建别名时如何处理速率限制？
在请求之间添加一个小的延迟，通常是50到100毫秒。当收到429状态码时，使用指数退避进行重试。GridInbox每个API密钥每分钟允许1000次请求。
邮件别名和邮件转发器有什么区别？
邮件别名是一个可以代表域名发送和接收邮件的地址，而转发器仅将收到的邮件重定向到另一个地址。GridInbox支持双向别名，可以从别名地址发送回复。
通过API删除别名安全吗？
安全，但前提是确认没有活跃的工作流依赖它。删除别名会立即停止向该地址投递邮件。务必记录删除操作，并在自动化流程中考虑软删除或归档步骤。
Gestionar alias de correo manualmente funciona para unas pocas direcciones. Pero cuando escalas a cientos o miles de alias en múltiples dominios y equipos, las actualizaciones manuales se convierten en un cuello de botella. Necesitas una API que te permita crear, actualizar y eliminar alias de forma programática. Esta guía te explica todo lo que necesitas para construir un sistema automatizado de gestión de alias usando API REST, con ejemplos de código funcionales en Python y Node.js.
Una API de alias de correo te permite crear, actualizar y eliminar alias de forma programática sin tocar un panel de control.
En lugar de iniciar sesión en una interfaz web cada vez que un nuevo cliente se registra o un miembro del equipo se va, puedes activar operaciones de alias desde la lógica de tu propia aplicación. Una empresa SaaS típica que usa GridInbox podría crear de 200 a 500 alias por semana para incorporar nuevos clientes, y luego eliminarlos cuando las suscripciones terminan. Ese volumen es inmanejable sin automatización.
API de Alias de Correo: Una interfaz RESTful que permite a aplicaciones externas crear, leer, actualizar y eliminar alias de correo de forma programática en un servidor de correo o plataforma de gestión de alias.
Plataformas modernas de alias como GridInbox exponen endpoints para cada operación que realizarías en una interfaz de usuario. Esto incluye crear alias, asociarlos a dominios específicos, establecer destinos de reenvío y gestionar permisos para el acceso del equipo.
La autenticación para las API de alias utiliza claves API o tokens OAuth enviados en los encabezados de las solicitudes.
Cada llamada a la API debe estar autenticada. La mayoría de los proveedores, incluido GridInbox, utilizan una clave API simple que se pasa como token Bearer en el encabezado Authorization. Nunca expongas tu clave API en código del lado del cliente o en control de versiones. Guárdala en variables de entorno o en un gestor de secretos.
Aquí tienes un ejemplo básico de autenticación en Python usando la librería requests:
import requests
API_KEY = "tu_clave_api_gridinbox"
BASE_URL = "https://api.gridinbox.com/v1"
headers = {
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json"
}
En Node.js, puedes lograr lo mismo con axios o el fetch integrado:
const API_KEY = process.env.GRIDINBOX_API_KEY;
const BASE_URL = "https://api.gridinbox.com/v1";
const headers = {
"Authorization": `Bearer ${API_KEY}`,
"Content-Type": "application/json"
};
Usa siempre HTTPS. Nunca codifiques credenciales. Rota las claves regularmente, al menos cada 90 días.
Crear un alias de correo mediante API requiere enviar una solicitud POST con el nombre del alias, el dominio y las reglas de reenvío.
La operación más común es crear un nuevo alias. Especificas la parte local (la parte antes de la @), el dominio y hacia dónde deben reenviarse los correos. Algunas plataformas también te permiten establecer un nombre para mostrar y habilitar el envío bidireccional.
Aquí tienes una función en Python para crear un alias con GridInbox:
def create_alias(local_part, domain, forward_to, display_name=None):
payload = {
"local_part": local_part,
"domain": domain,
"forward_to": forward_to,
"display_name": display_name or local_part
}
response = requests.post(
f"{BASE_URL}/aliases",
headers=headers,
json=payload
)
response.raise_for_status()
return response.json()
# Ejemplo: crear [email protected] reenviando a [email protected]
result = create_alias("support", "miempresa.com", "[email protected]")
print(result["id"]) # ej.: "alias_abc123"
Y la misma operación en Node.js:
async function createAlias(localPart, domain, forwardTo, displayName) {
const payload = {
local_part: localPart,
domain: domain,
forward_to: forwardTo,
display_name: displayName || localPart
};
const response = await fetch(`${BASE_URL}/aliases`, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
});
if (!response.ok) throw new Error(`HTTP ${response.status}`);
return await response.json();
}
// Ejemplo
createAlias("facturacion", "miempresa.com", "[email protected]")
.then(data => console.log(data.id));
Recuerda manejar los límites de tasa. GridInbox permite 1000 solicitudes por minuto por clave API. Si estás creando alias en lote, agrúpalos con un retraso de 60 milisegundos entre llamadas para mantenerte dentro del límite.
Gestionar alias a escala significa que necesitas listarlos, actualizarlos y eliminarlos usando los endpoints GET, PATCH y DELETE.
Una vez que has creado alias, necesitarás gestionarlos. La API admite operaciones CRUD completas. Listar alias te permite auditar tu estado actual. Actualizar es útil cuando un miembro del equipo cambia de rol y necesita una dirección de reenvío diferente. Eliminar limpia los alias obsoletos.
Listar todos los alias de un dominio
# Python
response = requests.get(
f"{BASE_URL}/aliases?domain=miempresa.com",
headers=headers
)
aliases = response.json()
print(f"Se encontraron {len(aliases)} alias")
// Node.js
const response = await fetch(
`${BASE_URL}/aliases?domain=miempresa.com`,
{ headers }
);
const aliases = await response.json();
console.log(`Se encontraron ${aliases.length} alias`);
Actualizar un alias existente
Para cambiar hacia dónde reenvía un alias, usa una solicitud PATCH:
# Python
update_payload = {
"forward_to": "[email protected]"
}
response = requests.patch(
f"{BASE_URL}/aliases/{alias_id}",
headers=headers,
json=update_payload
)
// Node.js
const updatePayload = {
forward_to: "[email protected]"
};
const response = await fetch(
`${BASE_URL}/aliases/${aliasId}`,
{
method: "PATCH",
headers: headers,
body: JSON.stringify(updatePayload)
}
);
Eliminar un alias
Cuando un empleado se va o un proyecto termina, elimina el alias para evitar rebotes de correo y riesgos de seguridad:
# Python
response = requests.delete(
f"{BASE_URL}/aliases/{alias_id}",
headers=headers
)
if response.status_code == 204:
print("Alias eliminado correctamente")
// Node.js
const response = await fetch(
`${BASE_URL}/aliases/${aliasId}`,
{ method: "DELETE", headers }
);
if (response.status === 204) {
console.log("Alias eliminado");
}
GridInbox también admite operaciones por lotes. Puedes eliminar hasta 50 alias en una sola solicitud enviando un array de IDs. Consulta la documentación de la API para el endpoint exacto.
Integrar la gestión de alias en tu flujo de trabajo SaaS reduce la carga manual y previene fallos en la entrega de correos.
La gestión automatizada de alias encaja naturalmente en varios flujos de trabajo comunes. Por ejemplo, cuando un nuevo usuario se registra en tu producto SaaS, puedes crear automáticamente un alias personalizado como [email protected] y reenviarlo a su correo real. Cuando cancela, eliminas el alias. Esto mantiene tu ecosistema de correo limpio y manejable.
Otro patrón común es la incorporación de equipos. Cuando contratas a un desarrollador, creas alias para cada uno de los servicios a los que necesita acceder: [email protected], [email protected], [email protected]. Cuando se va, eliminas esos alias para que nadie más reciba su correo.
GridInbox admite bandejas de entrada compartidas para equipos con control de acceso basado en roles (RBAC). Esto significa que puedes asignar un alias a un equipo y permitir que varias personas respondan desde la misma dirección. La API también te permite gestionar la membresía del equipo de forma programática.
Aquí tienes un ejemplo más avanzado: sincronizar alias desde un CRM. Supongamos que tienes 10,000 clientes en Salesforce. Quieres que cada uno tenga un alias único para enviar facturas automatizadas. Un script puede recorrer tu lista de clientes, crear alias y almacenar los IDs de los alias en tu base de datos. Todo el proceso toma menos de 10 minutos con la API.
# Pseudocódigo para sincronización con CRM
clientes = obtener_clientes_desde_crm()
for cliente in clientes:
alias_id = create_alias(
local_part=f"factura-{cliente.id}",
domain="facturas.miempresa.com",
forward_to=cliente.email
)
guardar_en_base_de_datos(cliente.id, alias_id)
Este enfoque escala a cualquier número de alias. GridInbox ofrece alias ilimitados en sus planes de pago, por lo que nunca te topas con un techo artificial.
El manejo de errores y la idempotencia son críticos para una integración confiable con la API.
Las API fallan. Ocurren tiempos de espera de red. Se alcanzan los límites de tasa. Tu integración debe manejar esto con elegancia. Siempre verifica los códigos de estado HTTP. Un 409 Conflict significa que el alias ya existe. Un 429 Too Many Requests significa que debes esperar. Un 422 Unprocessable Entity significa que tu payload tiene datos no válidos.
Implementa lógica de reintento con retroceso exponencial. Por ejemplo, espera 1 segundo después del primer fallo, 2 segundos después del segundo, 4 después del tercero, hasta un máximo de 60 segundos. Registra todos los fallos para depuración.
La idempotencia también es importante. Si tu script se bloquea a mitad de la creación de alias, no quieres duplicados cuando se reinicie. Usa claves de idempotencia. GridInbox admite el encabezado Idempotency-Key. Envía una clave única con cada solicitud POST. Si la misma clave se usa de nuevo dentro de las 24 horas, la API devuelve el resultado original en lugar de crear un duplicado.
# Python con clave de idempotencia
import uuid
idempotency_key = str(uuid.uuid4())
headers["Idempotency-Key"] = idempotency_key
response = requests.post(f"{BASE_URL}/aliases", headers=headers, json=payload)
Rendimiento en el mundo real: un equipo pequeño puede gestionar 10,000 alias con menos de 50 líneas de código de automatización.
Probamos esto con GridInbox. Un script en Python que crea 1000 alias con un retraso de 60 ms entre solicitudes se completa en aproximadamente 60 segundos. El mismo script usando endpoints por lotes (cuando están disponibles) termina en menos de 10 segundos. Listar todos los alias de un dominio con 5000 alias devuelve resultados en menos de 200 milisegundos.
GridInbox procesa más de 10 millones de operaciones de alias al mes en su base de clientes, con un SLA de disponibilidad del 99.95% en la API. Las tasas de error están por debajo del 0.1% para solicitudes correctamente autenticadas.
Para una empresa SaaS típica con 5000 clientes activos, crear un alias por cliente y gestionarlos a lo largo del ciclo de vida de cada cuenta requiere menos de 100 líneas de código en total. El tiempo ahorrado en comparación con la gestión manual es de aproximadamente 40 horas al mes para un equipo de dos ingenieros de DevOps.
Preguntas Frecuentes
¿Qué es una API de alias de correo?
Una API de alias de correo es una interfaz RESTful que te permite crear, leer, actualizar y eliminar alias de correo de forma programática sin usar un panel web. Permite la automatización de la gestión de alias en tus propias aplicaciones.
¿Cómo creo un alias de correo con una API REST?
Envía una solicitud POST al endpoint de alias con un payload JSON que contenga la parte local, el dominio y la dirección de reenvío. Incluye tu clave API en el encabezado Authorization. La API devuelve el ID y los detalles del alias.
¿Puedo gestionar alias de correo de forma programática con Python?
Sí. Usa la librería requests para hacer llamadas HTTP a la API de alias. Puedes crear, listar, actualizar y eliminar alias con simples llamadas a funciones. GridInbox proporciona ejemplos de código en Python en su documentación.
¿Cómo manejo los límites de tasa al crear alias en lote?
Añade un pequeño retraso entre solicitudes, típicamente de 50 a 100 milisegundos. Usa retroceso exponencial para los reintentos cuando recibas un código de estado 429. GridInbox permite 1000 solicitudes por minuto por clave API.
¿Cuál es la diferencia entre un alias de correo y un reenviador de correo?
Un alias de correo es una dirección que puede tanto enviar como recibir correos en nombre de un dominio, mientras que un reenviador solo redirige el correo entrante a otra dirección. GridInbox admite alias bidireccionales que pueden enviar respuestas desde la dirección del alias.
¿Es seguro eliminar un alias mediante API?
Sí, pero solo después de confirmar que ningún flujo de trabajo activo depende de él. Eliminar un alias detiene inmediatamente la entrega de correos a esa dirección. Siempre registra las eliminaciones y considera un paso de eliminación suave o archivado en tu automatización.
Gérer les alias email manuellement fonctionne pour quelques adresses. Mais quand vous passez à des centaines ou des milliers d'alias répartis sur plusieurs domaines et équipes, les mises à jour manuelles deviennent un goulot d'étranglement. Vous avez besoin d'une API qui vous permette de créer, mettre à jour et supprimer des alias par programmation. Ce guide vous explique tout ce qu'il faut pour construire un système automatisé de gestion d'alias avec une API REST, avec des exemples de code fonctionnels en Python et Node.js.
Une API d'alias email vous permet de créer, mettre à jour et supprimer des alias par programmation sans toucher à un tableau de bord.
Au lieu de vous connecter à une interface web chaque fois qu'un nouveau client s'inscrit ou qu'un membre de l'équipe quitte l'entreprise, vous pouvez déclencher des opérations sur les alias depuis votre propre logique applicative. Une entreprise SaaS typique utilisant GridInbox peut créer 200 à 500 alias par semaine pour intégrer de nouveaux clients, puis les supprimer à la fin des abonnements. Un tel volume est ingérable sans automatisation.
API Alias Email : Une interface RESTful qui permet aux applications externes de créer, lire, mettre à jour et supprimer par programmation des alias email sur un serveur de messagerie ou une plateforme de gestion d'alias.
Les plateformes d'alias modernes comme GridInbox exposent des endpoints pour chaque opération que vous effectueriez dans une interface utilisateur. Cela inclut la création d'alias, leur rattachement à des domaines spécifiques, la définition de destinations de transfert et la gestion des permissions pour l'accès des équipes.
L'authentification pour les API d'alias utilise des clés API ou des jetons OAuth envoyés dans les en-têtes des requêtes.
Chaque appel API doit être authentifié. La plupart des fournisseurs, dont GridInbox, utilisent une simple clé API transmise sous forme de jeton Bearer dans l'en-tête Authorization. N'exposez jamais votre clé API dans du code côté client ou dans un système de contrôle de version. Stockez-la dans des variables d'environnement ou un gestionnaire de secrets.
Voici un exemple d'authentification de base en Python avec la bibliothèque requests :
import requests
API_KEY = "votre_clé_api_gridinbox"
BASE_URL = "https://api.gridinbox.com/v1"
headers = {
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json"
}
En Node.js, vous pouvez obtenir le même résultat avec axios ou la fonction fetch intégrée :
const API_KEY = process.env.GRIDINBOX_API_KEY;
const BASE_URL = "https://api.gridinbox.com/v1";
const headers = {
"Authorization": `Bearer ${API_KEY}`,
"Content-Type": "application/json"
};
Utilisez toujours HTTPS. Ne codez jamais les identifiants en dur. Renouvelez les clés régulièrement, au moins tous les 90 jours.
Créer un alias email via l'API nécessite d'envoyer une requête POST avec le nom de l'alias, le domaine et les règles de transfert.
L'opération la plus courante est la création d'un nouvel alias. Vous spécifiez la partie locale (la partie avant le @), le domaine et les adresses de destination. Certaines plateformes permettent également de définir un nom d'affichage et d'activer l'envoi bidirectionnel.
Voici une fonction Python pour créer un alias avec GridInbox :
def create_alias(local_part, domain, forward_to, display_name=None):
payload = {
"local_part": local_part,
"domain": domain,
"forward_to": forward_to,
"display_name": display_name or local_part
}
response = requests.post(
f"{BASE_URL}/aliases",
headers=headers,
json=payload
)
response.raise_for_status()
return response.json()
# Exemple : créer [email protected] avec transfert vers [email protected]
result = create_alias("support", "mycompany.com", "[email protected]")
print(result["id"]) # ex. "alias_abc123"
Et la même opération en Node.js :
async function createAlias(localPart, domain, forwardTo, displayName) {
const payload = {
local_part: localPart,
domain: domain,
forward_to: forwardTo,
display_name: displayName || localPart
};
const response = await fetch(`${BASE_URL}/aliases`, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
});
if (!response.ok) throw new Error(`HTTP ${response.status}`);
return await response.json();
}
// Exemple
createAlias("billing", "mycompany.com", "[email protected]")
.then(data => console.log(data.id));
N'oubliez pas de gérer les limites de débit. GridInbox autorise 1000 requêtes par minute par clé API. Si vous créez des alias en masse, regroupez-les avec un délai de 60 millisecondes entre les appels pour rester sous la limite.
Gérer les alias à grande échelle implique de les lister, mettre à jour et supprimer via les endpoints GET, PATCH et DELETE.
Une fois les alias créés, vous devrez les gérer. L'API prend en charge les opérations CRUD complètes. Lister les alias permet d'auditer l'état actuel. La mise à jour est utile lorsqu'un membre de l'équipe change de rôle et a besoin d'une adresse de transfert différente. La suppression nettoie les alias obsolètes.
Lister tous les alias d'un domaine
# Python
response = requests.get(
f"{BASE_URL}/aliases?domain=mycompany.com",
headers=headers
)
aliases = response.json()
print(f"{len(aliases)} alias trouvés")
// Node.js
const response = await fetch(
`${BASE_URL}/aliases?domain=mycompany.com`,
{ headers }
);
const aliases = await response.json();
console.log(`${aliases.length} alias trouvés`);
Mettre à jour un alias existant
Pour modifier la destination d'un alias, utilisez une requête PATCH :
# Python
update_payload = {
"forward_to": "[email protected]"
}
response = requests.patch(
f"{BASE_URL}/aliases/{alias_id}",
headers=headers,
json=update_payload
)
// Node.js
const updatePayload = {
forward_to: "[email protected]"
};
const response = await fetch(
`${BASE_URL}/aliases/${aliasId}`,
{
method: "PATCH",
headers: headers,
body: JSON.stringify(updatePayload)
}
);
Supprimer un alias
Lorsqu'un employé quitte l'entreprise ou qu'un projet se termine, supprimez l'alias pour éviter les rebonds d'email et les risques de sécurité :
# Python
response = requests.delete(
f"{BASE_URL}/aliases/{alias_id}",
headers=headers
)
if response.status_code == 204:
print("Alias supprimé avec succès")
// Node.js
const response = await fetch(
`${BASE_URL}/aliases/${aliasId}`,
{ method: "DELETE", headers }
);
if (response.status === 204) {
console.log("Alias supprimé");
}
GridInbox prend également en charge les opérations en masse. Vous pouvez supprimer jusqu'à 50 alias en une seule requête en envoyant un tableau d'identifiants. Consultez la documentation de l'API pour l'endpoint exact.
Intégrer la gestion des alias dans votre flux de travail SaaS réduit la charge manuelle et prévient les échecs de livraison d'emails.
La gestion automatisée des alias s'intègre naturellement dans plusieurs flux de travail courants. Par exemple, lorsqu'un nouvel utilisateur s'inscrit à votre produit SaaS, vous pouvez automatiquement créer un alias personnalisé comme [email protected] et le transférer vers son adresse email réelle. Lorsqu'il annule, vous supprimez l'alias. Cela maintient votre écosystème email propre et gérable.
Un autre cas fréquent est l'intégration des nouveaux membres d'équipe. Lorsque vous embauchez un développeur, vous créez des alias pour chaque service auquel il doit avoir accès : [email protected], [email protected], [email protected]. Quand il part, vous supprimez ces alias pour que personne d'autre ne reçoive ses emails.
GridInbox prend en charge les boîtes de réception partagées avec contrôle d'accès basé sur les rôles (RBAC). Cela signifie que vous pouvez attribuer un alias à une équipe et permettre à plusieurs personnes de répondre depuis la même adresse. L'API permet également de gérer l'appartenance à une équipe par programmation.
Voici un exemple plus avancé : la synchronisation des alias depuis un CRM. Supposons que vous ayez 10 000 clients dans Salesforce. Vous souhaitez que chacun ait un alias unique pour l'envoi de factures automatisées. Un script peut parcourir votre liste de clients, créer des alias et stocker les identifiants d'alias dans votre base de données. L'ensemble du processus prend moins de 10 minutes avec l'API.
# Pseudocode pour la synchronisation CRM
clients = obtenir_clients_depuis_crm()
pour client in clients:
alias_id = creer_alias(
local_part=f"facture-{client.id}",
domain="factures.monentreprise.com",
forward_to=client.email
)
sauvegarder_en_base(client.id, alias_id)
Cette approche s'adapte à n'importe quel nombre d'alias. GridInbox propose des alias illimités sur ses formules payantes, vous n'atteignez donc jamais de plafond artificiel.
La gestion des erreurs et l'idempotence sont essentielles pour une intégration API fiable.
Les API échouent. Les timeouts réseau surviennent. Les limites de débit sont atteintes. Votre intégration doit gérer ces situations avec élégance. Vérifiez toujours les codes de statut HTTP. Un code 409 Conflict signifie que l'alias existe déjà. Un code 429 Too Many Requests signifie que vous devez ralentir. Un code 422 Unprocessable Entity signifie que votre payload contient des données invalides.
Implémentez une logique de réessai avec backoff exponentiel. Par exemple, attendez 1 seconde après le premier échec, 2 secondes après le deuxième, 4 après le troisième, jusqu'à un maximum de 60 secondes. Enregistrez tous les échecs pour le débogage.
L'idempotence est également importante. Si votre script plante au milieu de la création d'alias, vous ne voulez pas de doublons lorsqu'il redémarre. Utilisez des clés d'idempotence. GridInbox prend en charge l'en-tête Idempotency-Key. Envoyez une clé unique avec chaque requête POST. Si la même clé est utilisée à nouveau dans les 24 heures, l'API renvoie le résultat d'origine au lieu de créer un doublon.
# Python avec clé d'idempotence
import uuid
idempotency_key = str(uuid.uuid4())
headers["Idempotency-Key"] = idempotency_key
response = requests.post(f"{BASE_URL}/aliases", headers=headers, json=payload)
Performances réelles : une petite équipe peut gérer 10 000 alias avec moins de 50 lignes de code d'automatisation.
Nous l'avons testé avec GridInbox. Un script Python qui crée 1000 alias avec un délai de 60 ms entre les requêtes s'exécute en environ 60 secondes. Le même script utilisant des endpoints en masse (lorsqu'ils sont disponibles) se termine en moins de 10 secondes. Lister tous les alias d'un domaine contenant 5000 alias renvoie les résultats en moins de 200 millisecondes.
GridInbox traite plus de 10 millions d'opérations sur les alias par mois sur l'ensemble de sa clientèle, avec un SLA de disponibilité de 99,95 % sur l'API. Les taux d'erreur sont inférieurs à 0,1 % pour les requêtes correctement authentifiées.
Pour une entreprise SaaS typique avec 5000 clients actifs, créer un alias par client et les gérer tout au long du cycle de vie de chaque compte nécessite moins de 100 lignes de code au total. Le temps gagné par rapport à la gestion manuelle est d'environ 40 heures par mois pour une équipe de deux ingénieurs DevOps.
Questions fréquentes
Qu'est-ce qu'une API d'alias email ?
Une API d'alias email est une interface RESTful qui vous permet de créer, lire, mettre à jour et supprimer par programmation des alias email sans utiliser de tableau de bord web. Elle permet d'automatiser la gestion des alias dans vos propres applications.
Comment créer un alias email avec une API REST ?
Envoyez une requête POST à l'endpoint des alias avec un payload JSON contenant la partie locale, le domaine et l'adresse de transfert. Incluez votre clé API dans l'en-tête Authorization. L'API renvoie l'ID et les détails de l'alias.
Puis-je gérer les alias email par programmation avec Python ?
Oui. Utilisez la bibliothèque requests pour effectuer des appels HTTP à l'API d'alias. Vous pouvez créer, lister, mettre à jour et supprimer des alias avec des appels de fonction simples. GridInbox fournit des exemples de code Python dans sa documentation.
Comment gérer les limites de débit lors de la création d'alias en masse ?
Ajoutez un petit délai entre les requêtes, généralement de 50 à 100 millisecondes. Utilisez un backoff exponentiel pour les réessais lorsque vous recevez un code d'état 429. GridInbox autorise 1000 requêtes par minute par clé API.
Quelle est la différence entre un alias email et un forwarder email ?
Un alias email est une adresse qui peut à la fois envoyer et recevoir des emails pour le compte d'un domaine, tandis qu'un forwarder redirige uniquement les emails entrants vers une autre adresse. GridInbox prend en charge les alias bidirectionnels qui peuvent envoyer des réponses depuis l'adresse de l'alias.
Est-il sûr de supprimer un alias via l'API ?
Oui, mais seulement après avoir confirmé qu'aucun flux de travail actif n'en dépend. La suppression d'un alias arrête immédiatement la livraison des emails à cette adresse. Enregistrez toujours les suppressions et envisagez une étape de suppression douce ou d'archivage dans votre automatisation.
メールエイリアスの手動管理は、数個のアドレスなら問題ありません。しかし、複数のドメインやチームにわたって数百、数千のエイリアスを扱う規模になると、手動での更新はボトルネックになります。そこで必要なのが、プログラムでエイリアスを作成・更新・削除できるAPIです。このガイドでは、REST APIを使った自動エイリアス管理システムの構築に必要なすべてを、PythonとNode.jsの実用的なコード例とともに解説します。
メールエイリアスAPIを使えば、ダッシュボードに触れることなく、プログラムでエイリアスを作成・更新・削除できます。
新規顧客がサインアップしたり、チームメンバーが退職するたびにWebインターフェースにログインする代わりに、アプリケーションのロジックからエイリアス操作をトリガーできます。GridInboxを利用する一般的なSaaS企業では、新規クライアントのオンボーディングのために週に200～500個のエイリアスを作成し、サブスクリプション終了時にそれらを削除します。このボリュームは自動化なしでは管理不可能です。
メールエイリアスAPI：メールサーバーやエイリアス管理プラットフォーム上で、外部アプリケーションがプログラムによってメールエイリアスを作成・読み取り・更新・削除できるRESTfulインターフェースです。
GridInboxのような最新のエイリアスプラットフォームは、UIで実行するすべての操作に対応するエンドポイントを公開しています。これには、エイリアスの作成、特定のドメインへの割り当て、転送先の設定、チームアクセス権限の管理が含まれます。
エイリアスAPIの認証には、リクエストヘッダーにAPIキーまたはOAuthトークンを送信します。
すべてのAPI呼び出しは認証が必要です。GridInboxを含むほとんどのプロバイダーは、AuthorizationヘッダーにBearerトークンとして渡すシンプルなAPIキーを使用します。APIキーをクライアントサイドのコードやバージョン管理に公開しないでください。環境変数やシークレットマネージャーに保存しましょう。
以下は、Pythonのrequestsライブラリを使用した基本的な認証例です：
import requests
API_KEY = "your_gridinbox_api_key"
BASE_URL = "https://api.gridinbox.com/v1"
headers = {
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json"
}
Node.jsでは、axiosまたは組み込みのfetchで同じことが実現できます：
const API_KEY = process.env.GRIDINBOX_API_KEY;
const BASE_URL = "https://api.gridinbox.com/v1";
const headers = {
"Authorization": `Bearer ${API_KEY}`,
"Content-Type": "application/json"
};
常にHTTPSを使用してください。認証情報をハードコードしないでください。キーは少なくとも90日ごとに定期的にローテーションしましょう。
APIでメールエイリアスを作成するには、エイリアス名、ドメイン、転送ルールを含むPOSTリクエストを送信します。
最も一般的な操作は、新しいエイリアスの作成です。ローカルパート（@の前の部分）、ドメイン、メールの転送先を指定します。一部のプラットフォームでは、表示名の設定や双方向送信の有効化も可能です。
以下は、GridInboxでエイリアスを作成するPython関数です：
def create_alias(local_part, domain, forward_to, display_name=None):
payload = {
"local_part": local_part,
"domain": domain,
"forward_to": forward_to,
"display_name": display_name or local_part
}
response = requests.post(
f"{BASE_URL}/aliases",
headers=headers,
json=payload
)
response.raise_for_status()
return response.json()
# 例：[email protected]を作成し、[email protected]に転送
result = create_alias("support", "mycompany.com", "[email protected]")
print(result["id"]) # 例："alias_abc123"
同じ操作をNode.jsで行う場合：
async function createAlias(localPart, domain, forwardTo, displayName) {
const payload = {
local_part: localPart,
domain: domain,
forward_to: forwardTo,
display_name: displayName || localPart
};
const response = await fetch(`${BASE_URL}/aliases`, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
});
if (!response.ok) throw new Error(`HTTP ${response.status}`);
return await response.json();
}
// 例
createAlias("billing", "mycompany.com", "[email protected]")
.then(data => console.log(data.id));
レート制限に対処することを忘れないでください。GridInboxはAPIキーあたり毎分1000リクエストを許可しています。エイリアスを一括作成する場合は、呼び出し間に60ミリ秒の遅延を入れて制限内に収めてください。
大規模なエイリアス管理には、GET、PATCH、DELETEエンドポイントを使った一覧表示、更新、削除が必要です。
エイリアスを作成したら、それらを管理する必要があります。APIは完全なCRUD操作をサポートしています。エイリアスの一覧表示で現在の状態を監査できます。更新は、チームメンバーの役割が変わり転送先を変更する必要がある場合に便利です。削除は、古いエイリアスをクリーンアップします。
ドメイン内の全エイリアスを一覧表示
# Python
response = requests.get(
f"{BASE_URL}/aliases?domain=mycompany.com",
headers=headers
)
aliases = response.json()
print(f"Found {len(aliases)} aliases")
// Node.js
const response = await fetch(
`${BASE_URL}/aliases?domain=mycompany.com`,
{ headers }
);
const aliases = await response.json();
console.log(`Found ${aliases.length} aliases`);
既存のエイリアスを更新
エイリアスの転送先を変更するには、PATCHリクエストを使用します：
# Python
update_payload = {
"forward_to": "[email protected]"
}
response = requests.patch(
f"{BASE_URL}/aliases/{alias_id}",
headers=headers,
json=update_payload
)
// Node.js
const updatePayload = {
forward_to: "[email protected]"
};
const response = await fetch(
`${BASE_URL}/aliases/${aliasId}`,
{
method: "PATCH",
headers: headers,
body: JSON.stringify(updatePayload)
}
);
エイリアスを削除
従業員が退職したりプロジェクトが終了した場合は、メールのバウンスやセキュリティリスクを防ぐためにエイリアスを削除します：
# Python
response = requests.delete(
f"{BASE_URL}/aliases/{alias_id}",
headers=headers
)
if response.status_code == 204:
print("Alias deleted successfully")
// Node.js
const response = await fetch(
`${BASE_URL}/aliases/${aliasId}`,
{ method: "DELETE", headers }
);
if (response.status === 204) {
console.log("Alias deleted");
}
GridInboxは一括操作もサポートしています。IDの配列を送信することで、1回のリクエストで最大50個のエイリアスを削除できます。正確なエンドポイントについてはAPIドキュメントを確認してください。
エイリアス管理をSaaSワークフローに統合することで、手作業の負担を減らし、メール配信の失敗を防げます。
自動化されたエイリアス管理は、いくつかの一般的なワークフローに自然に適合します。例えば、新しいユーザーがSaaS製品にサインアップしたとき、[email protected]のようなパーソナライズされたエイリアスを自動的に作成し、実際のメールアドレスに転送できます。ユーザーが解約したらエイリアスを削除します。これにより、メールエコシステムをクリーンで管理しやすい状態に保てます。
もう一つの一般的なパターンは、チームのオンボーディングです。開発者を雇ったら、必要な各サービス用のエイリアス（[email protected]、[email protected]、[email protected]）を作成します。退職時にはそれらのエイリアスを削除し、他の誰もメールを受信しないようにします。
GridInboxは、ロールベースのアクセス制御（RBAC）を備えたチーム共有受信トレイをサポートしています。つまり、エイリアスをチームに割り当て、複数のメンバーが同じアドレスから返信できるようにできます。APIを使えば、チームメンバーシップもプログラムで管理できます。
さらに高度な例として、CRMからのエイリアス同期があります。Salesforceに10,000人の顧客がいる場合、各顧客に自動請求書送信用のユニークなエイリアスを持たせたいとします。スクリプトで顧客リストをループし、エイリアスを作成し、エイリアスIDをデータベースに保存します。このプロセス全体はAPIを使えば10分もかかりません。
# CRM同期の疑似コード
customers = get_customers_from_crm()
for customer in customers:
alias_id = create_alias(
local_part=f"invoice-{customer.id}",
domain="invoices.mycompany.com",
forward_to=customer.email
)
save_to_database(customer.id, alias_id)
このアプローチは、任意の数のエイリアスにスケールします。GridInboxは有料プランで無制限のエイリアスを提供しているため、人為的な上限に達することはありません。
信頼性の高いAPI統合には、エラーハンドリングと冪等性が不可欠です。
APIは失敗します。ネットワークタイムアウトが発生します。レート制限に達します。統合はこれらを適切に処理する必要があります。常にHTTPステータスコードを確認してください。409 Conflictはエイリアスが既に存在することを意味します。429 Too Many Requestsはバックオフが必要であることを示します。422 Unprocessable Entityはペイロードに無効なデータがあることを意味します。
指数バックオフによるリトライロジックを実装してください。例えば、最初の失敗後1秒、2回目は2秒、3回目は4秒、最大60秒まで待機します。デバッグのためにすべての失敗をログに記録します。
冪等性も重要です。スクリプトがエイリアス作成の途中でクラッシュした場合、再起動時に重複が発生しないようにする必要があります。冪等性キーを使用してください。GridInboxはIdempotency-Keyヘッダーをサポートしています。各POSTリクエストにユニークなキーを送信します。同じキーが24時間以内に再度使用された場合、APIは元の結果を返し、重複を作成しません。
# 冪等性キーを使用したPython
import uuid
idempotency_key = str(uuid.uuid4())
headers["Idempotency-Key"] = idempotency_key
response = requests.post(f"{BASE_URL}/aliases", headers=headers, json=payload)
実際のパフォーマンス：少人数のチームでも50行未満の自動化コードで10,000個のエイリアスを管理できます。
これをGridInboxでテストしました。リクエスト間に60msの遅延を入れて1000個のエイリアスを作成するPythonスクリプトは、約60秒で完了します。同じスクリプトを一括エンドポイント（利用可能な場合）で実行すると、10秒未満で完了します。5000個のエイリアスがあるドメインの全エイリアスを一覧表示する場合、200ミリ秒未満で結果が返ります。
GridInboxは顧客ベース全体で月間1000万件以上のエイリアス操作を処理し、APIの稼働率SLAは99.95％です。適切に認証されたリクエストのエラー率は0.1％未満です。
5000人のアクティブ顧客を持つ一般的なSaaS企業の場合、顧客ごとに1つのエイリアスを作成し、各アカウントのライフサイクルを通じて管理するには、合計100行未満のコードで済みます。手動管理と比較した場合の時間節約効果は、2人のDevOpsエンジニアのチームで月約40時間です。
よくある質問
メールエイリアスAPIとは何ですか？
メールエイリアスAPIは、Webダッシュボードを使わずに、プログラムでメールエイリアスを作成・読み取り・更新・削除できるRESTfulインターフェースです。独自のアプリケーションでエイリアス管理を自動化できます。
REST APIでメールエイリアスを作成するにはどうすればよいですか？
ローカルパート、ドメイン、転送先アドレスを含むJSONペイロードを、エイリアスエンドポイントにPOSTリクエストとして送信します。AuthorizationヘッダーにAPIキーを含めてください。APIはエイリアスIDと詳細を返します。
Pythonでプログラム的にメールエイリアスを管理できますか？
はい。requestsライブラリを使用してエイリアスAPIにHTTP呼び出しを行います。シンプルな関数呼び出しでエイリアスの作成、一覧表示、更新、削除が可能です。GridInboxはドキュメントでPythonコード例を提供しています。
エイリアスを一括作成する際のレート制限にはどう対処すればよいですか？
リクエスト間に50～100ミリ秒の短い遅延を追加します。429ステータスコードを受け取った場合は、指数バックオフでリトライします。GridInboxはAPIキーあたり毎分1000リクエストを許可しています。
メールエイリアスとメールフォワーダーの違いは何ですか？
メールエイリアスはドメインに代わってメールの送受信ができるアドレスですが、フォワーダーは受信メールを別のアドレスに転送するだけです。GridInboxはエイリアスアドレスから返信を送信できる双方向エイリアスをサポートしています。
APIでエイリアスを削除しても安全ですか？
はい。ただし、そのエイリアスに依存するアクティブなワークフローがないことを確認した上で行ってください。エイリアスを削除すると、そのアドレスへのメール配信が即座に停止します。常に削除をログに記録し、自動化ではソフトデリートやアーカイブのステップを検討してください。
Die manuelle Verwaltung von E-Mail-Aliasen funktioniert für eine Handvoll Adressen. Doch wenn Sie auf Hunderte oder Tausende von Aliasen über mehrere Domains und Teams skalieren, werden manuelle Updates zum Engpass. Sie benötigen eine API, mit der Sie Alias programmatisch erstellen, aktualisieren und löschen können. Diese Anleitung führt Sie durch alles, was Sie für den Aufbau eines automatisierten Alias-Verwaltungssystems mit REST-API benötigen – mit funktionierenden Codebeispielen in Python und Node.js.
Eine E-Mail-Alias-API ermöglicht es Ihnen, Alias programmatisch zu erstellen, zu aktualisieren und zu löschen, ohne ein Dashboard zu öffnen.
Statt sich jedes Mal in eine Weboberfläche einzuloggen, wenn ein neuer Kunde registriert oder ein Teammitglied geht, können Sie Alias-Operationen direkt aus Ihrer Anwendungslogik heraus auslösen. Ein typisches SaaS-Unternehmen, das GridInbox nutzt, erstellt pro Woche 200 bis 500 Alias für die Einrichtung neuer Kunden und löscht sie, wenn Abonnements enden. Dieses Volumen ist ohne Automatisierung nicht zu bewältigen.
E-Mail-Alias-API: Eine RESTful-Schnittstelle, die es externen Anwendungen ermöglicht, E-Mail-Alias auf einem Mailserver oder einer Alias-Verwaltungsplattform programmatisch zu erstellen, zu lesen, zu aktualisieren und zu löschen.
Moderne Alias-Plattformen wie GridInbox stellen Endpunkte für jede Operation bereit, die Sie in einer Benutzeroberfläche ausführen würden. Dazu gehören das Erstellen von Aliasen, das Zuweisen zu bestimmten Domains, das Festlegen von Weiterleitungszielen und die Verwaltung von Berechtigungen für den Teamzugriff.
Die Authentifizierung für Alias-APIs erfolgt über API-Schlüssel oder OAuth-Tokens, die in den Request-Headern gesendet werden.
Jeder API-Aufruf muss authentifiziert werden. Die meisten Anbieter, einschließlich GridInbox, verwenden einen einfachen API-Schlüssel, der als Bearer-Token im Authorization-Header übergeben wird. Geben Sie Ihren API-Schlüssel niemals im clientseitigen Code oder in der Versionskontrolle preis. Speichern Sie ihn in Umgebungsvariablen oder einem Secrets-Manager.
Hier ist ein einfaches Authentifizierungsbeispiel in Python mit der requests-Bibliothek:
import requests
API_KEY = "your_gridinbox_api_key"
BASE_URL = "https://api.gridinbox.com/v1"
headers = {
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json"
}
In Node.js erreichen Sie dasselbe mit axios oder dem integrierten fetch:
const API_KEY = process.env.GRIDINBOX_API_KEY;
const BASE_URL = "https://api.gridinbox.com/v1";
const headers = {
"Authorization": `Bearer ${API_KEY}`,
"Content-Type": "application/json"
};
Verwenden Sie immer HTTPS. Härten Sie Anmeldedaten niemals ein. Rotieren Sie die Schlüssel regelmäßig, mindestens alle 90 Tage.
Das Erstellen eines E-Mail-Alias per API erfordert eine POST-Anfrage mit dem Alias-Namen, der Domain und den Weiterleitungsregeln.
Der häufigste Vorgang ist das Erstellen eines neuen Alias. Sie geben den lokalen Teil (den Teil vor dem @), die Domain und an, wohin E-Mails weitergeleitet werden sollen. Einige Plattformen ermöglichen auch das Festlegen eines Anzeigenamens und das Aktivieren des bidirektionalen Versands.
Hier ist eine Python-Funktion zum Erstellen eines Alias mit GridInbox:
def create_alias(local_part, domain, forward_to, display_name=None):
payload = {
"local_part": local_part,
"domain": domain,
"forward_to": forward_to,
"display_name": display_name or local_part
}
response = requests.post(
f"{BASE_URL}/aliases",
headers=headers,
json=payload
)
response.raise_for_status()
return response.json()
# Beispiel: [email protected] erstellen, Weiterleitung an [email protected]
result = create_alias("support", "mycompany.com", "[email protected]")
print(result["id"]) # z. B. "alias_abc123"
Und derselbe Vorgang in Node.js:
async function createAlias(localPart, domain, forwardTo, displayName) {
const payload = {
local_part: localPart,
domain: domain,
forward_to: forwardTo,
display_name: displayName || localPart
};
const response = await fetch(`${BASE_URL}/aliases`, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
});
if (!response.ok) throw new Error(`HTTP ${response.status}`);
return await response.json();
}
// Beispiel
createAlias("billing", "mycompany.com", "[email protected]")
.then(data => console.log(data.id));
Denken Sie an die Ratenbegrenzung. GridInbox erlaubt 1000 Anfragen pro Minute pro API-Schlüssel. Wenn Sie Alias in großen Mengen erstellen, bündeln Sie sie mit einer Verzögerung von 60 Millisekunden zwischen den Aufrufen, um unter dem Limit zu bleiben.
Die Verwaltung von Aliasen in großem Maßstab erfordert das Auflisten, Aktualisieren und Löschen über GET-, PATCH- und DELETE-Endpunkte.
Sobald Sie Alias erstellt haben, müssen Sie sie verwalten. Die API unterstützt vollständige CRUD-Operationen. Das Auflisten von Aliasen ermöglicht Ihnen eine Überprüfung des aktuellen Zustands. Aktualisierungen sind nützlich, wenn ein Teammitglied die Rolle wechselt und eine andere Weiterleitungsadresse benötigt. Das Löschen bereinigt veraltete Alias.
Alle Alias für eine Domain auflisten
# Python
response = requests.get(
f"{BASE_URL}/aliases?domain=mycompany.com",
headers=headers
)
aliases = response.json()
print(f"{len(aliases)} Alias gefunden")
// Node.js
const response = await fetch(
`${BASE_URL}/aliases?domain=mycompany.com`,
{ headers }
);
const aliases = await response.json();
console.log(`${aliases.length} Alias gefunden`);
Vorhandenen Alias aktualisieren
Um zu ändern, wohin ein Alias weiterleitet, verwenden Sie eine PATCH-Anfrage:
# Python
update_payload = {
"forward_to": "[email protected]"
}
response = requests.patch(
f"{BASE_URL}/aliases/{alias_id}",
headers=headers,
json=update_payload
)
// Node.js
const updatePayload = {
forward_to: "[email protected]"
};
const response = await fetch(
`${BASE_URL}/aliases/${aliasId}`,
{
method: "PATCH",
headers: headers,
body: JSON.stringify(updatePayload)
}
);
Alias löschen
Wenn ein Mitarbeiter geht oder ein Projekt endet, löschen Sie den Alias, um E-Mail-Bounces und Sicherheitsrisiken zu vermeiden:
# Python
response = requests.delete(
f"{BASE_URL}/aliases/{alias_id}",
headers=headers
)
if response.status_code == 204:
print("Alias erfolgreich gelöscht")
// Node.js
const response = await fetch(
`${BASE_URL}/aliases/${aliasId}`,
{ method: "DELETE", headers }
);
if (response.status === 204) {
console.log("Alias gelöscht");
}
GridInbox unterstützt auch Bulk-Operationen. Sie können bis zu 50 Alias in einer einzigen Anfrage löschen, indem Sie ein Array von IDs senden. Lesen Sie die API-Dokumentation für den genauen Endpunkt.
Die Integration der Alias-Verwaltung in Ihren SaaS-Workflow reduziert manuellen Aufwand und verhindert E-Mail-Zustellungsfehler.
Automatisierte Alias-Verwaltung fügt sich nahtlos in mehrere gängige Workflows ein. Wenn sich beispielsweise ein neuer Benutzer für Ihr SaaS-Produkt registriert, können Sie automatisch einen personalisierten Alias wie [email protected] erstellen und an seine echte E-Mail weiterleiten. Wenn er kündigt, löschen Sie den Alias. So bleibt Ihr E-Mail-Ökosystem sauber und überschaubar.
Ein weiteres häufiges Muster ist das Onboarding von Teams. Wenn Sie einen Entwickler einstellen, erstellen Sie Alias für jeden Dienst, auf den er Zugriff benötigt: [email protected], [email protected], [email protected]. Wenn er geht, löschen Sie diese Alias, damit niemand anderes seine Post erhält.
GridInbox unterstützt geteilte Team-Postfächer mit rollenbasierter Zugriffskontrolle (RBAC). Das bedeutet, Sie können einen Alias einem Team zuweisen und mehreren Personen erlauben, von derselben Adresse aus zu antworten. Die API ermöglicht es Ihnen, die Teammitgliedschaft ebenfalls programmatisch zu verwalten.
Hier ist ein fortgeschritteneres Beispiel: die Synchronisierung von Aliasen aus einem CRM. Angenommen, Sie haben 10.000 Kunden in Salesforce. Jeder soll einen eindeutigen Alias für den Versand automatisierter Rechnungen erhalten. Ein Skript kann Ihre Kundenliste durchlaufen, Alias erstellen und die Alias-IDs in Ihrer Datenbank speichern. Der gesamte Vorgang dauert mit der API weniger als 10 Minuten.
# Pseudocode für CRM-Synchronisierung
customers = get_customers_from_crm()
for customer in customers:
alias_id = create_alias(
local_part=f"invoice-{customer.id}",
domain="invoices.mycompany.com",
forward_to=customer.email
)
save_to_database(customer.id, alias_id)
Dieser Ansatz skaliert auf beliebig viele Alias. GridInbox bietet unbegrenzte Alias in seinen kostenpflichtigen Tarifen, sodass Sie nie an eine künstliche Grenze stoßen.
Fehlerbehandlung und Idempotenz sind entscheidend für eine zuverlässige API-Integration.
APIs schlagen fehl. Netzwerk-Timeouts treten auf. Ratenbegrenzungen werden erreicht. Ihre Integration muss diese Fälle elegant behandeln. Überprüfen Sie immer die HTTP-Statuscodes. Ein 409 Conflict bedeutet, dass der Alias bereits existiert. Ein 429 Too Many Requests bedeutet, dass Sie eine Pause einlegen müssen. Ein 422 Unprocessable Entity bedeutet, dass Ihre Nutzdaten ungültige Daten enthalten.
Implementieren Sie Wiederholungslogik mit exponentiellem Backoff. Warten Sie zum Beispiel 1 Sekunde nach dem ersten Fehler, 2 Sekunden nach dem zweiten, 4 nach dem dritten, bis zu maximal 60 Sekunden. Protokollieren Sie alle Fehler zur Fehlerbehebung.
Idempotenz ist ebenfalls wichtig. Wenn Ihr Skript beim Erstellen von Aliasen mitten drin abstürzt, möchten Sie keine Duplikate, wenn es neu startet. Verwenden Sie Idempotenzschlüssel. GridInbox unterstützt einen Idempotency-Key-Header. Senden Sie einen eindeutigen Schlüssel mit jeder POST-Anfrage. Wenn derselbe Schlüssel innerhalb von 24 Stunden erneut verwendet wird, gibt die API das ursprüngliche Ergebnis zurück, anstatt ein Duplikat zu erstellen.
# Python mit Idempotenzschlüssel
import uuid
idempotency_key = str(uuid.uuid4())
headers["Idempotency-Key"] = idempotency_key
response = requests.post(f"{BASE_URL}/aliases", headers=headers, json=payload)
Echte Leistung: Ein kleines Team kann mit weniger als 50 Zeilen Automatisierungscode 10.000 Alias verwalten.
Wir haben dies mit GridInbox getestet. Ein Python-Skript, das 1000 Alias mit einer Verzögerung von 60 ms zwischen den Anfragen erstellt, ist in etwa 60 Sekunden fertig. Dasselbe Skript mit Bulk-Endpunkten (sofern verfügbar) ist in unter 10 Sekunden fertig. Das Auflisten aller Alias für eine Domain mit 5000 Alias liefert Ergebnisse in unter 200 Millisekunden.
GridInbox verarbeitet monatlich über 10 Millionen Alias-Operationen in seiner Kundenbasis, mit einer Verfügbarkeits-SLA von 99,95 % für die API. Die Fehlerrate liegt bei ordnungsgemäß authentifizierten Anfragen unter 0,1 %.
Für ein typisches SaaS-Unternehmen mit 5000 aktiven Kunden erfordert das Erstellen eines Alias pro Kunde und die Verwaltung über den gesamten Lebenszyklus jedes Kontos weniger als 100 Codezeilen insgesamt. Der Zeitaufwand im Vergleich zur manuellen Verwaltung beträgt für ein Team von zwei DevOps-Ingenieuren etwa 40 Stunden pro Monat.
Häufig gestellte Fragen
Was ist eine E-Mail-Alias-API?
Eine E-Mail-Alias-API ist eine RESTful-Schnittstelle, mit der Sie programmatisch E-Mail-Alias erstellen, lesen, aktualisieren und löschen können, ohne ein Web-Dashboard zu verwenden. Sie ermöglicht die Automatisierung der Alias-Verwaltung in Ihren eigenen Anwendungen.
Wie erstelle ich einen E-Mail-Alias mit einer REST-API?
Senden Sie eine POST-Anfrage an den Alias-Endpunkt mit einem JSON-Payload, das den lokalen Teil, die Domain und die Weiterleitungsadresse enthält. Fügen Sie Ihren API-Schlüssel in den Authorization-Header ein. Die API gibt die Alias-ID und Details zurück.
Kann ich E-Mail-Alias programmatisch mit Python verwalten?
Ja. Verwenden Sie die requests-Bibliothek, um HTTP-Aufrufe an die Alias-API zu tätigen. Sie können Alias mit einfachen Funktionsaufrufen erstellen, auflisten, aktualisieren und löschen. GridInbox stellt Python-Codebeispiele in seiner Dokumentation bereit.
Wie gehe ich mit Ratenbegrenzungen um, wenn ich Alias in großen Mengen erstelle?
Fügen Sie eine kleine Verzögerung zwischen den Anfragen ein, typischerweise 50 bis 100 Millisekunden. Verwenden Sie exponentielles Backoff für Wiederholungen, wenn Sie einen 429-Statuscode erhalten. GridInbox erlaubt 1000 Anfragen pro Minute pro API-Schlüssel.
Was ist der Unterschied zwischen einem E-Mail-Alias und einem E-Mail-Weiterleiter?
Ein E-Mail-Alias ist eine Adresse, die sowohl E-Mails im Namen einer Domain senden als auch empfangen kann, während ein Weiterleiter eingehende E-Mails nur an eine andere Adresse umleitet. GridInbox unterstützt bidirektionale Alias, die Antworten von der Alias-Adresse aus senden können.
Ist es sicher, einen Alias per API zu löschen?
Ja, aber nur, nachdem Sie bestätigt haben, dass keine aktiven Workflows davon abhängen. Das Löschen eines Alias stoppt sofort die E-Mail-Zustellung an diese Adresse. Protokollieren Sie Löschungen immer und erwägen Sie einen Soft-Delete- oder Archivierungsschritt in Ihrer Automatisierung.
Gerenciar aliases de e-mail manualmente funciona para alguns endereços. Mas quando você escala para centenas ou milhares de aliases em vários domínios e equipes, as atualizações manuais se tornam um gargalo. Você precisa de uma API que permita criar, atualizar e excluir aliases programaticamente. Este guia aborda tudo o que você precisa para construir um sistema automatizado de gerenciamento de aliases usando API REST, com exemplos de código funcionais em Python e Node.js.
Uma API de alias de e-mail permite criar, atualizar e excluir aliases programaticamente sem tocar em um painel.
Em vez de acessar uma interface web toda vez que um novo cliente se cadastra ou um membro da equipe sai, você pode acionar operações de alias a partir da lógica da sua própria aplicação. Uma empresa SaaS típica que usa GridInbox pode criar de 200 a 500 aliases por semana para integrar novos clientes e depois excluí-los quando as assinaturas terminam. Esse volume é incontrolável sem automação.
API de Alias de E-mail: Uma interface RESTful que permite que aplicações externas criem, leiam, atualizem e excluam aliases de e-mail programaticamente em um servidor de e-mail ou plataforma de gerenciamento de aliases.
Plataformas modernas de alias, como a GridInbox, expõem endpoints para cada operação que você realizaria em uma interface de usuário. Isso inclui criar aliases, vinculá-los a domínios específicos, definir destinos de encaminhamento e gerenciar permissões para acesso da equipe.
A autenticação para APIs de alias usa chaves de API ou tokens OAuth enviados nos cabeçalhos das requisições.
Toda chamada de API deve ser autenticada. A maioria dos provedores, incluindo a GridInbox, usa uma chave de API simples passada como um token Bearer no cabeçalho Authorization. Nunca exponha sua chave de API em código do lado do cliente ou em controle de versão. Armazene-a em variáveis de ambiente ou em um gerenciador de segredos.
Aqui está um exemplo básico de autenticação em Python usando a biblioteca requests:
import requests
API_KEY = "sua_chave_api_gridinbox"
BASE_URL = "https://api.gridinbox.com/v1"
headers = {
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json"
}
Em Node.js, você pode fazer o mesmo com axios ou com o fetch nativo:
const API_KEY = process.env.GRIDINBOX_API_KEY;
const BASE_URL = "https://api.gridinbox.com/v1";
const headers = {
"Authorization": `Bearer ${API_KEY}`,
"Content-Type": "application/json"
};
Sempre use HTTPS. Nunca codifique credenciais. Rotacione as chaves regularmente, pelo menos a cada 90 dias.
Criar um alias de e-mail via API exige o envio de uma requisição POST com o nome do alias, domínio e regras de encaminhamento.
A operação mais comum é criar um novo alias. Você especifica a parte local (a parte antes do @), o domínio e para onde os e-mails devem ser encaminhados. Algumas plataformas também permitem definir um nome de exibição e habilitar o envio bidirecional.
Aqui está uma função em Python para criar um alias com a GridInbox:
def create_alias(local_part, domain, forward_to, display_name=None):
payload = {
"local_part": local_part,
"domain": domain,
"forward_to": forward_to,
"display_name": display_name or local_part
}
response = requests.post(
f"{BASE_URL}/aliases",
headers=headers,
json=payload
)
response.raise_for_status()
return response.json()
# Exemplo: criar [email protected] encaminhando para [email protected]
result = create_alias("support", "minhaempresa.com", "[email protected]")
print(result["id"]) # ex.: "alias_abc123"
E a mesma operação em Node.js:
async function createAlias(localPart, domain, forwardTo, displayName) {
const payload = {
local_part: localPart,
domain: domain,
forward_to: forwardTo,
display_name: displayName || localPart
};
const response = await fetch(`${BASE_URL}/aliases`, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
});
if (!response.ok) throw new Error(`HTTP ${response.status}`);
return await response.json();
}
// Exemplo
createAlias("billing", "minhaempresa.com", "[email protected]")
.then(data => console.log(data.id));
Lembre-se de lidar com os limites de taxa. A GridInbox permite 1000 requisições por minuto por chave de API. Se você estiver criando aliases em lote, agrupe-os com um atraso de 60 milissegundos entre as chamadas para ficar abaixo do limite.
Gerenciar aliases em escala significa que você precisa listar, atualizar e excluí-los usando endpoints GET, PATCH e DELETE.
Depois de criar aliases, você precisará gerenciá-los. A API oferece suporte a operações CRUD completas. Listar aliases permite auditar seu estado atual. Atualizar é útil quando um membro da equipe muda de função e precisa de um endereço de encaminhamento diferente. Excluir limpa aliases obsoletos.
Listando todos os aliases de um domínio
# Python
response = requests.get(
f"{BASE_URL}/aliases?domain=minhaempresa.com",
headers=headers
)
aliases = response.json()
print(f"Encontrados {len(aliases)} aliases")
// Node.js
const response = await fetch(
`${BASE_URL}/aliases?domain=minhaempresa.com`,
{ headers }
);
const aliases = await response.json();
console.log(`Encontrados ${aliases.length} aliases`);
Atualizando um alias existente
Para alterar para onde um alias encaminha, use uma requisição PATCH:
# Python
update_payload = {
"forward_to": "[email protected]"
}
response = requests.patch(
f"{BASE_URL}/aliases/{alias_id}",
headers=headers,
json=update_payload
)
// Node.js
const updatePayload = {
forward_to: "[email protected]"
};
const response = await fetch(
`${BASE_URL}/aliases/${aliasId}`,
{
method: "PATCH",
headers: headers,
body: JSON.stringify(updatePayload)
}
);
Excluindo um alias
Quando um funcionário sai ou um projeto termina, exclua o alias para evitar rejeições de e-mail e riscos de segurança:
# Python
response = requests.delete(
f"{BASE_URL}/aliases/{alias_id}",
headers=headers
)
if response.status_code == 204:
print("Alias excluído com sucesso")
// Node.js
const response = await fetch(
`${BASE_URL}/aliases/${aliasId}`,
{ method: "DELETE", headers }
);
if (response.status === 204) {
console.log("Alias excluído");
}
A GridInbox também oferece suporte a operações em lote. Você pode excluir até 50 aliases em uma única requisição enviando um array de IDs. Consulte a documentação da API para o endpoint exato.
Integrar o gerenciamento de aliases ao seu fluxo de trabalho SaaS reduz a sobrecarga manual e evita falhas na entrega de e-mails.
O gerenciamento automatizado de aliases se encaixa naturalmente em vários fluxos de trabalho comuns. Por exemplo, quando um novo usuário se cadastra no seu produto SaaS, você pode criar automaticamente um alias personalizado como [email protected] e encaminhá-lo para o e-mail real dele. Quando ele cancela, você exclui o alias. Isso mantém seu ecossistema de e-mail limpo e gerenciável.
Outro padrão comum é a integração de equipes. Quando você contrata um desenvolvedor, cria aliases para cada um dos serviços aos quais ele precisa acessar: [email protected], [email protected], [email protected]. Quando ele sai, você exclui esses aliases para que ninguém mais receba os e-mails dele.
A GridInbox oferece suporte a caixas de entrada compartilhadas de equipe com controle de acesso baseado em funções (RBAC). Isso significa que você pode atribuir um alias a uma equipe e permitir que várias pessoas respondam do mesmo endereço. A API permite gerenciar a associação da equipe programaticamente também.
Aqui está um exemplo mais avançado: sincronizar aliases a partir de um CRM. Suponha que você tenha 10.000 clientes no Salesforce. Você quer que cada um tenha um alias único para enviar faturas automatizadas. Um script pode percorrer sua lista de clientes, criar aliases e armazenar os IDs dos aliases no seu banco de dados. Todo o processo leva menos de 10 minutos com a API.
# Pseudocódigo para sincronização com CRM
clientes = obter_clientes_do_crm()
for cliente in clientes:
alias_id = criar_alias(
local_part=f"fatura-{cliente.id}",
domain="faturas.minhaempresa.com",
forward_to=cliente.email
)
salvar_no_banco(cliente.id, alias_id)
Essa abordagem escala para qualquer número de aliases. A GridInbox oferece aliases ilimitados em seus planos pagos, para que você nunca encontre um teto artificial.
Tratamento de erros e idempotência são essenciais para uma integração confiável com a API.
APIs falham. Ocorrem timeouts de rede. Limites de taxa são atingidos. Sua integração deve lidar com isso de forma elegante. Sempre verifique os códigos de status HTTP. Um 409 Conflict significa que o alias já existe. Um 429 Too Many Requests significa que você precisa recuar. Um 422 Unprocessable Entity significa que seu payload contém dados inválidos.
Implemente lógica de repetição com backoff exponencial. Por exemplo, aguarde 1 segundo após a primeira falha, 2 segundos após a segunda, 4 após a terceira, até um máximo de 60 segundos. Registre todas as falhas para depuração.
A idempotência também é importante. Se seu script falhar no meio da criação de aliases, você não quer duplicatas quando ele reiniciar. Use chaves de idempotência. A GridInbox oferece suporte ao cabeçalho Idempotency-Key. Envie uma chave única com cada requisição POST. Se a mesma chave for usada novamente dentro de 24 horas, a API retorna o resultado original em vez de criar uma duplicata.
# Python com chave de idempotência
import uuid
idempotency_key = str(uuid.uuid4())
headers["Idempotency-Key"] = idempotency_key
response = requests.post(f"{BASE_URL}/aliases", headers=headers, json=payload)
Desempenho no mundo real: uma pequena equipe pode gerenciar 10.000 aliases com menos de 50 linhas de código de automação.
Testamos isso com a GridInbox. Um script Python que cria 1000 aliases com um atraso de 60ms entre as requisições é concluído em cerca de 60 segundos. O mesmo script usando endpoints em lote (quando disponíveis) termina em menos de 10 segundos. Listar todos os aliases de um domínio com 5000 aliases retorna resultados em menos de 200 milissegundos.
A GridInbox processa mais de 10 milhões de operações de alias por mês em sua base de clientes, com um SLA de uptime de 99,95% na API. As taxas de erro estão abaixo de 0,1% para requisições devidamente autenticadas.
Para uma empresa SaaS típica com 5000 clientes ativos, criar um alias por cliente e gerenciá-los ao longo do ciclo de vida de cada conta requer menos de 100 linhas de código no total. O tempo economizado em comparação com o gerenciamento manual é de aproximadamente 40 horas por mês para uma equipe de dois engenheiros de DevOps.
Perguntas Frequentes
O que é uma API de alias de e-mail?
Uma API de alias de e-mail é uma interface RESTful que permite criar, ler, atualizar e excluir aliases de e-mail programaticamente, sem usar um painel web. Ela possibilita a automação do gerenciamento de aliases em suas próprias aplicações.
Como criar um alias de e-mail com uma API REST?
Envie uma requisição POST para o endpoint de aliases com um payload JSON contendo a parte local, o domínio e o endereço de encaminhamento. Inclua sua chave de API no cabeçalho Authorization. A API retorna o ID e os detalhes do alias.
Posso gerenciar aliases de e-mail programaticamente com Python?
Sim. Use a biblioteca requests para fazer chamadas HTTP para a API de alias. Você pode criar, listar, atualizar e excluir aliases com simples chamadas de função. A GridInbox fornece exemplos de código Python em sua documentação.
Como lidar com limites de taxa ao criar aliases em lote?
Adicione um pequeno atraso entre as requisições, tipicamente de 50 a 100 milissegundos. Use backoff exponencial para novas tentativas ao receber um código de status 429. A GridInbox permite 1000 requisições por minuto por chave de API.
Qual é a diferença entre um alias de e-mail e um redirecionador de e-mail?
Um alias de e-mail é um endereço que pode tanto enviar quanto receber e-mails em nome de um domínio, enquanto um redirecionador apenas encaminha e-mails recebidos para outro endereço. A GridInbox oferece suporte a aliases bidirecionais que podem enviar respostas a partir do endereço do alias.
É seguro excluir um alias via API?
Sim, mas somente após confirmar que nenhum fluxo de trabalho ativo depende dele. Excluir um alias interrompe imediatamente a entrega de e-mails para esse endereço. Sempre registre as exclusões e considere uma etapa de exclusão suave ou arquivamento em sua automação.
이메일 별칭을 수동으로 관리하는 것은 소수의 주소만 다룰 때는 괜찮습니다. 하지만 여러 도메인과 팀에 걸쳐 수백, 수천 개의 별칭으로 확장하면 수동 업데이트가 병목 현상이 됩니다. 별칭을 프로그래밍 방식으로 생성, 업데이트, 삭제할 수 있는 API가 필요합니다. 이 가이드에서는 REST API를 사용하여 자동화된 별칭 관리 시스템을 구축하는 데 필요한 모든 내용을 Python과 Node.js의 실제 코드 예제와 함께 설명합니다.
이메일 별칭 API를 사용하면 대시보드에 접속하지 않고도 프로그래밍 방식으로 별칭을 생성, 업데이트, 삭제할 수 있습니다.
새 고객이 가입하거나 팀원이 퇴사할 때마다 웹 인터페이스에 로그인하는 대신, 자체 애플리케이션 로직에서 별칭 작업을 트리거할 수 있습니다. GridInbox를 사용하는 일반적인 SaaS 회사는 신규 고객 온보딩을 위해 주당 200~500개의 별칭을 생성하고, 구독이 종료되면 이를 삭제합니다. 이러한 규모는 자동화 없이는 관리가 불가능합니다.
이메일 별칭 API: 외부 애플리케이션이 메일 서버 또는 별칭 관리 플랫폼에서 이메일 별칭을 프로그래밍 방식으로 생성, 읽기, 업데이트, 삭제할 수 있도록 하는 RESTful 인터페이스입니다.
GridInbox와 같은 최신 별칭 플랫폼은 UI에서 수행하는 모든 작업에 대한 엔드포인트를 제공합니다. 여기에는 별칭 생성, 특정 도메인에 연결, 전달 대상 설정, 팀 액세스 권한 관리 등이 포함됩니다.
별칭 API 인증은 요청 헤더에 전송되는 API 키 또는 OAuth 토큰을 사용합니다.
모든 API 호출은 인증되어야 합니다. GridInbox를 포함한 대부분의 제공업체는 Authorization 헤더에 Bearer 토큰으로 전달되는 간단한 API 키를 사용합니다. API 키를 클라이언트 측 코드나 버전 관리 시스템에 절대 노출하지 마세요. 환경 변수 또는 비밀 관리자에 저장하세요.
다음은 requests 라이브러리를 사용한 Python의 기본 인증 예제입니다:
import requests
API_KEY = "your_gridinbox_api_key"
BASE_URL = "https://api.gridinbox.com/v1"
headers = {
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json"
}
Node.js에서는 axios 또는 내장 fetch로 동일한 작업을 수행할 수 있습니다:
const API_KEY = process.env.GRIDINBOX_API_KEY;
const BASE_URL = "https://api.gridinbox.com/v1";
const headers = {
"Authorization": `Bearer ${API_KEY}`,
"Content-Type": "application/json"
};
항상 HTTPS를 사용하세요. 자격 증명을 하드코딩하지 마세요. 키는 최소 90일마다 정기적으로 교체하세요.
API를 통해 이메일 별칭을 생성하려면 별칭 이름, 도메인 및 전달 규칙이 포함된 POST 요청을 전송해야 합니다.
가장 일반적인 작업은 새 별칭을 생성하는 것입니다. @ 앞의 로컬 부분, 도메인 및 이메일이 전달될 대상을 지정합니다. 일부 플랫폼에서는 표시 이름을 설정하고 양방향 전송을 활성화할 수도 있습니다.
다음은 GridInbox로 별칭을 생성하는 Python 함수입니다:
def create_alias(local_part, domain, forward_to, display_name=None):
payload = {
"local_part": local_part,
"domain": domain,
"forward_to": forward_to,
"display_name": display_name or local_part
}
response = requests.post(
f"{BASE_URL}/aliases",
headers=headers,
json=payload
)
response.raise_for_status()
return response.json()
# 예시: [email protected]을 [email protected]으로 전달
result = create_alias("support", "mycompany.com", "[email protected]")
print(result["id"]) # 예: "alias_abc123"
Node.js에서 동일한 작업:
async function createAlias(localPart, domain, forwardTo, displayName) {
const payload = {
local_part: localPart,
domain: domain,
forward_to: forwardTo,
display_name: displayName || localPart
};
const response = await fetch(`${BASE_URL}/aliases`, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
});
if (!response.ok) throw new Error(`HTTP ${response.status}`);
return await response.json();
}
// 예시
createAlias("billing", "mycompany.com", "[email protected]")
.then(data => console.log(data.id));
속도 제한을 처리하는 것을 잊지 마세요. GridInbox는 API 키당 분당 1000개의 요청을 허용합니다. 별칭을 대량으로 생성하는 경우 호출 간에 60밀리초의 지연을 두고 배치하여 제한을 초과하지 않도록 하세요.
대규모 별칭 관리를 위해서는 GET, PATCH 및 DELETE 엔드포인트를 사용하여 별칭을 나열, 업데이트 및 삭제해야 합니다.
별칭을 생성한 후에는 이를 관리해야 합니다. API는 전체 CRUD 작업을 지원합니다. 별칭을 나열하면 현재 상태를 감사할 수 있습니다. 업데이트는 팀원이 역할을 변경하여 다른 전달 주소가 필요할 때 유용합니다. 삭제는 오래된 별칭을 정리합니다.
도메인의 모든 별칭 나열
# Python
response = requests.get(
f"{BASE_URL}/aliases?domain=mycompany.com",
headers=headers
)
aliases = response.json()
print(f"{len(aliases)}개의 별칭을 찾았습니다")
// Node.js
const response = await fetch(
`${BASE_URL}/aliases?domain=mycompany.com`,
{ headers }
);
const aliases = await response.json();
console.log(`${aliases.length}개의 별칭을 찾았습니다`);
기존 별칭 업데이트
별칭이 전달되는 대상을 변경하려면 PATCH 요청을 사용하세요:
# Python
update_payload = {
"forward_to": "[email protected]"
}
response = requests.patch(
f"{BASE_URL}/aliases/{alias_id}",
headers=headers,
json=update_payload
)
// Node.js
const updatePayload = {
forward_to: "[email protected]"
};
const response = await fetch(
`${BASE_URL}/aliases/${aliasId}`,
{
method: "PATCH",
headers: headers,
body: JSON.stringify(updatePayload)
}
);
별칭 삭제
직원이 퇴사하거나 프로젝트가 종료되면 이메일 반송 및 보안 위험을 방지하기 위해 별칭을 삭제하세요:
# Python
response = requests.delete(
f"{BASE_URL}/aliases/{alias_id}",
headers=headers
)
if response.status_code == 204:
print("별칭이 성공적으로 삭제되었습니다")
// Node.js
const response = await fetch(
`${BASE_URL}/aliases/${aliasId}`,
{ method: "DELETE", headers }
);
if (response.status === 204) {
console.log("별칭이 삭제되었습니다");
}
GridInbox는 대량 작업도 지원합니다. ID 배열을 전송하여 단일 요청으로 최대 50개의 별칭을 삭제할 수 있습니다. 정확한 엔드포인트는 API 문서를 확인하세요.
SaaS 워크플로에 별칭 관리를 통합하면 수동 오버헤드를 줄이고 이메일 전송 실패를 방지할 수 있습니다.
자동화된 별칭 관리는 여러 일반적인 워크플로에 자연스럽게 맞습니다. 예를 들어, 새 사용자가 SaaS 제품에 가입하면 [email protected]과 같은 개인화된 별칭을 자동으로 생성하여 실제 이메일로 전달할 수 있습니다. 사용자가 취소하면 별칭을 삭제합니다. 이렇게 하면 이메일 생태계가 깔끔하고 관리하기 쉬워집니다.
또 다른 일반적인 패턴은 팀 온보딩입니다. 개발자를 고용하면 필요한 각 서비스에 대한 별칭을 생성합니다: [email protected], [email protected], [email protected]. 퇴사하면 해당 별칭을 삭제하여 다른 사람이 메일을 받지 않도록 합니다.
GridInbox는 역할 기반 액세스 제어(RBAC)를 갖춘 팀 공유 받은편지함을 지원합니다. 즉, 별칭을 팀에 할당하고 여러 사람이 동일한 주소에서 답장을 보낼 수 있습니다. API를 통해 팀 멤버십도 프로그래밍 방식으로 관리할 수 있습니다.
다음은 CRM에서 별칭을 동기화하는 고급 예제입니다. Salesforce에 10,000명의 고객이 있다고 가정해 보겠습니다. 각 고객에게 자동화된 청구서를 보내기 위한 고유한 별칭을 원합니다. 스크립트가 고객 목록을 반복하여 별칭을 생성하고 별칭 ID를 데이터베이스에 저장할 수 있습니다. 전체 프로세스는 API를 사용하여 10분 미만이 소요됩니다.
# CRM 동기화를 위한 의사 코드
customers = get_customers_from_crm()
for customer in customers:
alias_id = create_alias(
local_part=f"invoice-{customer.id}",
domain="invoices.mycompany.com",
forward_to=customer.email
)
save_to_database(customer.id, alias_id)
이 접근 방식은 모든 수의 별칭으로 확장 가능합니다. GridInbox는 유료 요금제에서 무제한 별칭을 제공하므로 인위적인 제한에 부딪히지 않습니다.
안정적인 API 통합을 위해서는 오류 처리와 멱등성이 중요합니다.
API는 실패합니다. 네트워크 타임아웃이 발생합니다. 속도 제한에 도달합니다. 통합은 이러한 상황을 원활하게 처리해야 합니다. 항상 HTTP 상태 코드를 확인하세요. 409 Conflict는 별칭이 이미 존재함을 의미합니다. 429 Too Many Requests는 속도를 늦춰야 함을 의미합니다. 422 Unprocessable Entity는 페이로드에 잘못된 데이터가 있음을 의미합니다.
지수 백오프를 사용한 재시도 로직을 구현하세요. 예를 들어, 첫 번째 실패 후 1초, 두 번째 실패 후 2초, 세 번째 실패 후 4초, 최대 60초까지 기다립니다. 디버깅을 위해 모든 실패를 기록하세요.
멱등성도 중요합니다. 스크립트가 별칭 생성 중간에 충돌하면 다시 시작할 때 중복이 발생하지 않아야 합니다. 멱등성 키를 사용하세요. GridInbox는 Idempotency-Key 헤더를 지원합니다. 각 POST 요청과 함께 고유한 키를 전송하세요. 동일한 키가 24시간 이내에 다시 사용되면 API는 중복을 생성하는 대신 원래 결과를 반환합니다.
# 멱등성 키를 사용한 Python
import uuid
idempotency_key = str(uuid.uuid4())
headers["Idempotency-Key"] = idempotency_key
response = requests.post(f"{BASE_URL}/aliases", headers=headers, json=payload)
실제 성능: 소규모 팀이 50줄 미만의 자동화 코드로 10,000개의 별칭을 관리할 수 있습니다.
GridInbox로 테스트했습니다. 요청 간 60ms 지연으로 1000개의 별칭을 생성하는 Python 스크립트는 약 60초 안에 완료됩니다. 동일한 스크립트가 대량 엔드포인트(사용 가능한 경우)를 사용하면 10초 미만으로 완료됩니다. 5000개의 별칭이 있는 도메인의 모든 별칭을 나열하면 200밀리초 미만으로 결과가 반환됩니다.
GridInbox는 고객 기반에서 월간 1000만 건 이상의 별칭 작업을 처리하며, API의 99.95% 가동 시간 SLA를 제공합니다. 적절히 인증된 요청의 오류율은 0.1% 미만입니다.
5000명의 활성 고객이 있는 일반적인 SaaS 회사의 경우, 고객당 하나의 별칭을 생성하고 각 계정의 수명 주기 동안 이를 관리하는 데 총 100줄 미만의 코드가 필요합니다. 수동 관리와 비교하여 절약되는 시간은 두 명의 DevOps 엔지니어로 구성된 팀 기준 월 약 40시간입니다.
자주 묻는 질문
이메일 별칭 API란 무엇인가요?
이메일 별칭 API는 웹 대시보드를 사용하지 않고 프로그래밍 방식으로 이메일 별칭을 생성, 읽기, 업데이트, 삭제할 수 있는 RESTful 인터페이스입니다. 자체 애플리케이션에서 별칭 관리를 자동화할 수 있습니다.
REST API로 이메일 별칭을 어떻게 생성하나요?
로컬 부분, 도메인 및 전달 주소가 포함된 JSON 페이로드와 함께 aliases 엔드포인트로 POST 요청을 전송하세요. Authorization 헤더에 API 키를 포함하세요. API는 별칭 ID와 세부 정보를 반환합니다.
Python으로 이메일 별칭을 프로그래밍 방식으로 관리할 수 있나요?
네. requests 라이브러리를 사용하여 별칭 API에 HTTP 호출을 할 수 있습니다. 간단한 함수 호출로 별칭을 생성, 나열, 업데이트 및 삭제할 수 있습니다. GridInbox는 문서에서 Python 코드 예제를 제공합니다.
별칭을 대량으로 생성할 때 속도 제한을 어떻게 처리하나요?
요청 사이에 일반적으로 50~100밀리초의 작은 지연을 추가하세요. 429 상태 코드를 받으면 재시도에 지수 백오프를 사용하세요. GridInbox는 API 키당 분당 1000개의 요청을 허용합니다.
이메일 별칭과 이메일 전달자의 차이점은 무엇인가요?
이메일 별칭은 도메인을 대신하여 이메일을 보내고 받을 수 있는 주소인 반면, 전달자는 들어오는 메일을 다른 주소로만 리디렉션합니다. GridInbox는 별칭 주소에서 답장을 보낼 수 있는 양방향 별칭을 지원합니다.
API를 통해 별칭을 삭제해도 안전한가요?
네, 하지만 해당 별칭에 의존하는 활성 워크플로가 없는지 확인한 후에만 가능합니다. 별칭을 삭제하면 해당 주소로의 이메일 전달이 즉시 중단됩니다. 항상 삭제를 기록하고 자동화에 소프트 삭제 또는 보관 단계를 고려하세요.
Управление email-алиасами вручную работает для нескольких адресов. Но когда вы масштабируетесь до сотен или тысяч алиасов в нескольких доменах и командах, ручные обновления становятся узким местом. Вам нужен API, который позволяет создавать, обновлять и удалять алиасы программно. Это руководство проведет вас через все, что нужно для создания автоматизированной системы управления алиасами с помощью REST API, с рабочими примерами кода на Python и Node.js.
Email Alias API позволяет создавать, обновлять и удалять алиасы программно, не заходя в панель управления.
Вместо того чтобы каждый раз входить в веб-интерфейс, когда регистрируется новый клиент или уходит сотрудник, вы можете запускать операции с алиасами из логики вашего приложения. Типичная SaaS-компания, использующая GridInbox, может создавать от 200 до 500 алиасов в неделю для подключения новых клиентов, а затем удалять их по окончании подписки. Такой объем невозможно обрабатывать без автоматизации.
Email Alias API: RESTful-интерфейс, который позволяет внешним приложениям программно создавать, читать, обновлять и удалять email-алиасы на почтовом сервере или платформе управления алиасами.
Современные платформы для работы с алиасами, такие как GridInbox, предоставляют эндпоинты для всех операций, которые вы выполняете в интерфейсе. Это включает создание алиасов, привязку к конкретным доменам, настройку целей пересылки и управление правами доступа для команды.
Аутентификация для API алиасов использует API-ключи или OAuth-токены, передаваемые в заголовках запросов.
Каждый вызов API должен быть аутентифицирован. Большинство провайдеров, включая GridInbox, используют простой API-ключ, передаваемый как Bearer-токен в заголовке Authorization. Никогда не раскрывайте ваш API-ключ в клиентском коде или системе контроля версий. Храните его в переменных окружения или менеджере секретов.
Вот базовый пример аутентификации на Python с использованием библиотеки requests:
import requests
API_KEY = "your_gridinbox_api_key"
BASE_URL = "https://api.gridinbox.com/v1"
headers = {
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json"
}
В Node.js то же самое можно сделать с помощью axios или встроенного fetch:
const API_KEY = process.env.GRIDINBOX_API_KEY;
const BASE_URL = "https://api.gridinbox.com/v1";
const headers = {
"Authorization": `Bearer ${API_KEY}`,
"Content-Type": "application/json"
};
Всегда используйте HTTPS. Никогда не жестко кодируйте учетные данные. Регулярно меняйте ключи, как минимум каждые 90 дней.
Создание email-алиаса через API требует отправки POST-запроса с именем алиаса, доменом и правилами пересылки.
Самая распространенная операция — создание нового алиаса. Вы указываете локальную часть (часть до @), домен и адрес, на который должны пересылаться письма. Некоторые платформы также позволяют задать отображаемое имя и включить двунаправленную отправку.
Вот функция на Python для создания алиаса в GridInbox:
def create_alias(local_part, domain, forward_to, display_name=None):
payload = {
"local_part": local_part,
"domain": domain,
"forward_to": forward_to,
"display_name": display_name or local_part
}
response = requests.post(
f"{BASE_URL}/aliases",
headers=headers,
json=payload
)
response.raise_for_status()
return response.json()
# Пример: создаем [email protected] с пересылкой на [email protected]
result = create_alias("support", "mycompany.com", "[email protected]")
print(result["id"]) # например, "alias_abc123"
И та же операция на Node.js:
async function createAlias(localPart, domain, forwardTo, displayName) {
const payload = {
local_part: localPart,
domain: domain,
forward_to: forwardTo,
display_name: displayName || localPart
};
const response = await fetch(`${BASE_URL}/aliases`, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
});
if (!response.ok) throw new Error(`HTTP ${response.status}`);
return await response.json();
}
// Пример
createAlias("billing", "mycompany.com", "[email protected]")
.then(data => console.log(data.id));
Не забывайте про лимиты запросов. GridInbox допускает 1000 запросов в минуту на один API-ключ. Если вы создаете алиасы массово, отправляйте их с задержкой в 60 миллисекунд между вызовами, чтобы не превысить лимит.
Управление алиасами в масштабе требует возможности их списка, обновления и удаления через эндпоинты GET, PATCH и DELETE.
После создания алиасов вам нужно будет ими управлять. API поддерживает полный набор CRUD-операций. Список алиасов позволяет провести аудит текущего состояния. Обновление полезно, когда сотрудник меняет роль и ему нужен другой адрес для пересылки. Удаление очищает устаревшие алиасы.
Получение списка всех алиасов для домена
# Python
response = requests.get(
f"{BASE_URL}/aliases?domain=mycompany.com",
headers=headers
)
aliases = response.json()
print(f"Найдено {len(aliases)} алиасов")
// Node.js
const response = await fetch(
`${BASE_URL}/aliases?domain=mycompany.com`,
{ headers }
);
const aliases = await response.json();
console.log(`Найдено ${aliases.length} алиасов`);
Обновление существующего алиаса
Чтобы изменить адрес пересылки для алиаса, используйте PATCH-запрос:
# Python
update_payload = {
"forward_to": "[email protected]"
}
response = requests.patch(
f"{BASE_URL}/aliases/{alias_id}",
headers=headers,
json=update_payload
)
// Node.js
const updatePayload = {
forward_to: "[email protected]"
};
const response = await fetch(
`${BASE_URL}/aliases/${aliasId}`,
{
method: "PATCH",
headers: headers,
body: JSON.stringify(updatePayload)
}
);
Удаление алиаса
Когда сотрудник увольняется или проект завершается, удалите алиас, чтобы избежать возвратов писем и рисков безопасности:
# Python
response = requests.delete(
f"{BASE_URL}/aliases/{alias_id}",
headers=headers
)
if response.status_code == 204:
print("Алиас успешно удален")
// Node.js
const response = await fetch(
`${BASE_URL}/aliases/${aliasId}`,
{ method: "DELETE", headers }
);
if (response.status === 204) {
console.log("Алиас удален");
}
GridInbox также поддерживает массовые операции. Вы можете удалить до 50 алиасов одним запросом, отправив массив идентификаторов. Уточните точный эндпоинт в документации API.
Интеграция управления алиасами в ваш SaaS-процесс снижает ручную нагрузку и предотвращает сбои доставки писем.
Автоматизированное управление алиасами естественно вписывается в несколько типичных рабочих процессов. Например, когда новый пользователь регистрируется в вашем SaaS-продукте, вы можете автоматически создать персонализированный алиас вида [email protected] и перенаправлять письма на его реальный email. Когда он отменяет подписку, вы удаляете алиас. Это поддерживает чистоту и управляемость вашей email-экосистемы.
Еще один распространенный сценарий — онбординг сотрудников. Когда вы нанимаете разработчика, вы создаете алиасы для каждого сервиса, к которому ему нужен доступ: [email protected], [email protected], [email protected]. Когда он уходит, вы удаляете эти алиасы, чтобы никто другой не получал его почту.
GridInbox поддерживает командные общие почтовые ящики с управлением доступом на основе ролей (RBAC). Это означает, что вы можете назначить алиас команде и разрешить нескольким людям отвечать с одного адреса. API позволяет управлять членством в команде программно.
Вот более продвинутый пример: синхронизация алиасов из CRM. Предположим, у вас 10 000 клиентов в Salesforce. Вы хотите, чтобы у каждого был уникальный алиас для отправки автоматических счетов. Скрипт может пройтись по списку клиентов, создать алиасы и сохранить их ID в вашей базе данных. Весь процесс занимает менее 10 минут с помощью API.
# Псевдокод для синхронизации с CRM
customers = get_customers_from_crm()
for customer in customers:
alias_id = create_alias(
local_part=f"invoice-{customer.id}",
domain="invoices.mycompany.com",
forward_to=customer.email
)
save_to_database(customer.id, alias_id)
Такой подход масштабируется на любое количество алиасов. GridInbox предлагает неограниченное количество алиасов в платных тарифах, так что вы никогда не упретесь в искусственный потолок.
Обработка ошибок и идемпотентность критически важны для надежной интеграции с API.
API могут давать сбои. Возникают тайм-ауты сети. Достигаются лимиты запросов. Ваша интеграция должна корректно обрабатывать эти ситуации. Всегда проверяйте HTTP-статусы. Код 409 Conflict означает, что алиас уже существует. Код 429 Too Many Requests — что нужно снизить частоту запросов. Код 422 Unprocessable Entity — что в ваших данных есть ошибка.
Реализуйте логику повторных попыток с экспоненциальной задержкой. Например, подождите 1 секунду после первого сбоя, 2 секунды после второго, 4 после третьего, вплоть до максимума в 60 секунд. Логируйте все сбои для отладки.
Идемпотентность также важна. Если ваш скрипт упал на полпути при создании алиасов, вы не хотите дубликатов при перезапуске. Используйте ключи идемпотентности. GridInbox поддерживает заголовок Idempotency-Key. Отправляйте уникальный ключ с каждым POST-запросом. Если тот же ключ будет использован снова в течение 24 часов, API вернет исходный результат вместо создания дубликата.
# Python с ключом идемпотентности
import uuid
idempotency_key = str(uuid.uuid4())
headers["Idempotency-Key"] = idempotency_key
response = requests.post(f"{BASE_URL}/aliases", headers=headers, json=payload)
Реальная производительность: небольшая команда может управлять 10 000 алиасов с помощью менее чем 50 строк кода автоматизации.
Мы протестировали это с GridInbox. Python-скрипт, создающий 1000 алиасов с задержкой 60 мс между запросами, выполняется примерно за 60 секунд. Тот же скрипт с использованием массовых эндпоинтов (когда они доступны) завершается менее чем за 10 секунд. Получение списка всех алиасов для домена с 5000 алиасов возвращает результат менее чем за 200 миллисекунд.
GridInbox обрабатывает более 10 миллионов операций с алиасами в месяц среди своей клиентской базы, обеспечивая SLA по времени безотказной работы API на уровне 99,95%. Уровень ошибок для правильно аутентифицированных запросов составляет менее 0,1%.
Для типичной SaaS-компании с 5000 активных клиентов создание одного алиаса на клиента и управление ими в течение жизненного цикла каждой учетной записи требует менее 100 строк кода в общей сложности. Экономия времени по сравнению с ручным управлением составляет примерно 40 часов в месяц для команды из двух DevOps-инженеров.
Часто задаваемые вопросы
Что такое Email Alias API?
Email Alias API — это RESTful-интерфейс, который позволяет программно создавать, читать, обновлять и удалять email-алиасы без использования веб-панели. Он обеспечивает автоматизацию управления алиасами в ваших собственных приложениях.
Как создать email-алиас с помощью REST API?
Отправьте POST-запрос на эндпоинт алиасов с JSON-нагрузкой, содержащей локальную часть, домен и адрес пересылки. Включите ваш API-ключ в заголовок Authorization. API вернет ID алиаса и его детали.
Можно ли управлять email-алиасами программно с помощью Python?
Да. Используйте библиотеку requests для выполнения HTTP-вызовов к API алиасов. Вы можете создавать, получать список, обновлять и удалять алиасы с помощью простых вызовов функций. GridInbox предоставляет примеры кода на Python в своей документации.
Как обрабатывать лимиты запросов при массовом создании алиасов?
Добавьте небольшую задержку между запросами, обычно от 50 до 100 миллисекунд. Используйте экспоненциальную задержку для повторных попыток при получении статуса 429. GridInbox допускает 1000 запросов в минуту на один API-ключ.
В чем разница между email-алиасом и email-пересылкой?
Email-алиас — это адрес, который может как отправлять, так и получать письма от имени домена, в то время как пересылка только перенаправляет входящие письма на другой адрес. GridInbox поддерживает двунаправленные алиасы, которые могут отправлять ответы с адреса алиаса.
Безопасно ли удалять алиас через API?
Да, но только после того, как вы убедитесь, что от него не зависят активные рабочие процессы. Удаление алиаса немедленно прекращает доставку писем на этот адрес. Всегда логируйте удаления и рассмотрите возможность мягкого удаления или архивации в вашей автоматизации.
إدارة الأسماء البديلة للبريد الإلكتروني يدويًا تنجح مع عدد قليل من العناوين. لكن عندما تتوسع إلى مئات أو آلاف الأسماء البديلة عبر نطاقات وفرق متعددة، تصبح التحديثات اليدوية عائقًا. أنت بحاجة إلى واجهة برمجة تطبيقات تتيح لك إنشاء وتحديث وحذف الأسماء البديلة برمجيًا. يشرح هذا الدليل كل ما تحتاجه لبناء نظام آلي لإدارة الأسماء البديلة باستخدام REST API، مع أمثلة كود عملية بلغة Python وNode.js.
واجهة برمجة تطبيقات البريد الإلكتروني البديل تتيح لك إنشاء وتحديث وحذف الأسماء البديلة برمجيًا دون لمس لوحة التحكم.
بدلاً من تسجيل الدخول إلى واجهة ويب في كل مرة يسجل فيها عميل جديد أو يغادر أحد أعضاء الفريق، يمكنك تشغيل عمليات الأسماء البديلة من منطق تطبيقك الخاص. شركة SaaS نموذجية تستخدم GridInbox قد تنشئ من 200 إلى 500 اسم بديل أسبوعيًا لدمج عملاء جدد، ثم تحذفهم عند انتهاء الاشتراكات. هذا الحجم لا يمكن إدارته بدون أتمتة.
واجهة برمجة تطبيقات البريد الإلكتروني البديل: واجهة RESTful تتيح للتطبيقات الخارجية إنشاء وقراءة وتحديث وحذف الأسماء البديلة للبريد الإلكتروني على خادم البريد أو منصة إدارة الأسماء البديلة برمجيًا.
منصات الأسماء البديلة الحديثة مثل GridInbox تعرض نقاط نهاية لكل عملية قد تقوم بها في واجهة المستخدم. يشمل ذلك إنشاء الأسماء البديلة، وربطها بنطاقات محددة، وتعيين وجهات إعادة التوجيه، وإدارة صلاحيات الوصول للفريق.
المصادقة لواجهات برمجة تطبيقات الأسماء البديلة تستخدم مفاتيح API أو رموز OAuth تُرسل في رؤوس الطلبات.
يجب مصادقة كل استدعاء لواجهة برمجة التطبيقات. معظم المزودين، بما في ذلك GridInbox، يستخدمون مفتاح API بسيط يُمرر كرمز Bearer في رأس Authorization. لا تعرض مفتاح API الخاص بك أبدًا في كود جانب العميل أو في نظام التحكم بالإصدارات. قم بتخزينه في متغيرات البيئة أو في مدير الأسرار.
إليك مثال أساسي للمصادقة بلغة Python باستخدام مكتبة requests:
import requests
API_KEY = "your_gridinbox_api_key"
BASE_URL = "https://api.gridinbox.com/v1"
headers = {
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json"
}
في Node.js، يمكنك تحقيق نفس الشيء باستخدام axios أو fetch المدمج:
const API_KEY = process.env.GRIDINBOX_API_KEY;
const BASE_URL = "https://api.gridinbox.com/v1";
const headers = {
"Authorization": `Bearer ${API_KEY}`,
"Content-Type": "application/json"
};
استخدم HTTPS دائمًا. لا تقم أبدًا بتضمين بيانات الاعتماد في الكود. قم بتدوير المفاتيح بانتظام، على الأقل كل 90 يومًا.
إنشاء اسم بديل للبريد الإلكتروني عبر API يتطلب إرسال طلب POST مع اسم الاسم البديل والنطاق وقواعد إعادة التوجيه.
العملية الأكثر شيوعًا هي إنشاء اسم بديل جديد. تحدد الجزء المحلي (الجزء قبل @)، والنطاق، وأين يجب إعادة توجيه رسائل البريد الإلكتروني. بعض المنصات تتيح لك أيضًا تعيين اسم عرض وتمكين الإرسال ثنائي الاتجاه.
إليك دالة بلغة Python لإنشاء اسم بديل مع GridInbox:
def create_alias(local_part, domain, forward_to, display_name=None):
payload = {
"local_part": local_part,
"domain": domain,
"forward_to": forward_to,
"display_name": display_name or local_part
}
response = requests.post(
f"{BASE_URL}/aliases",
headers=headers,
json=payload
)
response.raise_for_status()
return response.json()
# مثال: إنشاء [email protected] يُعاد توجيهه إلى [email protected]
result = create_alias("support", "mycompany.com", "[email protected]")
print(result["id"]) # مثلاً: "alias_abc123"
ونفس العملية في Node.js:
async function createAlias(localPart, domain, forwardTo, displayName) {
const payload = {
local_part: localPart,
domain: domain,
forward_to: forwardTo,
display_name: displayName || localPart
};
const response = await fetch(`${BASE_URL}/aliases`, {
method: "POST",
headers: headers,
body: JSON.stringify(payload)
});
if (!response.ok) throw new Error(`HTTP ${response.status}`);
return await response.json();
}
// مثال
createAlias("billing", "mycompany.com", "[email protected]")
.then(data => console.log(data.id));
تذكر التعامل مع حدود المعدل. GridInbox تسمح بـ 1000 طلب في الدقيقة لكل مفتاح API. إذا كنت تنشئ أسماء بديلة بكميات كبيرة، قم بتجميعها مع تأخير قدره 60 مللي ثانية بين الاستدعاءات للبقاء تحت الحد.
إدارة الأسماء البديلة على نطاق واسع تعني أنك بحاجة إلى عرض وتحديث وحذفها باستخدام نقاط نهاية GET وPATCH وDELETE.
بمجرد إنشاء الأسماء البديلة، ستحتاج إلى إدارتها. تدعم واجهة برمجة التطبيقات عمليات CRUD كاملة. عرض الأسماء البديلة يتيح لك تدقيق حالتك الحالية. التحديث مفيد عندما يتغير دور أحد أعضاء الفريق ويحتاج إلى عنوان إعادة توجيه مختلف. الحذف ينظف الأسماء البديلة القديمة.
عرض جميع الأسماء البديلة لنطاق معين
# Python
response = requests.get(
f"{BASE_URL}/aliases?domain=mycompany.com",
headers=headers
)
aliases = response.json()
print(f"تم العثور على {len(aliases)} اسم بديل")
// Node.js
const response = await fetch(
`${BASE_URL}/aliases?domain=mycompany.com`,
{ headers }
);
const aliases = await response.json();
console.log(`تم العثور على ${aliases.length} اسم بديل`);
تحديث اسم بديل موجود
لتغيير وجهة إعادة التوجيه لاسم بديل، استخدم طلب PATCH:
# Python
update_payload = {
"forward_to": "[email protected]"
}
response = requests.patch(
f"{BASE_URL}/aliases/{alias_id}",
headers=headers,
json=update_payload
)
// Node.js
const updatePayload = {
forward_to: "[email protected]"
};
const response = await fetch(
`${BASE_URL}/aliases/${aliasId}`,
{
method: "PATCH",
headers: headers,
body: JSON.stringify(updatePayload)
}
);
حذف اسم بديل
عندما يغادر موظف أو ينتهي مشروع، احذف الاسم البديل لمنع ارتداد البريد الإلكتروني والمخاطر الأمنية:
# Python
response = requests.delete(
f"{BASE_URL}/aliases/{alias_id}",
headers=headers
)
if response.status_code == 204:
print("تم حذف الاسم البديل بنجاح")
// Node.js
const response = await fetch(
`${BASE_URL}/aliases/${aliasId}`,
{ method: "DELETE", headers }
);
if (response.status === 204) {
console.log("تم حذف الاسم البديل");
}
GridInbox تدعم أيضًا العمليات المجمعة. يمكنك حذف ما يصل إلى 50 اسمًا بديلًا في طلب واحد عن طريق إرسال مصفوفة من المعرفات. راجع وثائق API للحصول على نقطة النهاية الدقيقة.
دمج إدارة الأسماء البديلة في سير عمل SaaS الخاص بك يقلل من الجهد اليدوي ويمنع فشل تسليم البريد الإلكتروني.
إدارة الأسماء البديلة الآلية تتناسب بشكل طبيعي مع العديد من سير العمل الشائعة. على سبيل المثال، عندما يسجل مستخدم جديد في منتج SaaS الخاص بك، يمكنك تلقائيًا إنشاء اسم بديل مخصص مثل [email protected] وإعادة توجيهه إلى بريدهم الإلكتروني الحقيقي. عندما يلغيون اشتراكهم، تحذف الاسم البديل. هذا يحافظ على نظام البريد الإلكتروني الخاص بك نظيفًا وقابلًا للإدارة.
نمط شائع آخر هو دمج الفريق الجديد. عندما توظف مطورًا، تنشئ أسماء بديلة لكل خدمة يحتاجون الوصول إليها: [email protected]، [email protected]، [email protected]. عندما يغادرون، تحذف تلك الأسماء البديلة حتى لا يتلقى أي شخص آخر بريدهم.
GridInbox تدعم صناديق البريد المشتركة للفريق مع التحكم في الوصول القائم على الأدوار (RBAC). هذا يعني أنه يمكنك تعيين اسم بديل لفريق والسماح لعدة أشخاص بالرد من نفس العنوان. تتيح لك واجهة برمجة التطبيقات إدارة عضوية الفريق برمجيًا أيضًا.
إليك مثال أكثر تقدمًا: مزامنة الأسماء البديلة من نظام CRM. افترض أن لديك 10,000 عميل في Salesforce. تريد أن يكون لكل واحد اسم بديل فريد لإرسال الفواتير الآلية. يمكن لسكريبت أن يتكرر عبر قائمة العملاء، وينشئ أسماء بديلة، ويخزن معرفات الأسماء البديلة في قاعدة البيانات الخاصة بك. تستغرق العملية بأكملها أقل من 10 دقائق باستخدام API.
# كود زائف لمزامنة CRM
customers = get_customers_from_crm()
for customer in customers:
alias_id = create_alias(
local_part=f"invoice-{customer.id}",
domain="invoices.mycompany.com",
forward_to=customer.email
)
save_to_database(customer.id, alias_id)
هذا النهج يتوسع لأي عدد من الأسماء البديلة. GridInbox تقدم أسماء بديلة غير محدودة في خططها المدفوعة، لذلك لن تواجه أبدًا سقفًا مصطنعًا.
معالجة الأخطاء وخاصية التكرارية (Idempotency) أمران حاسمان لدمج موثوق لواجهة برمجة التطبيقات.
واجهات برمجة التطبيقات تفشل. تحدث مهلات الشبكة. يتم الوصول إلى حدود المعدل. يجب أن يتعامل تكاملك مع هذه الأمور بلطف. تحقق دائمًا من رموز حالة HTTP. رمز 409 Conflict يعني أن الاسم البديل موجود بالفعل. رمز 429 Too Many Requests يعني أنك بحاجة إلى التوقف. رمز 422 Unprocessable Entity يعني أن حمولتك تحتوي على بيانات غير صالحة.
قم بتنفيذ منطق إعادة المحاولة مع التراجع الأسي. على سبيل المثال، انتظر ثانية واحدة بعد الفشل الأول، وثانيتين بعد الثاني، و4 بعد الثالث، حتى حد أقصى قدره 60 ثانية. سجل جميع حالات الفشل لتصحيح الأخطاء.
خاصية التكرارية مهمة أيضًا. إذا تعطل السكريبت الخاص بك في منتصف إنشاء الأسماء البديلة، فلن تريد تكرارات عند إعادة تشغيله. استخدم مفاتيح التكرارية. GridInbox تدعم رأس Idempotency-Key. أرسل مفتاحًا فريدًا مع كل طلب POST. إذا تم استخدام نفس المفتاح مرة أخرى خلال 24 ساعة، تعيد API النتيجة الأصلية بدلاً من إنشاء نسخة مكررة.
# Python مع مفتاح التكرارية
import uuid
idempotency_key = str(uuid.uuid4())
headers["Idempotency-Key"] = idempotency_key
response = requests.post(f"{BASE_URL}/aliases", headers=headers, json=payload)
الأداء في العالم الحقيقي: فريق صغير يمكنه إدارة 10,000 اسم بديل بأقل من 50 سطرًا من كود الأتمتة.
اختبرنا هذا مع GridInbox. سكريبت Python ينشئ 1000 اسم بديل مع تأخير 60 مللي ثانية بين الطلبات يكتمل في حوالي 60 ثانية. نفس السكريبت باستخدام نقاط النهاية المجمعة (عند توفرها) ينتهي في أقل من 10 ثوانٍ. عرض جميع الأسماء البديلة لنطاق يحتوي على 5000 اسم بديل يعيد النتائج في أقل من 200 مللي ثانية.
GridInbox تعالج أكثر من 10 ملايين عملية اسم بديل شهريًا عبر قاعدة عملائها، مع اتفاقية مستوى خدمة (SLA) بنسبة 99.95% لواجهة برمجة التطبيقات. معدلات الخطأ أقل من 0.1% للطلبات الموثقة بشكل صحيح.
لشركة SaaS نموذجية لديها 5000 عميل نشط، إنشاء اسم بديل واحد لكل عميل وإدارته خلال دورة حياة كل حساب يتطلب أقل من 100 سطر من الكود إجمالاً. الوقت الموفر مقارنة بالإدارة اليدوية يقارب 40 ساعة شهريًا لفريق من مهندسي DevOps.
الأسئلة الشائعة
ما هي واجهة برمجة تطبيقات البريد الإلكتروني البديل؟
واجهة برمجة تطبيقات البريد الإلكتروني البديل هي واجهة RESTful تتيح لك إنشاء وقراءة وتحديث وحذف الأسماء البديلة للبريد الإلكتروني برمجيًا دون استخدام لوحة تحكم ويب. تمكن من أتمتة إدارة الأسماء البديلة في تطبيقاتك الخاصة.
كيف يمكنني إنشاء اسم بديل للبريد الإلكتروني باستخدام REST API؟
أرسل طلب POST إلى نقطة نهاية الأسماء البديلة مع حمولة JSON تحتوي على الجزء المحلي والنطاق وعنوان إعادة التوجيه. قم بتضمين مفتاح API الخاص بك في رأس Authorization. تعيد API معرف الاسم البديل وتفاصيله.
هل يمكنني إدارة الأسماء البديلة للبريد الإلكتروني برمجيًا باستخدام Python؟
نعم. استخدم مكتبة requests لإجراء استدعاءات HTTP لواجهة برمجة تطبيقات الأسماء البديلة. يمكنك إنشاء وعرض وتحديث وحذف الأسماء البديلة باستخدام استدعاءات دالة بسيطة. توفر GridInbox أمثلة كود بلغة Python في وثائقها.
كيف أتعامل مع حدود المعدل عند إنشاء أسماء بديلة بكميات كبيرة؟
أضف تأخيرًا صغيرًا بين الطلبات، عادة من 50 إلى 100 مللي ثانية. استخدم التراجع الأسي لإعادة المحاولة عند تلقي رمز الحالة 429. GridInbox تسمح بـ 1000 طلب في الدقيقة لكل مفتاح API.
ما الفرق بين الاسم البديل للبريد الإلكتروني ومعيد التوجيه؟
الاسم البديل للبريد الإلكتروني هو عنوان يمكنه إرسال واستقبال البريد الإلكتروني نيابة عن نطاق، بينما معيد التوجيه يعيد توجيه البريد الوارد فقط إلى عنوان آخر. GridInbox تدعم الأسماء البديلة ثنائية الاتجاه التي يمكنها إرسال ردود من عنوان الاسم البديل.
هل من الآمن حذف اسم بديل عبر API؟
نعم، ولكن فقط بعد التأكد من عدم وجود سير عمل نشط يعتمد عليه. حذف الاسم البديل يوقف تسليم البريد الإلكتروني إلى ذلك العنوان فورًا. قم دائمًا بتسجيل عمليات الحذف وفكر في خطوة حذف مؤقت أو أرشفة في أتمتتك.
Start Managing Email Smarter — Free 开始更智能地管理邮件——免费 Gestiona el Email de Forma Más Inteligente — Gratis Gérez Votre Email Plus Intelligemment — Gratuit より賢いメール管理を始めよう — 無料 Verwalte E-Mails Intelligenter — Kostenlos Gerencie Email de Forma Mais Inteligente — Grátis 더 스마트하게 이메일 관리 시작 — 무료 Начните управлять Email умнее — Бесплатно ابدأ إدارة البريد الإلكتروني بذكاء — مجاناً
GridInbox gives you unlimited email aliases, custom domain support, team shared inboxes, and a full REST API — all on the free plan. No credit card needed. GridInbox 提供无限邮件别名、自定义域名支持、团队共享收件箱和完整 REST API——免费版即可使用。无需信用卡。 GridInbox te ofrece aliases ilimitados, dominio personalizado, bandejas compartidas y API REST — todo en el plan gratuito. Sin tarjeta de crédito. GridInbox vous offre des alias illimités, un domaine personnalisé, des boîtes partagées et une API REST complète — tout dans le plan gratuit. GridInboxは無制限のエイリアス、カスタムドメイン、チーム共有受信箱、REST APIを無料プランで提供。クレジットカード不要。 GridInbox bietet unbegrenzte E-Mail-Aliase, Custom Domain, Team-Postfächer und REST API — alles im kostenlosen Plan. GridInbox oferece aliases ilimitados, domínio personalizado, caixas compartilhadas e API REST — tudo no plano gratuito. GridInbox는 무제한 이메일 별칭, 커스텀 도메인, 팀 공유 받은편지함, REST API를 무료 플랜으로 제공합니다. GridInbox предлагает неограниченные псевдонимы, кастомный домен, командные ящики и REST API — всё в бесплатном плане. يوفر GridInbox عناوين مستعارة غير محدودة ونطاقاً مخصصاً وصناديق مشتركة وAPI كاملة — كل ذلك في الخطة المجانية.
Get Started Free → 免费开始使用 → Comenzar Gratis → Commencer Gratuitement → 無料で始める → Kostenlos Starten → Começar Grátis → 무료로 시작하기 → Начать Бесплатно → ابدأ مجاناً →