# SDK e librerie

> Le librerie ufficiali di Emailit per Node.js, PHP, Laravel, Python, Ruby, Go, Java, .NET e Rust, più il pacchetto MCP e come chiamare l’API in semplice HTTP.

Emailit mantiene librerie client open source per nove linguaggi e framework. Ognuna incapsula l’API REST con errori tipizzati e gli stessi nomi delle risorse che vedi nel [riferimento API](/it/docs/api-reference/). Se il tuo linguaggio non è nell’elenco, va bene qualsiasi client HTTP.

## Librerie ufficiali

Tutte le librerie hanno licenza MIT e sono pubblicate su [github.com/emailit](https://github.com/emailit).

| Linguaggio | Pacchetto | Installazione | Requisiti | Sorgente |
| --- | --- | --- | --- | --- |
| 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, vedi sotto | 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+ e Tokio | [emailit-rust](https://github.com/emailit/emailit-rust) |

Per Java, aggiungi la dipendenza con l’ultima versione indicata nel repository:

```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'
```

## Invia un’email

Ogni libreria riceve la chiave API quando crei il client. Caricala da una variabile d’ambiente invece di scriverla nel codice.

**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>"
  }'
```

L’indirizzo `from` deve appartenere a un [dominio di invio verificato](/it/docs/domains/add-a-domain/). Finché il workspace non ha l’[accesso alla produzione](/it/docs/workspaces/production-access/), puoi inviare solo agli indirizzi email degli account dei membri del workspace.

## Cosa coprono le librerie

Ogni libreria espone gli stessi servizi: email, domini, chiavi API, liste, iscritti, template, soppressioni, verifiche email, liste di verifica email, webhook, contatti ed eventi. Gli errori vengono sollevati come eccezioni tipizzate o valori di errore, ad esempio un errore di autenticazione per `401`, un errore di limite di frequenza per `429` e un errore di convalida per `422`, così puoi gestire ogni caso separatamente.

Alcuni endpoint più recenti non sono ancora inclusi, tra cui l’inoltro di un’email, le campagne, le automazioni, i moduli e i report DMARC. Inoltre le librerie non impostano l’header `Idempotency-Key`. In questi casi, chiama l’endpoint in HTTP con la stessa chiave API, come mostrato più avanti.

Per la configurazione specifica di ogni framework, compresi trasporti di posta, rotte dei webhook e configurazione SMTP, vedi le guide per framework: [Node.js](/it/docs/frameworks/nodejs/), [Next.js](/it/docs/frameworks/nextjs/), [Nuxt](/it/docs/frameworks/nuxt/), [Laravel](/it/docs/frameworks/laravel/), [PHP](/it/docs/frameworks/php/), [Python](/it/docs/frameworks/python/), [Ruby on Rails](/it/docs/frameworks/rails/), [Go](/it/docs/frameworks/go/), [Java](/it/docs/frameworks/java/), [.NET](/it/docs/frameworks/dotnet/) e [WordPress](/it/docs/frameworks/wordpress/).

## Pacchetto del server MCP

Il pacchetto open source [`@emailit/emailit-mcp`](https://github.com/emailit/emailit-mcp) esegue un server MCP sulla tua macchina, così gli assistenti AI possono chiamare Emailit con la tua chiave API:

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

Alla maggior parte delle persone non serve: il server ospitato su `https://api.emailit.com/mcp` non richiede installazione. Confronta le due opzioni in [Esegui il server MCP in locale](/it/docs/mcp/local-server/).

`@emailit/js` è un pacchetto diverso: è lo script per browser che mostra i [moduli di Emailit](/it/docs/forms/install/) sul tuo sito, non un client API.

## Usa l’API in HTTP

Non ti serve una libreria. Va bene qualsiasi client HTTP in grado di inviare JSON:

- URL di base: `https://api.emailit.com/v2`
- Header: `Authorization: Bearer <your API key>` e `Content-Type: application/json`
- Corpi e risposte: JSON

Ad esempio, per inoltrare un’email con una chiave di idempotenza da Node.js senza l’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()}`);
}
```

Prima di sviluppare un tuo client, leggi [Errori](/it/docs/api-reference/errors/) e [Limiti di frequenza](/it/docs/api-reference/rate-limits/), così gestirai correttamente le risposte `4xx` e `retry-after`. Se la tua app usa già l’SMTP, puoi anche fare a meno dell’API e usare l’[SMTP relay](/it/docs/smtp/settings/).

## Librerie della community

Emailit non mantiene librerie al di fuori dell’elenco qui sopra. Se ne trovi o ne sviluppi una per un altro linguaggio o framework, esaminane il codice prima di darle una chiave API, e preferisci una chiave Sending Only limitata a un dominio. Scrivici a support@emailit.com o su [Discord](https://discord.emailit.com) se vuoi che venga citata qui.

## Vedi anche

  - [Panoramica per sviluppatori](/it/docs/developers/): URL di base, ID, errori, paginazione e limiti di frequenza.
  - [Chiavi API](/it/docs/developers/api-keys/): Crea la chiave che serve alla tua libreria.
  - [Invia un’email](/it/docs/email-api/send-email/): Template, allegati, programmazione e tracciamento.
  - [Firme dei webhook](/it/docs/webhooks/request-signature/): Verifica che le richieste webhook provengano da Emailit.

---
Fonte: https://emailit.com/it/docs/sdks/