Emailit Ruby

gem "emailit"

require "emailit"

client = Emailit::EmailitClient.new("your_api_key")

email = client.emails.send(
  from: "hello@yourdomain.com",
  to: ["user@example.com"],
  subject: "Hello from Emailit",
  html: "<h1>Welcome!</h1><p>Thanks for signing up.</p>"
)

puts email.id     # em_abc123...
puts email.status # pending

email = client.emails.send(
  from: "hello@yourdomain.com",
  to: ["user@example.com"],
  subject: "Hello from Emailit",
  html: "<h1>Welcome!</h1>"
)

puts email.id
puts email.status

email = client.emails.send(
  from: "hello@yourdomain.com",
  to: "user@example.com",
  template: "welcome_email",
  variables: {
    name: "John Doe",
    company: "Acme Inc"
  }
)

email = client.emails.send(
  from: "invoices@yourdomain.com",
  to: "customer@example.com",
  subject: "Your Invoice #12345",
  html: "<p>Please find your invoice attached.</p>",
  attachments: [
    {
      filename: "invoice.pdf",
      content: Base64.strict_encode64(File.read("invoice.pdf")),
      content_type: "application/pdf"
    }
  ]
)

email = client.emails.send(
  from: "reminders@yourdomain.com",
  to: "user@example.com",
  subject: "Appointment Reminder",
  html: "<p>Your appointment is tomorrow at 2 PM.</p>",
  scheduled_at: "2026-01-10T09:00:00Z"
)

puts email.status       # scheduled
puts email.scheduled_at # 2026-01-10T09:00:00Z

emails = client.emails.list(page: 1, limit: 10)

emails.each do |email|
  puts "#{email.id} — #{email.status}"
end

if emails.has_more?
  # fetch next page
end

client.emails.cancel("em_abc123")
client.emails.retry("em_abc123")

# Create a domain
domain = client.domains.create(
  name: "example.com",
  track_loads: true,
  track_clicks: true
)
puts domain.id

# Verify DNS
domain = client.domains.verify("sd_123")

# List all domains
domains = client.domains.list

# Get a domain
domain = client.domains.get("sd_123")

# Update a domain
domain = client.domains.update("sd_123", track_clicks: false)

# Delete a domain
client.domains.delete("sd_123")

# Create an API key
key = client.api_keys.create(
  name: "Production Key",
  scope: "full"
)
puts key.key # only available on create

# List all API keys
keys = client.api_keys.list

# Get an API key
key = client.api_keys.get("ak_123")

# Update an API key
client.api_keys.update("ak_123", name: "Renamed Key")

# Delete an API key
client.api_keys.delete("ak_123")

# Create an audience
audience = client.audiences.create(name: "Newsletter")
puts audience.id
puts audience.token

# List audiences
audiences = client.audiences.list

# Get an audience
audience = client.audiences.get("aud_123")

# Update an audience
client.audiences.update("aud_123", name: "Updated Newsletter")

# Delete an audience
client.audiences.delete("aud_123")

# Add a subscriber
subscriber = client.subscribers.create("aud_123",
  email: "user@example.com",
  first_name: "John",
  last_name: "Doe"
)

# List subscribers in an audience
subscribers = client.subscribers.list("aud_123")

# Get a subscriber
subscriber = client.subscribers.get("aud_123", "sub_456")

# Update a subscriber
client.subscribers.update("aud_123", "sub_456", first_name: "Jane")

# Delete a subscriber
client.subscribers.delete("aud_123", "sub_456")

# Create a template
result = client.templates.create(
  name: "Welcome",
  subject: "Welcome!",
  html: "<h1>Hi {{name}}</h1>"
)

# List templates
templates = client.templates.list

# Get a template
template = client.templates.get("tem_123")

# Update a template
client.templates.update("tem_123", subject: "New Subject")

# Publish a template
client.templates.publish("tem_123")

# Delete a template
client.templates.delete("tem_123")

# Create a suppression
suppression = client.suppressions.create(
  email: "spam@example.com",
  type: "hard_bounce",
  reason: "Manual suppression"
)

# List suppressions
suppressions = client.suppressions.list

# Get a suppression
suppression = client.suppressions.get("sup_123")

# Update a suppression
client.suppressions.update("sup_123", reason: "Updated")

# Delete a suppression
client.suppressions.delete("sup_123")

result = client.email_verifications.verify(email: "test@example.com")

puts result.status # valid
puts result.score  # 0.95
puts result.risk   # low

# Create a verification list
list = client.email_verification_lists.create(
  name: "Marketing List Q1",
  emails: [
    "user1@example.com",
    "user2@example.com",
    "user3@example.com"
  ]
)
puts list.id     # evl_abc123...
puts list.status # pending

# List all verification lists
lists = client.email_verification_lists.list

# Get a verification list
list = client.email_verification_lists.get("evl_abc123")
puts list.stats["successful_verifications"]

# Get verification results
results = client.email_verification_lists.results("evl_abc123", page: 1, limit: 50)

results.each do |result|
  puts "#{result.email} — #{result.result}"
end

# Export results as XLSX
response = client.email_verification_lists.export("evl_abc123")
File.write("results.xlsx", response.body)

# Create a webhook
webhook = client.webhooks.create(
  name: "My Webhook",
  url: "https://example.com/hook",
  all_events: true,
  enabled: true
)
puts webhook.id

# List webhooks
webhooks = client.webhooks.list

# Get a webhook
webhook = client.webhooks.get("wh_123")

# Update a webhook
client.webhooks.update("wh_123", enabled: false)

# Delete a webhook
client.webhooks.delete("wh_123")

# Create a contact
contact = client.contacts.create(
  email: "user@example.com",
  first_name: "John",
  last_name: "Doe"
)
puts contact.id

# List contacts
contacts = client.contacts.list

# Get a contact
contact = client.contacts.get("con_123")

# Update a contact
client.contacts.update("con_123", first_name: "Jane")

# Delete a contact
client.contacts.delete("con_123")

# List events
events = client.events.list(type: "email.delivered")

events.each do |event|
  puts event.type
end

# Get an event
event = client.events.get("evt_123")
puts event.type
puts event.data["email_id"]

require "emailit"

raw_body = request.body.read
signature = request.headers["X-Emailit-Signature"]
timestamp = request.headers["X-Emailit-Timestamp"]
secret = "your_webhook_signing_secret"

begin
  event = Emailit::WebhookSignature.verify(raw_body, signature, timestamp, secret)

  # event is automatically typed based on the event type
  puts event.type     # e.g. "email.delivered"
  puts event.event_id # e.g. "evt_abc123"

  # Access the event data
  data = event.event_data

  case event
  when Emailit::Events::EmailDelivered
    handle_delivered(event)
  when Emailit::Events::EmailBounced
    handle_bounce(event)
  when Emailit::Events::ContactCreated
    handle_new_contact(event)
  else
    puts "Unhandled: #{event.type}"
  end
rescue Emailit::ApiError => e
  render plain: e.message, status: 401
end

# Skip replay check
event = Emailit::WebhookSignature.verify(raw_body, signature, timestamp, secret, tolerance: nil)

# Custom 10-minute tolerance
event = Emailit::WebhookSignature.verify(raw_body, signature, timestamp, secret, tolerance: 600)

case event
when Emailit::Events::EmailDelivered
  handle_delivered(event)
when Emailit::Events::EmailBounced
  handle_bounce(event)
when Emailit::Events::ContactCreated
  handle_new_contact(event)
else
  puts "Unhandled: #{event.type}"
end

# config/environments/production.rb
config.action_mailer.delivery_method = :emailit
config.action_mailer.emailit_settings = { api_key: ENV["EMAILIT_API_KEY"] }

class UserMailer < ApplicationMailer
  def welcome(user)
    @user = user
    mail(
      to: @user.email,
      subject: "Welcome to our app!"
    )
  end
end

# Send it
UserMailer.welcome(user).deliver_now
UserMailer.welcome(user).deliver_later

class NotificationMailer < ApplicationMailer
  def invoice(user, pdf_data)
    attachments["invoice.pdf"] = {
      mime_type: "application/pdf",
      content: pdf_data
    }

    mail(
      to: user.email,
      subject: "Your Invoice"
    )
  end
end

begin
  client.emails.send(
    from: "hello@yourdomain.com",
    to: "user@example.com",
    subject: "Hello",
    html: "<h1>Hi</h1>"
  )
rescue Emailit::AuthenticationError => e
  # Invalid API key (401)
rescue Emailit::InvalidRequestError => e
  # Bad request or not found (400, 404)
rescue Emailit::RateLimitError => e
  # Too many requests (429)
rescue Emailit::UnprocessableEntityError => e
  # Validation failed (422)
rescue Emailit::ConnectionError => e
  # Network error
rescue Emailit::ApiError => e
  # Any other API error
  puts e.http_status
  puts e.http_body
  puts e.json_body
end