Email Notifications

Svix supports sending personalized email notifications to your customers when certain events occur with their webhooks setup. This is useful for keeping customers aware of webhook delivery issues that might affect their integrations.

Email notifications are sent per Consumer Application. For example, when an endpoint for a particular Application is disabled due to repeated failures, Svix will send an email to the configured email address for that application.

Setting up email notifications

Enable email notifications in your organization

To get started, you’ll need to enable email notifications for your organization. Head to the Email Notifications section of the Svix dashboard.

Configure your branding

Personalize the email notifications by adding:

Company name - The name of your company or service
Logo URL - A link to your company logo for branding
Webhooks management page URL - Where your customers can manage their webhook settings

Set the email address for each application

For each application that should receive email notifications, you’ll need to specify an email address. This is done by setting the svix.email field in the Application’s metadata.

You can set the email address when creating an application, or by updating an existing application’s metadata.

When creating an application


import { Svix } from "svix";
 
const svix = new Svix("AUTH_TOKEN");
const app = await svix.application.create({
  name: "Example customer 123",
  uid: "example-customer-123",
  metadata: {
    "svix.email": "example-customer-123@example.com"
  }
});


from svix.api import Svix, ApplicationIn
 
svix = Svix("AUTH_TOKEN")
app = svix.application.create(ApplicationIn(
    name="Example customer 123",
    uid="example-customer-123",
    metadata={
        "svix.email": "example-customer-123@example.com"
    }
))


use svix::api::{ApplicationIn, Svix, SvixOptions};
 
let svix = Svix::new("AUTH_TOKEN".to_string(), None);
let mut metadata = std::collections::HashMap::new();
metadata.insert("svix.email".to_string(), serde_json::Value::String("example-customer-123@example.com".to_string()));
 
let app = svix
    .application()
    .create(
        ApplicationIn {
            name: "Example customer 123".to_string(),
            uid: Some("example-customer-123".to_string()),
            metadata: Some(metadata),
            ..ApplicationIn::default()
        },
        None,
    )
    .await?;


import (
	svix "github.com/svix/svix-webhooks/go"
)
 
svixClient := svix.New("AUTH_TOKEN", nil)
metadata := map[string]interface{}{
    "svix.email": "example-customer-123@example.com",
}
app, err := svixClient.Application.Create(ctx, &svix.ApplicationIn{
    Name: "Example customer 123",
    Uid:  "example-customer-123",
    Metadata: &metadata,
})


import com.svix.models.ApplicationIn;
import com.svix.models.ApplicationOut;
import com.svix.Svix;
import java.util.HashMap;
import java.util.Map;
 
Svix svix = new Svix("AUTH_TOKEN");
Map<String, Object> metadata = new HashMap<>();
metadata.put("svix.email", "example-customer-123@example.com");
 
ApplicationOut app = svix.getApplication().create(
    new ApplicationIn().name("Example customer 123").uid("example-customer-123").metadata(metadata)
);


import com.svix.kotlin.models.ApplicationIn
import com.svix.kotlin.models.ApplicationOut
import com.svix.kotlin.Svix
 
val svix = Svix("AUTH_TOKEN")
val metadata = mapOf("svix.email" to "example-customer-123@example.com")
 
val applicationOut = svix.application.create(
    ApplicationIn(
        name = "Example customer 123",
        uid = "example-customer-123",
        metadata = metadata
    )
)


require "svix"
 
svix = Svix::Client.new("AUTH_TOKEN")
 
application_out = svix.application.create(Svix::ApplicationIn.new({
    "name" => "Example customer 123",
    "uid" => "example-customer-123",
    "metadata" => {
        "svix.email" => "example-customer-123@example.com"
    }
}))


var svix = new SvixClient("AUTH_TOKEN", new SvixOptions("https://api.us.svix.com"));
var metadata = new Dictionary<string, object>
{
    { "svix.email", "example-customer-123@example.com" }
};
 
var applicationOut = await svix.Application.CreateAsync(
    new ApplicationIn(name: "Example customer 123", uid: "example-customer-123", metadata: metadata)
);


$svix = new Svix('AUTH_TOKEN');
 
$metadata = [
    'svix.email' => 'example-customer-123@example.com'
];
 
$applicationOut = $svix->application->create(
  ApplicationIn::create(
    name: 'Example customer 123'
  )
  ->withUid('example-customer-123')
  ->withMetadata($metadata)
);


export SVIX_AUTH_TOKEN='AUTH_TOKEN'
svix application create '{
  "name": "Example customer 123",
  "uid": "example-customer-123",
  "metadata": {
    "svix.email": "example-customer-123@example.com"
  }
}'


export SVIX_AUTH_TOKEN='AUTH_TOKEN'
 
curl -X POST "https://api.us.svix.com/api/v1/app/" \
    -H  "Accept: application/json" \
    -H  "Content-Type: application/json" \
    -H  "Authorization: Bearer ${SVIX_AUTH_TOKEN}" \
    -d '{
      "name": "Example customer 123",
      "uid": "example-customer-123",
      "metadata": {
        "svix.email": "example-customer-123@example.com"
      }
    }'

Updating an existing application


import { Svix } from "svix";
 
const svix = new Svix("AUTH_TOKEN");
await svix.application.patch("example-customer-123", {
  metadata: {
    "svix.email": "example-customer-123@example.com"
  }
});


from svix.api import Svix
 
svix = Svix("AUTH_TOKEN")
svix.application.patch("example-customer-123", {
    "metadata": {
        "svix.email": "example-customer-123@example.com"
    }
})


let svix = Svix::new("AUTH_TOKEN".to_string(), None);
let mut metadata = std::collections::HashMap::new();
metadata.insert("svix.email".to_string(), serde_json::Value::String("example-customer-123@example.com".to_string()));
 
let app = svix
    .application()
    .patch(
        "example-customer-123".to_string(),
        ApplicationPatch {
            metadata: Some(metadata),
            ..ApplicationPatch::default()
        },
    )
    .await?;


import (
	svix "github.com/svix/svix-webhooks/go"
)
 
svixClient := svix.New("AUTH_TOKEN", nil)
metadata := map[string]interface{}{
    "svix.email": "example-customer-123@example.com",
}
app, err := svixClient.Application.Patch(ctx, "example-customer-123", &svix.ApplicationPatch{
    Metadata: &metadata,
})


import com.svix.Svix;
import com.svix.models.ApplicationPatch;
import java.util.HashMap;
import java.util.Map;
 
Svix svix = new Svix("AUTH_TOKEN");
Map<String, Object> metadata = new HashMap<>();
metadata.put("svix.email", "example-customer-123@example.com");
 
svix.getApplication()
  .patch("example-customer-123", new ApplicationPatch()
    .metadata(metadata)
  );


import com.svix.kotlin.Svix
import com.svix.kotlin.models.ApplicationPatch
 
val svix = Svix("AUTH_TOKEN")
val metadata = mapOf("svix.email" to "example-customer-123@example.com")
 
svix.application.patch("example-customer-123", ApplicationPatch(
    metadata = metadata
))


svix = Svix::Client.new("AUTH_TOKEN")
svix.application.patch("example-customer-123", Svix::ApplicationPatch.new({
    "metadata" => {
        "svix.email" => "example-customer-123@example.com"
    }
}))


var svix = new SvixClient("AUTH_TOKEN", new SvixOptions("https://api.us.svix.com"));
var metadata = new Dictionary<string, object>
{
    { "svix.email", "example-customer-123@example.com" }
};
 
await svix.Application.PatchAsync("example-customer-123", new ApplicationPatch(
    metadata: metadata
));


$svix = new Svix('AUTH_TOKEN');
 
$metadata = [
    'svix.email' => 'example-customer-123@example.com'
];
 
$svix->application->patch(
  'example-customer-123',
  ApplicationPatch::create()
  ->withMetadata($metadata)
);


export SVIX_AUTH_TOKEN='AUTH_TOKEN'
svix application patch 'example-customer-123' '{ "metadata": { "svix.email": "example-customer-123@example.com" } }'


export SVIX_AUTH_TOKEN='AUTH_TOKEN'
 
curl -X PATCH "https://api.us.svix.com/api/v1/app/example-customer-123/" \
    -H  "Accept: application/json" \
    -H  "Content-Type: application/json" \
    -H  "Authorization: Bearer ${SVIX_AUTH_TOKEN}" \
    -d '{ "metadata": { "svix.email": "example-customer-123@example.com" } }'

Redirecting to your webhooks management page

When the webhooks management page URL is included in emails, Svix adds svix_app_id as a query parameter, with the application ID as the value (or the UID if the application has one).

This can be used to redirect the user to the right page in your application, in cases where the URL varies per customer.

For example, if the webhooks management page URL in your site is app.example.com/webhooks/customer-123, set the webhooks management URL to app.example.com/webhooks. Then, in your application, add a redirect from /webhooks/?svix_app_id={APP_UID} to /webhooks/{APP_UID}.

An example email notification

Email notification example