# Odeslání prvního e-mailu přes API

> Ověřte doménu, vytvořte API klíč a odešlete první e-mail přes cURL nebo oficiální SDK pro Node.js, Python, PHP, Ruby, Go, Javu, .NET nebo Rust.

Tento rychlý začátek vás od nového účtu dovede k doručenému e-mailu zhruba za pět minut, plus čas, který váš poskytovatel DNS potřebuje ke zveřejnění záznamů. Ověříte doménu, vytvoříte API klíč, odešlete e-mail a najdete ho ve webovém rozhraní.

## Než začnete

- Účet v Emailitu. Zaregistrujte se na [dash.emailit.com](https://dash.emailit.com).
- Doména, ke které můžete přidávat DNS záznamy, například `acme.com`. Můžete použít i subdoménu, například `mail.acme.com`.

## Přidejte a ověřte doménu

Emailit odesílá jen z ověřených domén, aby poštovní servery příjemců mohly zkontrolovat, že e-mail opravdu pochází od vás.

1. **Přidejte doménu.** Otevřete **Email API → Domains**, vyberte **Add domain**, zadejte `acme.com` a vyberte **Create**.

2. **Zveřejněte DNS záznamy.** Stránka domény uvádí záznamy, které máte přidat u svého poskytovatele DNS. Zkopírujte z ní přesné hodnoty. Tři povinné záznamy vypadají takto:

   | Typ | Název | Hodnota |
   | --- | --- | --- |
   | TXT | `emailit._domainkey.acme.com` | `v=DKIM1; t=s; h=sha256; p=…` (váš klíč) |
   | TXT | `emailit.acme.com` | `v=spf1 include:_spf.emailit.com ~all` |
   | MX | `emailit.acme.com`, priorita 10 | `feedback-smtp.ffdc-1.emailit.com` |

   Pokud máte DNS v Cloudflare, můžete záznamy místo toho zveřejnit jedním kliknutím. Viz [Nastavení DNS v Cloudflare](/cs/docs/domains/cloudflare/).

3. **Zkontrolujte DNS.** Vyberte **Check DNS**. Když SPF, DKIM a Return Path ukazují **OK**, má doména stav **Verified**. Většina poskytovatelů záznamy zveřejní během několika minut, ale může to trvat až 48 hodin.

V tarifu Pay as you go má doména registrovaná před méně než 30 dny stav **Pending verification**, dokud ji tým Emailitu nezkontroluje. Podrobnosti a volitelné záznamy pro DMARC, měření a příchozí poštu najdete na stránce [Přidání odesílací domény](/cs/docs/domains/add-a-domain/).

## Vytvořte API klíč

1. **Otevřete API klíče.** Otevřete **Email API → API Keys** a vyberte **Add API key**.

2. **Pojmenujte klíč a zvolte rozsah oprávnění.** Zadejte název, například `Quickstart`. **Sending Only** může jen odesílat e-maily. **Full Access** může volat i zbytek API. Pro tento rychlý začátek stačí kterýkoli z nich.

3. **Zkopírujte klíč.** Vyberte **Create** a klíč zkopírujte. Začíná na `secret_` a zobrazí se jen jednou.

4. **Uložte ho do proměnné prostředí**, aby nebyl ve vašem kódu:

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

## Odešlete e-mail

Nainstalujte SDK pro svůj jazyk, nebo použijte 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
```

Pak odešlete e-mail. Použijte adresu odesílatele na doméně, kterou jste ověřili, a e-mail pošlete na adresu, se kterou jste se zaregistrovali:

**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(())
}
```

> **Režim sandbox:** Dokud váš workspace nemá produkční přístup, můžete odesílat jen na e-mailové adresy účtů členů workspace. Odeslání komukoli jinému vrátí `403` s kódem `unverified_workspace_recipient`. Až budete připraveni na skutečné příjemce, [požádejte o produkční přístup](/cs/docs/workspaces/production-access/).

## Přečtěte si odpověď

Úspěšný požadavek vrací `200` s novým e-mailem:

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

| Pole | Význam |
| --- | --- |
| `id` | ID e-mailu. Použijte ho k dohledání e-mailu, k jeho zrušení nebo opakovanému odeslání a k párování událostí webhooků. |
| `status` | `accepted` znamená, že Emailit zařadil e-mail do fronty k doručení. Pokud nastavíte `scheduled_at`, je stav `scheduled`. |
| `message_id` | Hlavička `Message-ID` e-mailu. |
| `ids` | Uvádí se, jen pokud je příjemců víc. Přiřazuje každé adrese příjemce vlastní ID e-mailu. |
| `tracking` | Jestli se u tohoto e-mailu měří otevření (`loads`) a prokliky. Měření potřebuje ověřenou [subdoménu pro měření](/cs/docs/tracking/). |

Stav `accepted` ještě neznamená doručení. Doručení probíhá na pozadí a stav se během něj mění.

## Zkontrolujte e-mail ve webovém rozhraní

Otevřete **Email API → Emails**. Váš e-mail je nahoře na kartě **Outgoing**. Během několika sekund obvykle přejde ze stavu **accepted** do stavu **delivered**. Když ho otevřete, uvidíte hlavičky, obsah, každý pokus o doručení s odpovědí přijímajícího serveru a výsledky kontrol spamu.

Samotný požadavek se zobrazí v **Email API → Logs** se stavovým kódem a tělem požadavku i odpovědi.

## Řešení problémů

| Odpověď | Příčina | Řešení |
| --- | --- | --- |
| `401` `API key required` nebo `Invalid API key` | Chybí hlavička `Authorization`, nebo je klíč špatný | Pošlete `Authorization: Bearer secret_…` s aktuálním klíčem |
| `403` `unverified_workspace_recipient` | Workspace je v režimu sandbox | Odešlete e-mail na adresu účtu člena workspace, nebo [požádejte o produkční přístup](/cs/docs/kb/403-unverified-workspace-recipient/) |
| `422` `From/Sender domain is not valid or not verified` | Doména odesílatele není v tomto workspace ověřená | Ověřte doménu, nebo použijte adresu na ověřené doméně |
| `403` `Domain not authorized` | Klíč jen pro odesílání je omezený na jinou doménu | Použijte klíč pro tuto doménu, nebo klíč bez omezení |
| `402` `Insufficient credits` | Workspace nemá dost kreditů | [Dokupte kredity](/cs/docs/kb/402-insufficient-credits/) |
| `429` `Rate limit exceeded` | Příliš mnoho e-mailů v této sekundě nebo dnes | Počkejte dobu uvedenou v `retry-after`. Viz [Limity rychlosti](/cs/docs/kb/429-rate-limit-exceeded/). |

## Další kroky

  - [Nastavte webhooky](/cs/docs/webhooks/set-up/): Dostávejte události doručení, nedoručení a otevření v reálném čase.
  - [Odesílejte se šablonou](/cs/docs/templates/): Navrhněte e-mail jednou ve webovém rozhraní a odesílejte ho podle aliasu s proměnnými.
  - [Idempotentní požadavky](/cs/docs/email-api/idempotency/): Opakujte požadavky bezpečně, aniž byste odeslali e-mail dvakrát.
  - [Kontrolní seznam před ostrým provozem](/cs/docs/get-started/go-live/): Co zkontrolovat, než začnete odesílat skutečným příjemcům.

---
Zdroj: https://emailit.com/cs/docs/quickstart/api/
