# SDK y bibliotecas

> Las bibliotecas oficiales de Emailit para Node.js, PHP, Laravel, Python, Ruby, Go, Java, .NET y Rust, el paquete MCP y cómo llamar a la API directamente por HTTP.

Emailit mantiene bibliotecas cliente de código abierto para nueve lenguajes y frameworks. Cada una envuelve la API REST con errores tipados y los mismos nombres de recursos que ves en la [referencia de la API](/es/docs/api-reference/). Si tu lenguaje no aparece en la lista, sirve cualquier cliente HTTP.

## Bibliotecas oficiales

Todas las bibliotecas tienen licencia MIT y se publican desde [github.com/emailit](https://github.com/emailit).

| Lenguaje | Paquete | Instalación | Requisitos | Código fuente |
| --- | --- | --- | --- | --- |
| Node.js | `@emailit/node` | `npm install @emailit/node` | Node.js 18+ | [emailit-node](https://github.com/emailit/emailit-node) |
| PHP | `emailit/emailit-php` | `composer require emailit/emailit-php` | PHP 8.1+ | [emailit-php](https://github.com/emailit/emailit-php) |
| Laravel | `emailit/emailit-laravel` | `composer require emailit/emailit-laravel` | Laravel 10, 11 o 12 | [emailit-laravel](https://github.com/emailit/emailit-laravel) |
| Python | `emailit` | `pip install emailit` | Python 3.7+ | [emailit-python](https://github.com/emailit/emailit-python) |
| Ruby | `emailit` | `bundle add emailit` | Ruby 3.0+ | [emailit-ruby](https://github.com/emailit/emailit-ruby) |
| Go | `github.com/emailit/emailit-go/v2` | `go get github.com/emailit/emailit-go/v2` | Go 1.21+ | [emailit-go](https://github.com/emailit/emailit-go) |
| Java | `com.emailit:emailit-java` | Maven o Gradle, consulta más abajo | Java 11+ | [emailit-java](https://github.com/emailit/emailit-java) |
| .NET | `Emailit` | `dotnet add package Emailit` | .NET 8+ | [emailit-dotnet](https://github.com/emailit/emailit-dotnet) |
| Rust | `emailit` | `cargo add emailit` | Rust 1.85+ y Tokio | [emailit-rust](https://github.com/emailit/emailit-rust) |

Para Java, añade la dependencia con la última versión que aparece en el repositorio:

```xml title="pom.xml"
<dependency>
  <groupId>com.emailit</groupId>
  <artifactId>emailit-java</artifactId>
  <version>VERSION</version>
</dependency>
```

```groovy title="build.gradle"
implementation 'com.emailit:emailit-java:VERSION'
```

## Enviar un email

Todas las bibliotecas reciben tu clave de API al crear el cliente. Cárgala desde una variable de entorno en lugar de escribirla en el código.

**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: 'Welcome to Acme',
  html: '<p>Thanks for signing up.</p>',
});

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

**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' => 'Welcome to Acme',
    'html'    => '<p>Thanks for signing up.</p>',
]);

echo $email->id;
```

**Laravel**

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

$email = Emailit::emails()->send([
    'from'    => 'Acme <hello@acme.com>',
    'to'      => 'ada@example.com',
    'subject' => 'Welcome to Acme',
    'html'    => '<p>Thanks for signing up.</p>',
]);
```

**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": "Welcome to Acme",
    "html": "<p>Thanks for signing up.</p>",
})

print(email.id)
```

**Ruby**

```ruby
require "emailit"

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

email = client.emails.send(
  from: "Acme <hello@acme.com>",
  to: "ada@example.com",
  subject: "Welcome to Acme",
  html: "<p>Thanks for signing up.</p>"
)

puts email.id
```

**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: "Welcome to Acme",
        Html:    "<p>Thanks for signing up.</p>",
    })
    if err != nil {
        panic(err)
    }

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

**Java**

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

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("Welcome to Acme")
        .setHtml("<p>Thanks for signing up.</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 = "Welcome to Acme",
    Html = "<p>Thanks for signing up.</p>",
});

Console.WriteLine(email.Id);
```

**Rust**

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

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

    let options = CreateEmailBaseOptions::new(
        "Acme <hello@acme.com>",
        ["ada@example.com"],
        "Welcome to Acme",
    )
    .with_html("<p>Thanks for signing up.</p>");

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

    Ok(())
}
```

**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": "Welcome to Acme",
    "html": "<p>Thanks for signing up.</p>"
  }'
```

El `from` debe pertenecer a un [dominio de envío verificado](/es/docs/domains/add-a-domain/). Hasta que tu espacio de trabajo tenga [acceso de producción](/es/docs/workspaces/production-access/), solo puedes enviar a las direcciones de email de las cuentas de los miembros del espacio de trabajo.

## Qué cubren las bibliotecas

Todas las bibliotecas exponen los mismos servicios: emails, dominios, claves de API, listas de contactos, suscriptores, plantillas, direcciones bloqueadas, verificaciones de emails, listas de verificación de emails, webhooks, contactos y eventos. Los errores se lanzan como excepciones tipadas o valores de error, por ejemplo un error de autenticación para `401`, un error de límite de velocidad para `429` y un error de validación para `422`, para que puedas gestionar cada caso por separado.

Algunos endpoints más recientes todavía no están incluidos, como el reenvío de un email, las campañas, las automatizaciones, los formularios y los informes DMARC. Las bibliotecas tampoco envían la cabecera `Idempotency-Key`. Para esos casos, llama al endpoint por HTTP con la misma clave de API, como se muestra más abajo.

Para la configuración específica de cada framework, incluidos los transportes de correo, las rutas de webhooks y la configuración SMTP, consulta las guías de frameworks: [Node.js](/es/docs/frameworks/nodejs/), [Next.js](/es/docs/frameworks/nextjs/), [Nuxt](/es/docs/frameworks/nuxt/), [Laravel](/es/docs/frameworks/laravel/), [PHP](/es/docs/frameworks/php/), [Python](/es/docs/frameworks/python/), [Ruby on Rails](/es/docs/frameworks/rails/), [Go](/es/docs/frameworks/go/), [Java](/es/docs/frameworks/java/), [.NET](/es/docs/frameworks/dotnet/) y [WordPress](/es/docs/frameworks/wordpress/).

## Paquete del servidor MCP

El paquete de código abierto [`@emailit/emailit-mcp`](https://github.com/emailit/emailit-mcp) ejecuta un servidor MCP en tu equipo para que los asistentes de IA puedan llamar a Emailit con tu clave de API:

```bash
npx -y @emailit/emailit-mcp
```

La mayoría no lo necesita: el servidor alojado en `https://api.emailit.com/mcp` no requiere instalación. Compara los dos en [Ejecutar el servidor MCP en local](/es/docs/mcp/local-server/).

`@emailit/js` es un paquete distinto: es el script del navegador que muestra los [formularios de Emailit](/es/docs/forms/install/) en tu web, no un cliente de la API.

## Usar la API por HTTP

No necesitas una biblioteca. Sirve cualquier cliente HTTP que pueda enviar JSON:

- URL base: `https://api.emailit.com/v2`
- Cabeceras: `Authorization: Bearer <your API key>` y `Content-Type: application/json`
- Cuerpos y respuestas: JSON

Por ejemplo, para reenviar un email con una clave de idempotencia desde Node.js sin el SDK:

```javascript
const response = await fetch('https://api.emailit.com/v2/emails/em_4K6oASS7KP9ztzWmSN9ndEu13HW/forward', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.EMAILIT_API_KEY}`,
    'Content-Type': 'application/json',
    'Idempotency-Key': 'forward-order-1042',
  },
  body: JSON.stringify({ to: 'support@acme.com' }),
});

if (!response.ok) {
  throw new Error(`Emailit returned ${response.status}: ${await response.text()}`);
}
```

Lee [Errores](/es/docs/api-reference/errors/) y [Límites de velocidad](/es/docs/api-reference/rate-limits/) antes de crear tu propio cliente, para gestionar correctamente las respuestas `4xx` y `retry-after`. Si tu aplicación ya usa SMTP, también puedes prescindir de la API y usar el [SMTP relay](/es/docs/smtp/settings/).

## Bibliotecas de la comunidad

Emailit no mantiene bibliotecas aparte de las de la lista anterior. Si encuentras o creas una para otro lenguaje o framework, revisa su código antes de darle una clave de API, y usa preferiblemente una clave Sending Only limitada a un dominio. Avísanos en support@emailit.com o en [Discord](https://discord.emailit.com) si quieres que la mencionemos aquí.

## Ver también

  - [Descripción general para desarrolladores](/es/docs/developers/): URL base, ID, errores, paginación y límites de velocidad.
  - [Claves de API](/es/docs/developers/api-keys/): Crea la clave que necesita tu biblioteca.
  - [Enviar emails con la API](/es/docs/email-api/send-email/): Plantillas, adjuntos, programación y seguimiento.
  - [Firmas de los webhooks](/es/docs/webhooks/request-signature/): Verifica que las peticiones de webhook proceden de Emailit.

---
Fuente: https://emailit.com/es/docs/sdks/