# SDKs e bibliotecas

> Bibliotecas oficiais do Emailit para Node.js, PHP, Laravel, Python, Ruby, Go, Java, .NET e Rust, além do pacote MCP e de como chamar a API por HTTP simples.

O Emailit mantém bibliotecas cliente de código aberto para nove linguagens e frameworks. Cada uma encapsula a API REST com erros tipados e os mesmos nomes de recursos que você vê na [referência da API](/pt/docs/api-reference/). Se a sua linguagem não estiver na lista, qualquer cliente HTTP funciona.

## Bibliotecas oficiais

Todas as bibliotecas têm licença MIT e são publicadas em [github.com/emailit](https://github.com/emailit).

| Linguagem | Pacote | Instalação | Requisitos | Código-fonte |
| --- | --- | --- | --- | --- |
| 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 ou 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 ou Gradle, veja abaixo | 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) |

Para Java, adicione a dependência com a versão mais recente indicada no repositório:

```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 um e-mail

Todas as bibliotecas recebem a sua chave de API quando você cria o cliente. Carregue-a de uma variável de ambiente em vez de deixá-la fixa no 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>"
  }'
```

O endereço `from` precisa estar em um [domínio de envio verificado](/pt/docs/domains/add-a-domain/). Até o seu workspace ter [acesso de produção](/pt/docs/workspaces/production-access/), você só pode enviar para os e-mails das contas dos membros do workspace.

## O que as bibliotecas cobrem

Todas as bibliotecas expõem os mesmos serviços: e-mails, domínios, chaves de API, listas de contatos, inscritos, templates, supressões, verificações de e-mail, listas de verificação de e-mails, webhooks, contatos e eventos. Os erros são lançados como exceções ou valores de erro tipados, por exemplo um erro de autenticação para `401`, um erro de limite de requisições para `429` e um erro de validação para `422`, para que você possa tratar cada caso separadamente.

Alguns endpoints mais novos ainda não estão encapsulados, como o encaminhamento de e-mails, campanhas, automações, formulários e relatórios DMARC. As bibliotecas também não definem o cabeçalho `Idempotency-Key`. Nesses casos, chame o endpoint por HTTP com a mesma chave de API, como mostrado abaixo.

Para a configuração específica de cada framework, incluindo transportes de e-mail, rotas de webhook e configuração de SMTP, consulte os guias de frameworks: [Node.js](/pt/docs/frameworks/nodejs/), [Next.js](/pt/docs/frameworks/nextjs/), [Nuxt](/pt/docs/frameworks/nuxt/), [Laravel](/pt/docs/frameworks/laravel/), [PHP](/pt/docs/frameworks/php/), [Python](/pt/docs/frameworks/python/), [Ruby on Rails](/pt/docs/frameworks/rails/), [Go](/pt/docs/frameworks/go/), [Java](/pt/docs/frameworks/java/), [.NET](/pt/docs/frameworks/dotnet/) e [WordPress](/pt/docs/frameworks/wordpress/).

## Pacote do servidor MCP

O pacote de código aberto [`@emailit/emailit-mcp`](https://github.com/emailit/emailit-mcp) executa um servidor MCP na sua máquina para que assistentes de IA possam chamar o Emailit com a sua chave de API:

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

A maioria das pessoas não precisa dele: o servidor hospedado em `https://api.emailit.com/mcp` não exige instalação. Compare os dois em [Servidor MCP local](/pt/docs/mcp/local-server/).

`@emailit/js` é um pacote diferente: é o script de navegador que mostra os [formulários do Emailit](/pt/docs/forms/install/) no seu site, não um cliente da API.

## Usar a API por HTTP

Você não precisa de uma biblioteca. Qualquer cliente HTTP que envie JSON funciona:

- URL base: `https://api.emailit.com/v2`
- Cabeçalhos: `Authorization: Bearer <your API key>` e `Content-Type: application/json`
- Corpos e respostas: JSON

Por exemplo, para encaminhar um e-mail com uma chave de idempotência a partir do Node.js, sem o 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()}`);
}
```

Leia [Erros](/pt/docs/api-reference/errors/) e [Limites de requisições](/pt/docs/api-reference/rate-limits/) antes de criar o seu próprio cliente, para tratar corretamente as respostas `4xx` e o `retry-after`. Se a sua aplicação já usa SMTP, você também pode dispensar a API e usar o [SMTP relay](/pt/docs/smtp/settings/).

## Bibliotecas da comunidade

O Emailit não mantém bibliotecas fora da lista acima. Se você encontrar ou criar uma para outra linguagem ou framework, revise o código dela antes de lhe dar uma chave de API e prefira uma chave Sending Only restrita a um domínio. Avise-nos em support@emailit.com ou no [Discord](https://discord.emailit.com) se quiser que ela seja mencionada aqui.

## Veja também

  - [Visão geral para desenvolvedores](/pt/docs/developers/): URL base, IDs, erros, paginação e limites de requisições.
  - [Chaves de API](/pt/docs/developers/api-keys/): Crie a chave de que a sua biblioteca precisa.
  - [Enviar e-mails com a API](/pt/docs/email-api/send-email/): Templates, anexos, agendamento e rastreamento.
  - [Assinaturas de webhook](/pt/docs/webhooks/request-signature/): Verifique se as requisições de webhook vêm do Emailit.

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