# Enviar o primeiro e-mail com a API

> Verifique um domínio, crie uma chave de API e envie o seu primeiro e-mail com cURL ou com um SDK oficial para Node.js, Python, PHP, Ruby, Go, Java, .NET ou Rust.

Este guia rápido leva você de uma conta nova a um e-mail entregue em cerca de cinco minutos, mais o tempo que o seu provedor de DNS leva para publicar os registros. Você vai verificar um domínio, criar uma chave de API, enviar um e-mail e encontrá-lo no painel.

## Antes de começar

- Uma conta no Emailit. Crie uma em [dash.emailit.com](https://dash.emailit.com).
- Um domínio em que você possa adicionar registros DNS, como `acme.com`. Você também pode usar um subdomínio, como `mail.acme.com`.

## Adicionar e verificar o seu domínio

O Emailit só envia de domínios que você verificou, para que os servidores de e-mail dos destinatários possam confirmar que o e-mail vem mesmo de você.

1. **Adicione o domínio.** Acesse **Email API → Domains**, selecione **Add domain**, digite `acme.com` e selecione **Create**.

2. **Publique os registros DNS.** A página do domínio lista os registros a adicionar no seu provedor de DNS. Copie os valores exatos dessa página. Os três registros obrigatórios são assim:

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

   Se o seu DNS estiver no Cloudflare, você pode publicar os registros em um clique. Consulte [Cloudflare](/pt/docs/domains/cloudflare/).

3. **Verifique o DNS.** Selecione **Check DNS**. Quando SPF, DKIM e Return Path mostrarem **OK**, o domínio fica **Verified**. A maioria dos provedores publica os registros em minutos, mas isso pode levar até 48 horas.

No Pay as you go, um domínio registrado há menos de 30 dias mostra **Pending verification** até a equipe do Emailit analisá-lo. Consulte [Adicionar um domínio](/pt/docs/domains/add-a-domain/) para ver os detalhes e os registros opcionais de DMARC, rastreamento e recebimento de e-mails.

## Criar uma chave de API

1. **Abra as chaves de API.** Acesse **Email API → API Keys** e selecione **Add API key**.

2. **Dê um nome à chave e escolha um escopo.** Digite um nome como `Quickstart`. **Sending Only** só pode enviar e-mails. **Full Access** também pode chamar o restante da API. Qualquer uma serve para este guia rápido.

3. **Copie a chave.** Selecione **Create** e copie a chave. Ela começa com `secret_` e é exibida uma única vez.

4. **Guarde-a em uma variável de ambiente** para mantê-la fora do seu código:

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

## Enviar um e-mail

Instale o SDK da sua linguagem ou use 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
```

Depois, envie um e-mail. Use um endereço From no domínio que você verificou e envie para o endereço de e-mail com que você criou a conta:

**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:** Até o seu workspace ter acesso de produção, você só pode enviar para os endereços de e-mail das contas dos membros do workspace. Enviar para qualquer outra pessoa retorna `403` com o código `unverified_workspace_recipient`. Quando estiver pronto para destinatários reais, [solicite o acesso de produção](/pt/docs/workspaces/production-access/).

## Ler a resposta

Uma requisição bem-sucedida retorna `200` com o novo e-mail:

```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` | O ID do e-mail. Use-o para consultar, cancelar ou tentar enviar o e-mail de novo e para associar os eventos de webhook. |
| `status` | `accepted` significa que o Emailit colocou o e-mail na fila para entrega. Ele fica `scheduled` se você definir `scheduled_at`. |
| `message_id` | O cabeçalho `Message-ID` do e-mail. |
| `ids` | Presente apenas com vários destinatários. Associa cada endereço de destinatário ao ID do e-mail correspondente. |
| `tracking` | Se as aberturas (`loads`) e os cliques são rastreados neste e-mail. O rastreamento exige um [subdomínio de rastreamento](/pt/docs/tracking/) verificado. |

`accepted` ainda não significa entregue. A entrega acontece em segundo plano, e o status muda à medida que ela avança.

## Conferir no painel

Acesse **Email API → Emails**. O seu e-mail está no topo da aba **Outgoing**. Em poucos segundos, o status dele normalmente muda de **accepted** para **delivered**. Abra-o para ver os cabeçalhos, o conteúdo, cada tentativa de entrega com a resposta do servidor de destino e os resultados da verificação de spam.

A própria requisição aparece em **Email API → Logs**, com o código de status e os corpos da requisição e da resposta.

## Solução de problemas

| Resposta | Causa | Solução |
| --- | --- | --- |
| `401` `API key required` ou `Invalid API key` | O cabeçalho `Authorization` está ausente ou a chave está errada | Envie `Authorization: Bearer secret_…` com uma chave atual |
| `403` `unverified_workspace_recipient` | O workspace está no modo sandbox | Envie para o e-mail da conta de um membro do workspace ou [solicite o acesso de produção](/pt/docs/kb/403-unverified-workspace-recipient/) |
| `422` `From/Sender domain is not valid or not verified` | O domínio do From não está verificado neste workspace | Verifique o domínio ou use um endereço em um domínio verificado |
| `403` `Domain not authorized` | A chave Sending Only está restrita a outro domínio | Use uma chave para este domínio ou uma chave sem restrição |
| `402` `Insufficient credits` | O workspace não tem créditos suficientes | [Adicione créditos](/pt/docs/kb/402-insufficient-credits/) |
| `429` `Rate limit exceeded` | E-mails demais neste segundo ou hoje | Espere o tempo indicado em `retry-after`. Consulte [Limites de requisições](/pt/docs/kb/429-rate-limit-exceeded/). |

## Próximos passos

  - [Configurar webhooks](/pt/docs/webhooks/set-up/): Receba eventos de entrega, bounce e abertura em tempo real.
  - [Enviar com um template](/pt/docs/templates/): Crie uma vez no painel e envie pelo alias com variáveis.
  - [Idempotência](/pt/docs/email-api/idempotency/): Tente as requisições de novo com segurança, sem enviar duas vezes.
  - [Checklist para entrar em produção](/pt/docs/get-started/go-live/): O que conferir antes de enviar para destinatários reais.

---
Fonte: https://emailit.com/pt/docs/quickstart/api/