Mailtrap

https://github.com/mailtrap/mailtrap-elixir
Admin
Mailtrap is an Elixir API client with Bamboo adapters for interacting with Mailtrap Sandbox and...
Tokens:7,794
Snippets:55
Trust Score:8.2
License:MIT
Update:5 months ago
Show doc for...
Tokens:
Raw
### Initialize Mailtrap Sandbox Client

Source: https://github.com/mailtrap/mailtrap-elixir/blob/main/README.md

Initialize the Mailtrap Sandbox client with your API token.

```elixir
client = Mailtrap.Sandbox.client("PASTE TOKEN HERE")
```

--------------------------------

### Initialize Mailtrap API Client

Source: https://github.com/mailtrap/mailtrap-elixir/blob/main/README.md

Initialize the Mailtrap API client with your provided API token.

```elixir
client = Mailtrap.client("PASTE TOKEN HERE")
```

--------------------------------

### Create Email Attachments with Mailtrap.Email.Attachment.build/2

Source: https://context7.com/mailtrap/mailtrap-elixir/llms.txt

Builds an `Attachment` struct by Base64-encoding binary content. Supports optional MIME type, disposition, and content ID for inline images.

```elixir
# Attach a PDF file
{:ok, pdf_data} = File.read("priv/static/invoice.pdf")
attachment =
```

```elixir
  Mailtrap.Email.Attachment.build(pdf_data, "invoice.pdf")
  |> Mailtrap.Email.Attachment.put_type("application/pdf")
  |> Mailtrap.Email.Attachment.put_disposition("attachment")
```

```elixir
# Attach an inline image with a content ID
{:ok, img_data} = File.read("priv/static/logo.png")
inline_image =
```

```elixir
  Mailtrap.Email.Attachment.build(img_data, "logo.png")
  |> Mailtrap.Email.Attachment.put_type("image/png")
  |> Mailtrap.Email.Attachment.put_disposition("inline")
  |> Mailtrap.Email.Attachment.put_content_id("logo-cid")
```

```elixir
email =
  %Mailtrap.Email{}
```

```elixir
|> Mailtrap.Email.put_from({"Billing", "billing@acme.com"})
```

```elixir
|> Mailtrap.Email.put_to({"Customer", "customer@example.com"})
```

```elixir
|> Mailtrap.Email.put_subject("Your Invoice")
```

```elixir
|> Mailtrap.Email.put_html(~s(<img src="cid:logo-cid" /><p>Please find your invoice attached.</p>))
```

```elixir
|> Mailtrap.Email.put_attachments([attachment, inline_image])
```

```elixir
client = Mailtrap.Sending.client("my_api_token")
```

```elixir
{:ok, result} = Mailtrap.Sending.send(client, email)
```

```elixir
IO.inspect(result)
```

--------------------------------

### Build a Mailbox Address with Mailtrap.Email.Mailbox.build/2

Source: https://context7.com/mailtrap/mailtrap-elixir/llms.txt

Constructs a `Mailbox` struct (RFC 5322 mailbox) from a display name and email address. An empty or `nil` name omits the name field.

```elixir
# With display name
mb1 = Mailtrap.Email.Mailbox.build("Jane Doe", "jane@example.com")
# => %Mailtrap.Email.Mailbox{name: "Jane Doe", email: "jane@example.com"}
```

```elixir
# Without display name
mb2 = Mailtrap.Email.Mailbox.build(nil, "noreply@example.com")
# => %Mailtrap.Email.Mailbox{name: nil, email: "noreply@example.com"}
```

```elixir
mb3 = Mailtrap.Email.Mailbox.build("", "noreply@example.com")
# => %Mailtrap.Email.Mailbox{name: nil, email: "noreply@example.com"}
```

--------------------------------

### Bamboo.MailtrapSandboxAdapter — Bamboo Adapter for Sandbox Testing

Source: https://context7.com/mailtrap/mailtrap-elixir/llms.txt

A drop-in `Bamboo.Adapter` implementation that routes Bamboo emails into a Mailtrap virtual inbox. Requires both `api_token` and `inbox_id` in the mailer config.

```APIDOC
## `Bamboo.MailtrapSandboxAdapter` — Bamboo Adapter for Sandbox Testing

A drop-in `Bamboo.Adapter` implementation that routes Bamboo emails into a Mailtrap virtual inbox. Requires both `api_token` and `inbox_id` in the mailer config.

```elixir
# config/test.exs
config :my_app, MyApp.Mailer,
  adapter: Bamboo.MailtrapSandboxAdapter,
  api_token: System.get_env("MAILTRAP_API_TOKEN"),
  inbox_id: 111

# test/my_app/emails_test.exs
defmodule MyApp.EmailsTest do
  use ExUnit.Case

  test "sends welcome email to sandbox" do
    result =
      MyApp.Emails.welcome_email(%{name: "Bob", email: "bob@example.com"})
      |> MyApp.Mailer.deliver_now()

    assert {:ok, _response} = result
  end
end
```
```

--------------------------------

### Generate Welcome Email

Source: https://github.com/mailtrap/mailtrap-elixir/blob/main/README.md

A function to generate a welcome email with customizable subject, recipient name, and email address. It uses the `new_email` macro from Bamboo.

```elixir
def welcome_email(subject \"Hi there\", friendly_name \"Recepient\", to \"recepient@example.com\") do
  new_email(
    to: {friendly_name, to},
    from: {"From", "from@example.com"},
    subject: subject,
    html_body: "<strong>Thanks for joining!</strong>",
    text_body: "Thanks for joining!"
  )
end
```

--------------------------------

### Build Sandbox Testing Client

Source: https://context7.com/mailtrap/mailtrap-elixir/llms.txt

Create a Tesla client for capturing emails in a virtual inbox using the Mailtrap Sandbox API. Construct an email and send it with Mailtrap.Sandbox.send/3, specifying the inbox ID. Responses indicate success or failure.

```elixir
client = Mailtrap.Sandbox.client("my_api_token")
inbox_id = 111

email =
  %Mailtrap.Email{}
  |> Mailtrap.Email.put_from({"CI Bot", "ci@acme.com"})
  |> Mailtrap.Email.put_to([{"Bob", "bob@example.com"}, {"Carol", "carol@example.com"}])
  |> Mailtrap.Email.put_subject("Sandbox Test")
  |> Mailtrap.Email.put_text("Testing email flow in CI pipeline.")

case Mailtrap.Sandbox.send(client, email, inbox_id) do
  {:ok, response}  -> IO.inspect(response, label: "Sandbox response")
  {:error, env}    -> IO.puts("Error: #{env.status}")
end
```

--------------------------------

### Initialize Mailtrap Sending Client

Source: https://github.com/mailtrap/mailtrap-elixir/blob/main/README.md

Initialize the Mailtrap Sending API client with your API token.

```elixir
client = Mailtrap.Sending.client("PASTE TOKEN HERE")
```

--------------------------------

### Mailtrap.Sandbox.client/1 - Build a Sandbox Testing Client

Source: https://context7.com/mailtrap/mailtrap-elixir/llms.txt

Creates a Tesla client for the Mailtrap Sandbox API, located at `https://sandbox.api.mailtrap.io/api`. This client is used for capturing emails in a virtual inbox for testing purposes.

```APIDOC
## Mailtrap.Sandbox.client/1 - Build a Sandbox Testing Client

### Description
Creates a Tesla client pointed at `https://sandbox.api.mailtrap.io/api` for capturing emails in a virtual inbox without real delivery. This client is used with `Mailtrap.Sandbox.send/3`.

### Method
`Mailtrap.Sandbox.client(api_token)`

### Parameters
- `api_token` (string) - Your Mailtrap API token.

### Usage Examples

```elixir
client = Mailtrap.Sandbox.client("my_api_token")
inbox_id = 111

email = 
  %Mailtrap.Email{}`
  |> Mailtrap.Email.put_from({"CI Bot", "ci@acme.com"})
  |> Mailtrap.Email.put_to([{"Bob", "bob@example.com"}, {"Carol", "carol@example.com"}])
  |> Mailtrap.Email.put_subject("Sandbox Test")
  |> Mailtrap.Email.put_text("Testing email flow in CI pipeline.")

case Mailtrap.Sandbox.send(client, email, inbox_id) do
  {:ok, response}  -> IO.inspect(response, label: "Sandbox response")
  {:error, env}    -> IO.puts("Error: #{env.status}")
end
```

### Response
On success, returns `{:ok, response_body}`. On failure, returns `{:error, Tesla.Env.t()}`.
```

--------------------------------

### Configure Bamboo for Sandbox Testing with MailtrapSandboxAdapter

Source: https://context7.com/mailtrap/mailtrap-elixir/llms.txt

Routes Bamboo emails into a Mailtrap virtual inbox. Requires both `api_token` and `inbox_id` in the mailer config.

```elixir
# config/test.exs
config :my_app, MyApp.Mailer,
  adapter: Bamboo.MailtrapSandboxAdapter,
  api_token: System.get_env("MAILTRAP_API_TOKEN"),
  inbox_id: 111
```

```elixir
# test/my_app/emails_test.exs
defmodule MyApp.EmailsTest do
  use ExUnit.Case

  test "sends welcome email to sandbox" do
    result =
      MyApp.Emails.welcome_email(%{name: "Bob", email: "bob@example.com"})
      |> MyApp.Mailer.deliver_now()

    assert {:ok, _response} = result
  end
end
```

--------------------------------

### Construct and Send Email via Sandbox

Source: https://github.com/mailtrap/mailtrap-elixir/blob/main/README.md

Construct an email using Mailtrap.Email struct and send it via the Mailtrap Sandbox API. Replace '111' with your inbox ID.

```elixir
email = (%Mailtrap.Email{})
  |> Mailtrap.Email.put_from({"From name", "from@example.com"})
  |> Mailtrap.Email.put_to({"Recepient", "recepient@example.com"})
  |> Mailtrap.Email.put_subject("Hi there")
  |> Mailtrap.Email.put_text("General Kenobi")
Mailtrap.Sandbox.send(client, email, 111) # replace 111 with your inbox id
```

--------------------------------

### Build an Email with Mailtrap.Email

Source: https://context7.com/mailtrap/mailtrap-elixir/llms.txt

Construct email messages using a pipeline-friendly struct. All `put_*` functions accept the email struct and return an updated struct.

```elixir
email =
  %Mailtrap.Email{}
```

```elixir
|> Mailtrap.Email.put_from({"Sender Name", "sender@example.com"})
```

```elixir
|> Mailtrap.Email.put_to({"Recipient", "recipient@example.com"})
```

```elixir
|> Mailtrap.Email.put_cc([{"Manager", "manager@example.com"}])
```

```elixir
|> Mailtrap.Email.put_bcc({"Audit", "audit@example.com"})
```

```elixir
|> Mailtrap.Email.put_subject("Welcome to Acme!")
```

```elixir
|> Mailtrap.Email.put_text("Plain text body.")
```

```elixir
|> Mailtrap.Email.put_html("<h1>Welcome!</h1><p>Thanks for joining.</p>")
```

```elixir
|> Mailtrap.Email.put_category("Onboarding")
```

```elixir
|> Mailtrap.Email.put_custom_variables(%{user_id: "42", plan: "pro"})
```

```elixir
|> Mailtrap.Email.put_headers(%{"X-Campaign-ID" => "launch-2024"})
```

```elixir
IO.inspect(email.subject)   # => "Welcome to Acme!"
```

```elixir
IO.inspect(email.category)  # => "Onboarding"
```

```elixir
IO.inspect(email.from)
```

```elixir
# => %Mailtrap.Email.Mailbox{name: "Sender Name", email: "sender@example.com"}
```

```elixir
IO.inspect(email.to)
```

```elixir
# => [%Mailtrap.Email.Mailbox{name: "Recipient", email: "recipient@example.com"}]
```

--------------------------------

### Mailtrap.client/1 - Build a General API Client

Source: https://context7.com/mailtrap/mailtrap-elixir/llms.txt

Creates a Tesla HTTP client preconfigured for the Mailtrap management REST API. This client can be used to perform arbitrary authenticated requests to the Mailtrap API.

```APIDOC
## Mailtrap.client/1 - Build a General API Client

### Description
Creates a Tesla HTTP client preconfigured with bearer-token auth and base URL `https://mailtrap.io/api`. Use this client to call any endpoint of the Mailtrap management REST API.

### Method
`Mailtrap.client(api_token)`

### Parameters
- `api_token` (string) - Your Mailtrap API token.

### Usage Examples

```elixir
client = Mailtrap.client("my_api_token")

# Fetch all accounts
{:ok, accounts} = Mailtrap.get(client, "accounts")
IO.inspect(accounts)

# Revoke an account access
account_id = "42"
access_id  = "99"
{:ok, _} = Mailtrap.delete(client, "accounts/#{account_id}/account_accesses/#{access_id}")

# Update a resource via PATCH
{:ok, updated} = Mailtrap.patch(client, "accounts/#{account_id}", %{name: "New Name"})

# Error case — non-200 response
case Mailtrap.get(client, "accounts/0") do
  {:ok, body}    -> IO.puts("Success: #{inspect(body)}")
  {:error, env}  -> IO.puts("Error #{env.status}: #{inspect(env.body)}")
end
```

### Response
API calls return `{:ok, body}` on HTTP 200 and `{:error, Tesla.Env.t()}` otherwise.
```

--------------------------------

### Construct and Send Email via Sending API

Source: https://github.com/mailtrap/mailtrap-elixir/blob/main/README.md

Construct an email using Mailtrap.Email struct and send it via the Mailtrap Sending API.

```elixir
email = (%Mailtrap.Email{})
  |> Mailtrap.Email.put_from({"From name", "from@example.com"})
  |> Mailtrap.Email.put_to({"Recepient", "recepient@example.com"})
  |> Mailtrap.Email.put_subject("Hi there")
  |> Mailtrap.Email.put_text("General Kenobi")
Mailtrap.Sending.send(client, email)
```

--------------------------------

### Mailtrap.Sending.client/1 - Build a Production Sending Client

Source: https://context7.com/mailtrap/mailtrap-elixir/llms.txt

Creates a Tesla client specifically for the Mailtrap Sending API, pointed at `https://send.api.mailtrap.io/api`. This is used for sending real transactional emails in production.

```APIDOC
## Mailtrap.Sending.client/1 - Build a Production Sending Client

### Description
Creates a Tesla client pointed at `https://send.api.mailtrap.io/api` for sending real transactional emails. This client is used in conjunction with `Mailtrap.Sending.send/2`.

### Method
`Mailtrap.Sending.client(api_token)`

### Parameters
- `api_token` (string) - Your Mailtrap API token.

### Usage Examples

```elixir
client = Mailtrap.Sending.client("my_api_token")

email = 
  %Mailtrap.Email{}`
  |> Mailtrap.Email.put_from({"Acme Support", "support@acme.com"})
  |> Mailtrap.Email.put_to({"Alice", "alice@example.com"})
  |> Mailtrap.Email.put_subject("Your order has shipped!")
  |> Mailtrap.Email.put_text("Hi Alice, your order #1234 is on its way.")
  |> Mailtrap.Email.put_html("<p>Hi Alice, your order <strong>#1234</strong> is on its way.</p>")

case Mailtrap.Sending.send(client, email) do
  {:ok, %{"message_ids" => ids}} -> IO.puts("Sent! IDs: #{inspect(ids)}")
  {:error, env}                  -> IO.puts("Failed #{env.status}: #{inspect(env.body)}")
end
```

### Response
On success, returns `{:ok, %{"message_ids" => list_of_ids}}`. On failure, returns `{:error, Tesla.Env.t()}`.
```

--------------------------------

### Bamboo.MailtrapSendingAdapter — Bamboo Adapter for Production Sending

Source: https://context7.com/mailtrap/mailtrap-elixir/llms.txt

A drop-in `Bamboo.Adapter` implementation that routes Bamboo emails through the Mailtrap Sending API. Requires `api_token` in the mailer config.

```APIDOC
## `Bamboo.MailtrapSendingAdapter` — Bamboo Adapter for Production Sending

A drop-in `Bamboo.Adapter` implementation that routes Bamboo emails through the Mailtrap Sending API. Requires `api_token` in the mailer config.

```elixir
# lib/my_app/mailer.ex
defmodule MyApp.Mailer do
  use Bamboo.Mailer, otp_app: :my_app
end

# config/prod.exs
config :my_app, MyApp.Mailer,
  adapter: Bamboo.MailtrapSendingAdapter,
  api_token: System.get_env("MAILTRAP_API_TOKEN")

# lib/my_app/emails.ex
defmodule MyApp.Emails do
  import Bamboo.Email

  def welcome_email(user) do
    new_email(
      to: {user.name, user.email},
      from: {"MyApp Team", "hello@myapp.com"},
      subject: "Welcome, #{user.name}!",
      html_body: "<strong>Thanks for signing up!</strong>",
      text_body: "Thanks for signing up!"
    )
  end
end

# Deliver
MyApp.Emails.welcome_email(%{name: "Alice", email: "alice@example.com"})
|> MyApp.Mailer.deliver_now()
# => {:ok, %{"message_ids" => ["abc123"]}}
```
```

--------------------------------

### Mailtrap.Email.Mailbox.build/2 — Build a Mailbox Address

Source: https://context7.com/mailtrap/mailtrap-elixir/llms.txt

Constructs a `Mailbox` struct (RFC 5322 mailbox) from a display name and email address. An empty or `nil` name omits the name field.

```APIDOC
## `Mailtrap.Email.Mailbox.build/2` — Build a Mailbox Address

Constructs a `Mailbox` struct (RFC 5322 mailbox) from a display name and email address. An empty or `nil` name omits the name field.

```elixir
# With display name
mb1 = Mailtrap.Email.Mailbox.build("Jane Doe", "jane@example.com")
# => %Mailtrap.Email.Mailbox{name: "Jane Doe", email: "jane@example.com"}

# Without display name
mb2 = Mailtrap.Email.Mailbox.build(nil, "noreply@example.com")
# => %Mailtrap.Email.Mailbox{name: nil, email: "noreply@example.com"}

mb3 = Mailtrap.Email.Mailbox.build("", "noreply@example.com")
# => %Mailtrap.Email.Mailbox{name: nil, email: "noreply@example.com"}
```
```

--------------------------------

### Mailtrap.Email.Attachment.build/2 — Create an Email Attachment

Source: https://context7.com/mailtrap/mailtrap-elixir/llms.txt

Builds an `Attachment` struct by Base64-encoding binary content. Supports optional MIME type, disposition, and content ID for inline images.

```APIDOC
## `Mailtrap.Email.Attachment.build/2` — Create an Email Attachment

Builds an `Attachment` struct by Base64-encoding binary content. Supports optional MIME type, disposition, and content ID for inline images.

```elixir
# Attach a PDF file
{:ok, pdf_data} = File.read("priv/static/invoice.pdf")
attachment =
  Mailtrap.Email.Attachment.build(pdf_data, "invoice.pdf")
  |> Mailtrap.Email.Attachment.put_type("application/pdf")
  |> Mailtrap.Email.Attachment.put_disposition("attachment")

# Attach an inline image with a content ID
{:ok, img_data} = File.read("priv/static/logo.png")
inline_image =
  Mailtrap.Email.Attachment.build(img_data, "logo.png")
  |> Mailtrap.Email.Attachment.put_type("image/png")
  |> Mailtrap.Email.Attachment.put_disposition("inline")
  |> Mailtrap.Email.Attachment.put_content_id("logo-cid")

email =
  %Mailtrap.Email{}
  |> Mailtrap.Email.put_from({"Billing", "billing@acme.com"})
  |> Mailtrap.Email.put_to({"Customer", "customer@example.com"})
  |> Mailtrap.Email.put_subject("Your Invoice")
  |> Mailtrap.Email.put_html(~s(<img src="cid:logo-cid" /><p>Please find your invoice attached.</p>))
  |> Mailtrap.Email.put_attachments([attachment, inline_image])

client = Mailtrap.Sending.client("my_api_token")
{:ok, result} = Mailtrap.Sending.send(client, email)
IO.inspect(result)
```
```

--------------------------------

### Deliver Email using Bamboo Adapter

Source: https://github.com/mailtrap/mailtrap-elixir/blob/main/README.md

Send a generated email immediately using the configured Mailtrap Bamboo adapter.

```elixir
welcome_email() |> TestMailtrap.Mailer.deliver_now()
```

--------------------------------

### Configure Bamboo for Production Sending with MailtrapSendingAdapter

Source: https://context7.com/mailtrap/mailtrap-elixir/llms.txt

Routes Bamboo emails through the Mailtrap Sending API. Requires `api_token` in the mailer config.

```elixir
# lib/my_app/mailer.ex
defmodule MyApp.Mailer do
  use Bamboo.Mailer, otp_app: :my_app
end
```

```elixir
# config/prod.exs
config :my_app, MyApp.Mailer,
  adapter: Bamboo.MailtrapSendingAdapter,
  api_token: System.get_env("MAILTRAP_API_TOKEN")
```

```elixir
# lib/my_app/emails.ex
defmodule MyApp.Emails do
  import Bamboo.Email

  def welcome_email(user) do
    new_email(
      to: {user.name, user.email},
      from: {"MyApp Team", "hello@myapp.com"},
      subject: "Welcome, #{user.name}!",
      html_body: "<strong>Thanks for signing up!</strong>",
      text_body: "Thanks for signing up!"
    )
  end
end
```

```elixir
# Deliver
MyApp.Emails.welcome_email(%{name: "Alice", email: "alice@example.com"})
|> MyApp.Mailer.deliver_now()
# => {:ok, %{"message_ids" => ["abc123"]}}
```

--------------------------------

### Configure Mailtrap Bamboo Adapters

Source: https://context7.com/mailtrap/mailtrap-elixir/llms.txt

Configure the Mailtrap adapters for Bamboo in your application configuration files. Use the Sending adapter for production and the Sandbox adapter for testing.

```elixir
config :my_app, MyApp.Mailer,
  adapter: Bamboo.MailtrapSendingAdapter,
  api_token: System.get_env("MAILTRAP_API_TOKEN")
```

```elixir
config :my_app, MyApp.Mailer,
  adapter: Bamboo.MailtrapSandboxAdapter,
  api_token: System.get_env("MAILTRAP_API_TOKEN"),
  inbox_id: 111
```

--------------------------------

### Build Production Sending Client

Source: https://context7.com/mailtrap/mailtrap-elixir/llms.txt

Create a Tesla client for sending transactional emails via the Mailtrap Sending API. Construct an email using Mailtrap.Email struct and its put_* functions, then send it using Mailtrap.Sending.send/2. Handles success and error responses.

```elixir
client = Mailtrap.Sending.client("my_api_token")

email =
  %Mailtrap.Email{}
  |> Mailtrap.Email.put_from({"Acme Support", "support@acme.com"})
  |> Mailtrap.Email.put_to({"Alice", "alice@example.com"})
  |> Mailtrap.Email.put_subject("Your order has shipped!")
  |> Mailtrap.Email.put_text("Hi Alice, your order #1234 is on its way.")
  |> Mailtrap.Email.put_html("<p>Hi Alice, your order <strong>#1234</strong> is on its way.</p>")

case Mailtrap.Sending.send(client, email) do
  {:ok, %{"message_ids" => ids}} -> IO.puts("Sent! IDs: #{inspect(ids)}")
  {:error, env}                  -> IO.puts("Failed #{env.status}: #{inspect(env.body)}")
end
```

--------------------------------

### Define Mailer Module for Bamboo

Source: https://github.com/mailtrap/mailtrap-elixir/blob/main/README.md

Define a Mailer module that uses Bamboo and specifies the OTP app.

```elixir
defmodule TestMailtrap.Mailer do
  use Bamboo.Mailer, otp_app: :test_mailtrap
end
```

--------------------------------

### Configure Mailtrap Sandbox Adapter

Source: https://github.com/mailtrap/mailtrap-elixir/blob/main/README.md

Configure the Bamboo adapter for Mailtrap Sandbox. Ensure you replace 'PASTE TOKEN HERE' with your actual API token and '111' with your inbox ID.

```elixir
config :test_mailtrap, TestMailtrap.Mailer,
  adapter: Bamboo.MailtrapSandboxAdapter,
  api_token: "PASTE TOKEN HERE",
  inbox_id: 111 # replace with your inbox id
```

--------------------------------

### Configure Mailtrap Sending Adapter

Source: https://github.com/mailtrap/mailtrap-elixir/blob/main/README.md

Configure the Bamboo adapter for Mailtrap Sending API. Replace 'PASTE TOKEN HERE' with your actual API token.

```elixir
config :test_mailtrap, TestMailtrap.Mailer,
  adapter: Bamboo.MailtrapSendingAdapter,
  api_token: "PASTE TOKEN HERE"
```

--------------------------------

### Fetch Mailtrap Accounts

Source: https://github.com/mailtrap/mailtrap-elixir/blob/main/README.md

Retrieve account information using the initialized Mailtrap API client.

```elixir
accounts = Mailtrap.get(client, "accounts")
```

--------------------------------

### Build General Mailtrap API Client

Source: https://context7.com/mailtrap/mailtrap-elixir/llms.txt

Create a Tesla HTTP client for the Mailtrap management REST API. Use this client for operations like fetching accounts or updating resources. API calls return {:ok, body} on success or {:error, Tesla.Env.t()} on failure.

```elixir
client = Mailtrap.client("my_api_token")

# Fetch all accounts
{:ok, accounts} = Mailtrap.get(client, "accounts")
IO.inspect(accounts)
# => [வைக்{"id" => 42, "name" => "My Workspace", ...}]

# Revoke an account access
account_id = "42"
access_id  = "99"
{:ok, _} = Mailtrap.delete(client, "accounts/#{account_id}/account_accesses/#{access_id}")

# Update a resource via PATCH
{:ok, updated} = Mailtrap.patch(client, "accounts/#{account_id}", %{name: "New Name"})

# Error case — non-200 response
case Mailtrap.get(client, "accounts/0") do
  {:ok, body}    -> IO.puts("Success: #{inspect(body)}")
  {:error, env}  -> IO.puts("Error #{env.status}: #{inspect(env.body)}")
end
```

--------------------------------

### Add Mailtrap Dependency

Source: https://github.com/mailtrap/mailtrap-elixir/blob/main/README.md

Add the Mailtrap Elixir client to your project's dependencies.

```elixir
def deps do
  [
    {:mailtrap, "~> 0.2.0"}
  ]
end
```

--------------------------------

### Mailtrap.Email — Composable Email Builder

Source: https://context7.com/mailtrap/mailtrap-elixir/llms.txt

Construct email messages using a pipeline-friendly struct. The `put_*` functions allow for incremental updates to the email struct.

```APIDOC
## `Mailtrap.Email` — Composable Email Builder

A pipeline-friendly struct module for constructing email messages. All `put_*` functions accept the email struct as the first argument and return an updated struct.

```elixir
email =
  %Mailtrap.Email{}
  |> Mailtrap.Email.put_from({"Sender Name", "sender@example.com"})
  |> Mailtrap.Email.put_to({"Recipient", "recipient@example.com"})
  |> Mailtrap.Email.put_cc([{"Manager", "manager@example.com"}])
  |> Mailtrap.Email.put_bcc({"Audit", "audit@example.com"})
  |> Mailtrap.Email.put_subject("Welcome to Acme!")
  |> Mailtrap.Email.put_text("Plain text body.")
  |> Mailtrap.Email.put_html("<h1>Welcome!</h1><p>Thanks for joining.</p>")
  |> Mailtrap.Email.put_category("Onboarding")
  |> Mailtrap.Email.put_custom_variables(%{user_id: "42", plan: "pro"})
  |> Mailtrap.Email.put_headers(%{"X-Campaign-ID" => "launch-2024"})

IO.inspect(email.subject)   # => "Welcome to Acme!"
IO.inspect(email.category)  # => "Onboarding"
IO.inspect(email.from)
# => %Mailtrap.Email.Mailbox{name: "Sender Name", email: "sender@example.com"}
IO.inspect(email.to)
# => [%Mailtrap.Email.Mailbox{name: "Recipient", email: "recipient@example.com"}]
```
```

--------------------------------

### Mailtrap Elixir Client - Generic HTTP Verbs

Source: https://context7.com/mailtrap/mailtrap-elixir/llms.txt

Use these low-level wrappers over Tesla HTTP verbs to call any endpoint of the Mailtrap management REST API directly. All functions return `{:ok, body}` on success or `{:error, Tesla.Env.t()}` on failure. Ensure you have a Mailtrap client initialized with your API token.

```elixir
client = Mailtrap.client("my_api_token")

# GET — list inboxes for a project
{:ok, inboxes} = Mailtrap.get(client, "accounts/42/projects/7/inboxes")
Enum.each(inboxes, fn i -> IO.puts("Inbox: #{i["name"]} (#{i["id"]})") end)

# POST — create a new inbox
{:ok, inbox} = Mailtrap.post(client, "accounts/42/projects/7/inboxes", %{inbox: %{name: "Staging"}})
IO.inspect(inbox["id"])  # => 222

# PUT — replace inbox settings
{:ok, _} = Mailtrap.put(client, "accounts/42/inboxes/222", %{inbox: %{name: "Staging v2"}})

# PATCH — partial update
{:ok, _} = Mailtrap.patch(client, "accounts/42/inboxes/222", %{inbox: %{email_username: "staging"}})

# DELETE — remove account access
{:ok, _} = Mailtrap.delete(client, "accounts/42/account_accesses/99")
```

--------------------------------

### Mailtrap Generic HTTP Verbs

Source: https://context7.com/mailtrap/mailtrap-elixir/llms.txt

Low-level wrappers over Tesla HTTP verbs for calling any endpoint of the Mailtrap management REST API directly. All return `{:ok, body}` on success or `{:error, Tesla.Env.t()}` on failure.

```APIDOC
## `Mailtrap` Generic HTTP Verbs — `get/3`, `post/4`, `put/4`, `patch/4`, `delete/3`

Low-level wrappers over Tesla HTTP verbs for calling any endpoint of the Mailtrap management REST API directly. All return `{:ok, body}` on success or `{:error, Tesla.Env.t()}` on failure.

```elixir
client = Mailtrap.client("my_api_token")

# GET — list inboxes for a project
{:ok, inboxes} = Mailtrap.get(client, "accounts/42/projects/7/inboxes")
Enum.each(inboxes, fn i -> IO.puts("Inbox: #{i["name"]} (#{i["id"]})") end)

# POST — create a new inbox
{:ok, inbox} = Mailtrap.post(client, "accounts/42/projects/7/inboxes", %{inbox: %{name: "Staging"}})
IO.inspect(inbox["id"])  # => 222

# PUT — replace inbox settings
{:ok, _} = Mailtrap.put(client, "accounts/42/inboxes/222", %{inbox: %{name: "Staging v2"}})

# PATCH — partial update
{:ok, _} = Mailtrap.patch(client, "accounts/42/inboxes/222", %{inbox: %{email_username: "staging"}})

# DELETE — remove account access
{:ok, _} = Mailtrap.delete(client, "accounts/42/account_accesses/99")
```
```

--------------------------------

### Delete Mailtrap Account Access

Source: https://github.com/mailtrap/mailtrap-elixir/blob/main/README.md

Delete a specific account access entry using the Mailtrap API client. Ensure you have the correct account_id and account_access_id.

```elixir
Mailtrap.delete(client, "accounts/" <> account_id <> "/account_accesses/" <> account_access_id)
```
Tokens:
Raw