# Enviar tu primer email con la API

> Verifica un dominio, crea una clave de API y envía tu primer email con cURL o con un SDK oficial para Node.js, Python, PHP, Ruby, Go, Java, .NET o Rust.

Este inicio rápido te lleva de una cuenta nueva a un email entregado en unos cinco minutos, más el tiempo que tarde tu proveedor de DNS en publicar los registros. Verificarás un dominio, crearás una clave de API, enviarás un email y lo encontrarás en el panel.

## Antes de empezar

- Una cuenta de Emailit. Regístrate en [dash.emailit.com](https://dash.emailit.com).
- Un dominio al que puedas añadir registros DNS, como `acme.com`. También puedes usar un subdominio, como `mail.acme.com`.

## Añadir y verificar tu dominio

Emailit solo envía desde dominios que hayas verificado, para que los servidores de correo de los destinatarios puedan comprobar que el email procede realmente de ti.

1. **Añade el dominio.** Ve a **Email API → Domains**, selecciona **Add domain**, introduce `acme.com` y selecciona **Create**.

2. **Publica los registros DNS.** La página del dominio lista los registros que debes añadir en tu proveedor de DNS. Copia los valores exactos de esa página. Los tres registros obligatorios tienen este aspecto:

   | Tipo | Nombre | Valor |
   | --- | --- | --- |
   | TXT | `emailit._domainkey.acme.com` | `v=DKIM1; t=s; h=sha256; p=…` (tu clave) |
   | TXT | `emailit.acme.com` | `v=spf1 include:_spf.emailit.com ~all` |
   | MX | `emailit.acme.com`, prioridad 10 | `feedback-smtp.ffdc-1.emailit.com` |

   Si tus DNS están en Cloudflare, puedes publicar en su lugar los registros con un clic. Consulta [Cloudflare](/es/docs/domains/cloudflare/).

3. **Comprueba los DNS.** Selecciona **Check DNS**. Cuando SPF, DKIM y Return Path muestran **OK**, el dominio está **Verified**. La mayoría de los proveedores publican los registros en minutos, pero puede tardar hasta 48 horas.

En Pay as you go, un dominio registrado hace menos de 30 días muestra **Pending verification** hasta que el equipo de Emailit lo revisa. Para los detalles y los registros opcionales de DMARC, seguimiento y email entrante, consulta [Añadir un dominio](/es/docs/domains/add-a-domain/).

## Crear una clave de API

1. **Abre API Keys.** Ve a **Email API → API Keys** y selecciona **Add API key**.

2. **Ponle nombre a la clave y elige un permiso.** Introduce un nombre como `Quickstart`. **Sending Only** solo puede enviar emails. **Full Access** también puede llamar al resto de la API. Cualquiera de las dos sirve para este inicio rápido.

3. **Copia la clave.** Selecciona **Create** y copia la clave. Empieza por `secret_` y solo se muestra una vez.

4. **Guárdala en una variable de entorno** para mantenerla fuera de tu código:

```bash
export EMAILIT_API_KEY="secret_••••"
```

## Enviar un email

Instala el SDK de tu lenguaje o usa cURL:

**cURL**

```bash
# cURL is preinstalled on macOS, Linux and Windows 10 or later
curl --version
```

**Node.js**

```bash
npm install @emailit/node
```

**Python**

```bash
pip install emailit
```

**PHP**

```bash
composer require emailit/emailit-php
```

**Laravel**

```bash
composer require emailit/emailit-laravel
# Then add EMAILIT_API_KEY=secret_•••• to your .env file
```

**Ruby**

```bash
gem install emailit
```

**Go**

```bash
go get github.com/emailit/emailit-go/v2
```

**Java**

```xml
<dependency>
  <groupId>com.emailit</groupId>
  <artifactId>emailit-java</artifactId>
  <version><!-- latest version from Maven Central --></version>
</dependency>
```

**.NET**

```bash
dotnet add package Emailit
```

**Rust**

```bash
cargo add emailit
cargo add tokio --features full
```

Después, envía un email. Usa una dirección del remitente del dominio que verificaste y envíalo a la dirección de email con la que te registraste:

**cURL**

```bash
curl https://api.emailit.com/v2/emails \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "from": "Acme <hello@acme.com>",
    "to": "ada@example.com",
    "subject": "Hello from Emailit",
    "html": "<p>This is my first email sent with Emailit.</p>"
  }'
```

**Node.js**

```javascript
import { Emailit } from '@emailit/node';

const emailit = new Emailit(process.env.EMAILIT_API_KEY);

const email = await emailit.emails.send({
  from: 'Acme <hello@acme.com>',
  to: 'ada@example.com',
  subject: 'Hello from Emailit',
  html: '<p>This is my first email sent with Emailit.</p>',
});

console.log(email.id, email.status);
```

**Python**

```python
import os
from emailit import EmailitClient

client = EmailitClient(os.environ["EMAILIT_API_KEY"])

email = client.emails.send({
    "from": "Acme <hello@acme.com>",
    "to": "ada@example.com",
    "subject": "Hello from Emailit",
    "html": "<p>This is my first email sent with Emailit.</p>",
})

print(email.id, email.status)
```

**PHP**

```php
<?php
require 'vendor/autoload.php';

$emailit = Emailit::client(getenv('EMAILIT_API_KEY'));

$email = $emailit->emails()->send([
    'from' => 'Acme <hello@acme.com>',
    'to' => 'ada@example.com',
    'subject' => 'Hello from Emailit',
    'html' => '<p>This is my first email sent with Emailit.</p>',
]);

echo $email->id . ' ' . $email->status;
```

**Laravel**

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

$email = Emailit::emails()->send([
    'from' => 'Acme <hello@acme.com>',
    'to' => 'ada@example.com',
    'subject' => 'Hello from Emailit',
    'html' => '<p>This is my first email sent with Emailit.</p>',
]);

logger()->info('Sent email', ['id' => $email->id]);
```

**Ruby**

```ruby
require "emailit"

client = Emailit::EmailitClient.new(ENV["EMAILIT_API_KEY"])

email = client.emails.send(
  from: "Acme <hello@acme.com>",
  to: "ada@example.com",
  subject: "Hello from Emailit",
  html: "<p>This is my first email sent with Emailit.</p>"
)

puts email.id, email.status
```

**Go**

```go
package main

import (
    "fmt"
    "os"

    "github.com/emailit/emailit-go/v2"
)

func main() {
    client := emailit.NewClient(os.Getenv("EMAILIT_API_KEY"))

    email, err := client.Emails.Send(&emailit.SendEmailRequest{
        From:    "Acme <hello@acme.com>",
        To:      []string{"ada@example.com"},
        Subject: "Hello from Emailit",
        Html:    "<p>This is my first email sent with Emailit.</p>",
    })
    if err != nil {
        panic(err)
    }

    fmt.Println(email.Id)
}
```

**Java**

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

public class SendEmail {
    public static void main(String[] args) throws Exception {
        EmailitClient emailit = new EmailitClient(System.getenv("EMAILIT_API_KEY"));

        EmailitObject email = emailit.emails().send(
            EmailSendParams.builder()
                .setFrom("Acme <hello@acme.com>")
                .setTo(List.of("ada@example.com"))
                .setSubject("Hello from Emailit")
                .setHtml("<p>This is my first email sent with Emailit.</p>")
                .build()
        );

        System.out.println(email.getString("id"));
    }
}
```

**.NET**

```csharp
using Emailit;
using Emailit.Options;
using Emailit.Resources;

var emailit = new EmailitClient(Environment.GetEnvironmentVariable("EMAILIT_API_KEY"));

Email email = emailit.Emails.Send(new EmailSendOptions
{
    From = "Acme <hello@acme.com>",
    To = new[] { "ada@example.com" },
    Subject = "Hello from Emailit",
    Html = "<p>This is my first email sent with Emailit.</p>",
});

Console.WriteLine($"{email.Id} {email.Status}");
```

**Rust**

```rust
use emailit::types::CreateEmailBaseOptions;
use emailit::{Emailit, Result};

#[tokio::main]
async fn main() -> Result<()> {
    let api_key = std::env::var("EMAILIT_API_KEY").expect("EMAILIT_API_KEY is not set");
    let emailit = Emailit::new(&api_key);

    let email = CreateEmailBaseOptions::new(
        "Acme <hello@acme.com>",
        ["ada@example.com"],
        "Hello from Emailit",
    )
    .with_html("<p>This is my first email sent with Emailit.</p>");

    let result = emailit.emails.send(email).await?;
    println!("{:?}", result.id);

    Ok(())
}
```

> **Modo sandbox:** Hasta que tu espacio de trabajo tenga acceso de producción, solo puedes enviar a las direcciones de email de las cuentas de los miembros del espacio de trabajo. Si envías a cualquier otra persona, recibes `403` con el código `unverified_workspace_recipient`. Cuando quieras enviar a destinatarios reales, [solicita acceso de producción](/es/docs/workspaces/production-access/).

## Leer la respuesta

Una petición correcta devuelve `200` con el email nuevo:

```json
{
  "object": "email",
  "id": "em_2pX7cN4kQ9vLm3RtB8yWd1Zs",
  "token": "2pX7cN4m8FqT1vKz6RbL3HwYd",
  "message_id": "<2pX7cN4m8FqT1vKz6RbL3HwYd@acme.com>",
  "from": "Acme <hello@acme.com>",
  "to": ["ada@example.com"],
  "subject": "Hello from Emailit",
  "status": "accepted",
  "scheduled_at": null,
  "created_at": "2026-10-01T09:30:12.418Z",
  "tracking": { "loads": false, "clicks": false }
}
```

| Campo | Significado |
| --- | --- |
| `id` | El ID del email. Úsalo para consultar el email, cancelarlo o reintentarlo, y para relacionarlo con los eventos de webhook. |
| `status` | `accepted` significa que Emailit ha puesto el email en cola para su entrega. Es `scheduled` si defines `scheduled_at`. |
| `message_id` | La cabecera `Message-ID` del email. |
| `ids` | Solo aparece con varios destinatarios. Asocia cada dirección de destinatario con su propio ID de email. |
| `tracking` | Si se hace seguimiento de las aperturas (`loads`) y de los clics de este email. El seguimiento requiere un [subdominio de seguimiento](/es/docs/tracking/) verificado. |

`accepted` no significa que ya se haya entregado. La entrega se produce en segundo plano y el estado cambia a medida que avanza.

## Comprobarlo en el panel

Ve a **Email API → Emails**. Tu email aparece arriba del todo en la pestaña **Outgoing**. En unos segundos, su estado suele cambiar de **accepted** a **delivered**. Ábrelo para ver las cabeceras, el contenido, cada intento de entrega con la respuesta del servidor receptor y los resultados de las comprobaciones de spam.

La petición aparece en **Email API → Logs**, con el código de estado y los cuerpos de la petición y de la respuesta.

## Solución de problemas

| Respuesta | Causa | Solución |
| --- | --- | --- |
| `401` `API key required` o `Invalid API key` | Falta la cabecera `Authorization` o la clave es incorrecta | Envía `Authorization: Bearer secret_…` con una clave vigente |
| `403` `unverified_workspace_recipient` | El espacio de trabajo está en modo sandbox | Envía a la dirección de email de la cuenta de un miembro del espacio de trabajo o [solicita acceso de producción](/es/docs/kb/403-unverified-workspace-recipient/) |
| `422` `From/Sender domain is not valid or not verified` | El dominio del remitente no está verificado en este espacio de trabajo | Verifica el dominio o usa una dirección de un dominio verificado |
| `403` `Domain not authorized` | La clave Sending Only está limitada a otro dominio | Usa una clave para este dominio o una clave sin limitación de dominio |
| `402` `Insufficient credits` | El espacio de trabajo no tiene créditos suficientes | [Añade créditos](/es/docs/kb/402-insufficient-credits/) |
| `429` `Rate limit exceeded` | Demasiados emails en este segundo o en el día de hoy | Espera el tiempo indicado en `retry-after`. Consulta [Límites de velocidad](/es/docs/kb/429-rate-limit-exceeded/). |

## Próximos pasos

  - [Configurar webhooks](/es/docs/webhooks/set-up/): Recibe en tiempo real los eventos de entrega, rebote y apertura.
  - [Enviar con una plantilla](/es/docs/templates/): Diséñala una vez en el panel y envíala por su alias con variables.
  - [Idempotencia](/es/docs/email-api/idempotency/): Reintenta las peticiones de forma segura sin enviar dos veces.
  - [Lista de comprobación para el lanzamiento](/es/docs/get-started/go-live/): Qué comprobar antes de enviar a destinatarios reales.

---
Fuente: https://emailit.com/es/docs/quickstart/api/