# Envío de emails con Laravel

> Aprende a enviar emails en Laravel con el paquete Emailit Laravel. Se integra como transporte de correo nativo y te da acceso completo a la API de Emailit mediante una Facade.

2026-03-04 · George (https://x.com/thegeorge, https://www.linkedin.com/in/jiri-zizka/)

Laravel incluye de serie un excelente soporte para el envío de correo, pero aun así necesitas un servicio de entrega fiable detrás. El paquete **Emailit Laravel** se conecta directamente al sistema de correo de Laravel como transporte nativo. Tus Mailables, Notifications y llamadas a `Mail::send()` actuales funcionan sin cambiar ni una línea de código. Además, obtienes acceso completo a la API de Emailit a través de una práctica Facade.

El envío de emails es una de las tareas más habituales en cualquier aplicación Laravel. Las confirmaciones de registro, los restablecimientos de contraseña, los recibos de pedidos, los avisos de envío y las newsletters de marketing dependen de una entrega de email fiable. Aunque Laravel ofrece una potente capa de abstracción para el correo, la entrega en sí sigue dependiendo del transporte que configures. Usar una API de email como Emailit te ofrece una alta entregabilidad, seguimiento de entregas, gestión de rebotes y analíticas detalladas, sin tener que administrar servidores SMTP ni preocuparte por la reputación de tus IP.

En esta guía veremos cómo configurar Emailit en una aplicación Laravel y enviar emails tanto con el sistema de correo estándar de Laravel como con la Facade de Emailit.

## Requisitos

- PHP 8.1 o superior
- Laravel 10, 11 o 12
- Una [cuenta de Emailit](https://app.emailit.com/register) con una clave de API

## Instalación

Instala el paquete con Composer:

```bash
composer require emailit/emailit-laravel
```

El paquete descubre automáticamente su proveedor de servicios, así que no tienes que registrarlo a mano. Funciona con Laravel 10, 11 y 12 sin configuración adicional.

## Configuración

Añade tu clave de API a `.env`:

```
EMAILIT_API_KEY=tu_clave_api
```

Establece Emailit como tu mailer predeterminado:

```
MAIL_MAILER=emailit
```

Añade el mailer `emailit` al array de mailers de tu `config/mail.php`:

```php
'mailers' => [
    // ...

    'emailit' => [
        'transport' => 'emailit',
    ],
],
```

Si quieres, publica el archivo de configuración para personalizar la URL base de la API:

```bash
php artisan vendor:publish --tag=emailit-config
```

La configuración es deliberadamente mínima. En cuanto definas tu clave de API y el mailer predeterminado, Laravel enviará automáticamente todo el correo saliente a través de Emailit. No necesitas configurar hosts SMTP, puertos, cifrado ni credenciales de autenticación, como harías con un servidor de correo tradicional.

## Enviar emails con Laravel Mail

Una vez configurado, todas las funciones de correo de Laravel están listas para usar. No tienes que cambiar nada de tu código actual.

### Usar un Mailable

Crea una clase Mailable como lo harías normalmente:

```php
namespace App\Mail;

use Illuminate\Bus\Queueable;
use Illuminate\Mail\Mailable;
use Illuminate\Mail\Mailables\Content;
use Illuminate\Mail\Mailables\Envelope;
use Illuminate\Queue\SerializesModels;

class WelcomeEmail extends Mailable
{
    use Queueable, SerializesModels;

    public function __construct(
        public readonly User $user,
    ) {}

    public function envelope(): Envelope
    {
        return new Envelope(
            subject: 'Bienvenido a Nuestra App',
        );
    }

    public function content(): Content
    {
        return new Content(
            view: 'emails.welcome',
        );
    }
}
```

Después, envíalo:

```php
use Illuminate\Support\Facades\Mail;
use App\Mail\WelcomeEmail;

Mail::to('usuario@ejemplo.com')->send(new WelcomeEmail($user));
```

Los emails en cola, los Mailables en Markdown y las Notifications funcionan exactamente como esperas. Emailit actúa de forma transparente detrás de la capa de correo de Laravel, así que puedes usarlo en lugar de cualquier transporte que ya tengas, como SMTP, Mailgun o SES, sin tocar el código de tu aplicación. Esto facilita probar Emailit junto a tu proveedor actual o migrar poco a poco.

## Usar la Facade de Emailit

Para funciones que van más allá de lo que ofrece el sistema de correo de Laravel, como plantillas con variables, envíos programados o la gestión de recursos de la API, usa la Facade `Emailit`. Te da acceso directo a todo el [SDK de Emailit para PHP](https://github.com/emailit/emailit-php).

### Enviar un email a través de la API

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

$email = Emailit::emails()->send([
    'from'    => 'hola@tudominio.com',
    'to'      => ['usuario@ejemplo.com'],
    'subject' => 'Hola desde Emailit',
    'html'    => '<h1>¡Bienvenido!</h1>',
]);

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

### Enviar con una plantilla

Haz referencia a las plantillas que has creado en el panel de Emailit y pásales variables dinámicas:

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

$email = Emailit::emails()->send([
    'from'      => 'hola@tudominio.com',
    'to'        => 'usuario@ejemplo.com',
    'template'  => 'email_bienvenida',
    'variables' => [
        'name'    => 'Juan Pérez',
        'company' => 'Acme Inc',
    ],
]);
```

Usar plantillas en el servidor es un patrón muy potente para aplicaciones Laravel. Tus diseñadores y tu equipo de marketing pueden actualizar el contenido, el estilo y la maquetación de los emails en el panel de Emailit sin cambios de código ni nuevos despliegues. El código PHP solo tiene que pasar los datos y la plantilla se encarga del renderizado.

### Programar un email

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

$email = Emailit::emails()->send([
    'from'         => 'recordatorios@tudominio.com',
    'to'           => 'usuario@ejemplo.com',
    'subject'      => 'Recordatorio de Cita',
    'html'         => '<p>Tu cita es mañana a las 2 PM.</p>',
    'scheduled_at' => '2026-04-10T09:00:00Z',
]);
```

De los emails programados se encarga íntegramente la API de Emailit, lo que significa que funcionan con independencia del sistema de colas de Laravel. Es ideal para recordatorios de citas, avisos de renovación de suscripciones y campañas en las que la puntualidad es clave y necesitas garantizar la entrega a una hora concreta, aunque tu servidor de aplicaciones sufra una caída.

### Enviar con archivos adjuntos

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

$email = Emailit::emails()->send([
    'from'        => 'facturas@tudominio.com',
    'to'          => 'cliente@ejemplo.com',
    'subject'     => 'Tu Factura #12345',
    'html'        => '<p>Por favor encuentra tu factura adjunta.</p>',
    'attachments' => [
        [
            'filename'     => 'factura.pdf',
            'content'      => base64_encode(file_get_contents('factura.pdf')),
            'content_type' => 'application/pdf',
        ],
    ],
]);
```

## Gestión de recursos

La Facade expone todos los servicios de la API de Emailit, así que puedes gestionar toda tu infraestructura de email desde Laravel.

### Dominios

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

$domain = Emailit::domains()->create([
    'name' => 'ejemplo.com',
    'track_loads' => true,
    'track_clicks' => true,
]);

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

Gestionar los dominios de envío a través de la API es útil para plataformas SaaS que necesitan configurar dominios personalizados para cada cliente. Puedes automatizar todo el flujo de verificación de dominios, incluidas las comprobaciones de los registros DNS, directamente desde tu aplicación Laravel.

### Contactos

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

$contact = Emailit::contacts()->create([
    'email' => 'usuario@ejemplo.com',
    'first_name' => 'Juan',
    'last_name' => 'Pérez',
]);

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

### Verificación de emails

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

$result = Emailit::emailVerifications()->verify([
    'email' => 'test@ejemplo.com',
]);

echo $result->status; // valid
echo $result->risk;   // low
```

Verificar las direcciones de email en el momento del registro o al enviar un formulario te ayuda a mantener limpia tu lista de contactos y protege tu reputación de remitente. Las tasas de rebote altas por direcciones no válidas pueden hacer que tus emails acaben en la carpeta de spam, así que la verificación es una buena práctica para cualquier aplicación Laravel que envíe emails transaccionales o de marketing a gran escala.

## Inyección de dependencias

Si prefieres no usar Facades, puedes inyectar el cliente directamente:

```php
use Emailit\EmailitClient;

class EmailController extends Controller
{
    public function send(EmailitClient $emailit)
    {
        $email = $emailit->emails()->send([
            'from'    => 'hola@tudominio.com',
            'to'      => ['usuario@ejemplo.com'],
            'subject' => 'Hola',
            'html'    => '<p>¡Hola!</p>',
        ]);

        return response()->json(['id' => $email->id]);
    }
}
```

El contenedor de servicios de Laravel resuelve automáticamente la instancia de `EmailitClient` con la clave de API de tu configuración, así que tienes la misma comodidad que con la Facade y, además, la facilidad para escribir tests que aporta la inyección de dependencias.

## Gestión de errores

El SDK de PHP subyacente lanza excepciones tipadas, así que puedes capturar tipos de error concretos:

```php
use Emailit\Exceptions\AuthenticationException;
use Emailit\Exceptions\RateLimitException;
use Emailit\Exceptions\ApiErrorException;
use Emailit\Laravel\Facades\Emailit;

try {
    Emailit::emails()->send([...]);
} catch (AuthenticationException $e) {
    // Clave API inválida (401)
} catch (RateLimitException $e) {
    // Demasiadas solicitudes (429)
} catch (ApiErrorException $e) {
    // Cualquier otro error de API
    echo $e->getHttpStatus();
}
```

En una aplicación Laravel también puedes gestionar estas excepciones de forma global en tu manejador de excepciones o usar un middleware que capture los errores de límite de peticiones y aplique reintentos automáticos. Así tu aplicación sigue siendo resiliente incluso cuando envía grandes volúmenes de email.

## Todos los servicios disponibles

La Facade te da acceso a todo lo que ofrece la API de Emailit:

| Servicio | Uso | Descripción |
| --- | --- | --- |
| Emails | `Emailit::emails()` | Enviar, listar, obtener, cancelar y reintentar emails |
| Dominios | `Emailit::domains()` | Crear, verificar, listar y gestionar dominios de envío |
| Claves de API | `Emailit::apiKeys()` | Crear, listar y gestionar claves de API |
| Listas | `Emailit::audiences()` | Crear, listar y gestionar listas de contactos |
| Suscriptores | `Emailit::subscribers()` | Añadir, listar y gestionar suscriptores |
| Plantillas | `Emailit::templates()` | Crear, listar y publicar plantillas de email |
| Direcciones bloqueadas | `Emailit::suppressions()` | Crear, listar y gestionar direcciones bloqueadas |
| Verificación de emails | `Emailit::emailVerifications()` | Verificar direcciones de email |
| Listas de verificación | `Emailit::emailVerificationLists()` | Verificación masiva de emails |
| Webhooks | `Emailit::webhooks()` | Crear, listar y gestionar webhooks |
| Contactos | `Emailit::contacts()` | Crear, listar y gestionar contactos |
| Eventos | `Emailit::events()` | Listar y consultar eventos |

## Empieza ya

Instala el paquete y empieza a enviar en menos de un minuto:

```bash
composer require emailit/emailit-laravel
```

Consulta la documentación completa del paquete en [GitHub](https://github.com/emailit/emailit-laravel) y el [SDK de Emailit para PHP](https://github.com/emailit/emailit-php), que es el cliente subyacente, o ve a la [referencia de la API](https://emailit.com/docs/api-reference/endpoints) para ver los detalles de cada endpoint.

---

Source: https://emailit.com/es/blog/envio-de-correos-con-laravel/