Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/auth0/go-auth0/llms.txt

Use this file to discover all available pages before exploring further.

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: "noreply@example.com",
    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: "noreply@example.com",
    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: "noreply@example.com",
    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("no-reply@example.com"),
}

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: "noreply@example.com",
        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