Skip to main content
The Emails API allows you to configure email provider settings for transactional emails sent by Auth0, such as verification emails, password reset emails, and more.

​
Overview

Auth0 can send emails through:
  • Built-in Auth0 email provider (default)
  • Custom SMTP providers
  • Third-party email services (SendGrid, Mailgun, Mandrill, etc.)
Access the email provider configuration through: 
client.Management.Emails.Provider

​
Get Email Provider

Retrieves details of the email provider configuration. 
func (c *Client) Get(
    ctx context.Context,
    request *management.GetEmailProviderRequestParameters,
    opts ...option.RequestOption,
) (*management.GetEmailProviderResponseContent, error)
​
ctx
context.Context
required
Context for the request
​
request
*management.GetEmailProviderRequestParameters
Query parameters:
  • Fields - Fields to include or exclude
  • IncludeFields - Whether to include or exclude fields
​
opts
...option.RequestOption
Optional request options
​
provider
*management.GetEmailProviderResponseContent
Returns the email provider with properties:
  • Name - Provider name (e.g., “smtp”, “sendgrid”, “mailgun”)
  • Enabled - Whether the provider is enabled
  • DefaultFromAddress - Default from address
  • Credentials - Provider credentials (redacted)
  • Settings - Provider-specific settings

​
Example

import (
    "context"
    "fmt"
    "log"

    "github.com/auth0/go-auth0/v2/management"
)

provider, err := client.Management.Emails.Provider.Get(
    context.TODO(),
    &management.GetEmailProviderRequestParameters{},
)
if err != nil {
    log.Fatalf("Failed to get email provider: %v", err)
}

fmt.Printf("Provider: %s\n", provider.GetName())
fmt.Printf("Enabled: %v\n", provider.GetEnabled())
fmt.Printf("From: %s\n", provider.GetDefaultFromAddress())

​
Create Email Provider

Configures a new email provider. 
func (c *Client) Create(
    ctx context.Context,
    request *management.CreateEmailProviderRequestContent,
    opts ...option.RequestOption,
) (*management.CreateEmailProviderResponseContent, error)
​
ctx
context.Context
required
Context for the request
​
request
*management.CreateEmailProviderRequestContent
required
The email provider configuration:
  • Name - Provider name (required)
  • Enabled - Whether to enable the provider
  • DefaultFromAddress - Default from address
  • Credentials - Provider credentials
  • Settings - Provider-specific settings
​
opts
...option.RequestOption
Optional request options

​
Example: SendGrid Provider

provider := &management.CreateEmailProviderRequestContent{
    Name: "sendgrid",
    Enabled: management.Bool(true),
    DefaultFromAddress: "[email protected]",
    Credentials: &management.EmailProviderCredentials{
        APIKey: management.String("your-sendgrid-api-key"),
    },
}

created, err := client.Management.Emails.Provider.Create(context.TODO(), provider)
if err != nil {
    log.Fatalf("Failed to create email provider: %v", err)
}

fmt.Printf("Email provider configured: %s\n", created.GetName())

​
Example: SMTP Provider

provider := &management.CreateEmailProviderRequestContent{
    Name: "smtp",
    Enabled: management.Bool(true),
    DefaultFromAddress: "[email protected]",
    Credentials: &management.EmailProviderCredentials{
        SMTPHost: management.String("smtp.example.com"),
        SMTPPort: management.Int(587),
        SMTPUser: management.String("smtp-user"),
        SMTPPass: management.String("smtp-password"),
    },
    Settings: &management.EmailProviderSettings{
        Headers: map[string]interface{}{
            "X-Custom-Header": "value",
        },
    },
}

created, err := client.Management.Emails.Provider.Create(context.TODO(), provider)
if err != nil {
    log.Fatalf("Failed to create SMTP provider: %v", err)
}

​
Example: Mailgun Provider

provider := &management.CreateEmailProviderRequestContent{
    Name: "mailgun",
    Enabled: management.Bool(true),
    DefaultFromAddress: "[email protected]",
    Credentials: &management.EmailProviderCredentials{
        APIKey: management.String("your-mailgun-api-key"),
        Domain: management.String("mg.example.com"),
        Region: management.String("us"), // or "eu"
    },
}

created, err := client.Management.Emails.Provider.Create(context.TODO(), provider)
if err != nil {
    log.Fatalf("Failed to create Mailgun provider: %v", err)
}

​
Update Email Provider

Updates the email provider configuration. 
func (c *Client) Update(
    ctx context.Context,
    request *management.UpdateEmailProviderRequestContent,
    opts ...option.RequestOption,
) (*management.UpdateEmailProviderResponseContent, error)
​
ctx
context.Context
required
Context for the request
​
request
*management.UpdateEmailProviderRequestContent
required
The fields to update
​
opts
...option.RequestOption
Optional request options

​
Example

update := &management.UpdateEmailProviderRequestContent{
    Enabled: management.Bool(true),
    DefaultFromAddress: management.String("[email protected]"),
}

updated, err := client.Management.Emails.Provider.Update(context.TODO(), update)
if err != nil {
    log.Fatalf("Failed to update email provider: %v", err)
}

​
Delete Email Provider

Deletes the email provider configuration, reverting to the default Auth0 email provider. 
func (c *Client) Delete(
    ctx context.Context,
    opts ...option.RequestOption,
) error
​
ctx
context.Context
required
Context for the request
​
opts
...option.RequestOption
Optional request options

​
Example

err := client.Management.Emails.Provider.Delete(context.TODO())
if err != nil {
    log.Fatalf("Failed to delete email provider: %v", err)
}

fmt.Println("Reverted to default Auth0 email provider")

​
Supported Email Providers

​
SendGrid

Requires:
  • api_key - SendGrid API key

​
Mailgun

Requires:
  • api_key - Mailgun API key
  • domain - Mailgun domain
  • region - “us” or “eu” (optional)

​
Mandrill

Requires:
  • api_key - Mandrill API key

​
Amazon SES

Requires:
  • accessKeyId - AWS access key ID
  • secretAccessKey - AWS secret access key
  • region - AWS region

​
SparkPost

Requires:
  • api_key - SparkPost API key
  • region - “us” or “eu” (optional)

​
SMTP

Requires:
  • smtp_host - SMTP server hostname
  • smtp_port - SMTP server port
  • smtp_user - SMTP username
  • smtp_pass - SMTP password

​
Complete Example

package main

import (
    "context"
    "fmt"
    "log"
    "os"

    "github.com/auth0/go-auth0/v2/management"
)

func main() {
    client, err := management.New(
        context.TODO(),
        os.Getenv("AUTH0_DOMAIN"),
        management.WithClientCredentials(
            os.Getenv("AUTH0_CLIENT_ID"),
            os.Getenv("AUTH0_CLIENT_SECRET"),
        ),
    )
    if err != nil {
        log.Fatalf("Failed to create client: %v", err)
    }

    // Get current email provider
    current, err := client.Management.Emails.Provider.Get(
        context.TODO(),
        &management.GetEmailProviderRequestParameters{},
    )
    if err != nil {
        log.Printf("No email provider configured: %v", err)
    } else {
        fmt.Printf("Current provider: %s\n", current.GetName())
    }

    // Configure SendGrid as email provider
    provider := &management.CreateEmailProviderRequestContent{
        Name: "sendgrid",
        Enabled: management.Bool(true),
        DefaultFromAddress: "[email protected]",
        Credentials: &management.EmailProviderCredentials{
            APIKey: management.String(os.Getenv("SENDGRID_API_KEY")),
        },
    }

    created, err := client.Management.Emails.Provider.Create(context.TODO(), provider)
    if err != nil {
        log.Fatalf("Failed to configure email provider: %v", err)
    }

    fmt.Printf("Configured provider: %s\n", created.GetName())
    fmt.Printf("From address: %s\n", created.GetDefaultFromAddress())
}

​
Best Practices

  1. Use Dedicated Email Service - Configure a reliable third-party email provider for production
  2. Verify Domain - Ensure your from address domain is verified with your email provider
  3. Test Configuration - Send test emails after configuring a provider
  4. Monitor Delivery - Track email delivery rates and bounces
  5. Secure Credentials - Store API keys and credentials securely
  6. Configure SPF/DKIM - Set up proper email authentication to improve deliverability

Build docs developers (and LLMs) love

Get started for freeTalk to us