Event Types

Each message sent through Svix has an associated event type. Event types are identifiers denoting the type of message being sent and are the primary way for webhook consumers to configure what events they are interested in receiving.

Event types are just a string, for example: user.signup, invoice.paid and workflow.completed.

Webhook consumers can choose which events are sent to which endpoint. By default, all messages are sent to all endpoints. Though when adding or editing endpoints, users can choose to only subscribe to some of the event types for this particular endpoint.

Bulk Create

It's recommended to add the event types you are going to use ahead of time. You can do it using the scripts in the bulk creating event types section.

What your users will see

This is how choosing event types look like in the pre-built application portal:

Event Type Format

Event types have a pattern defined a ^[a-zA-Z0-9\\-_.]+$, meaning it can contain any of the following characters:

• A through Z (uppercase or lowercase)
• 0 through 9
• Special characters: -, _, .

Style guide

We recommend you use period-delimited event type names (e.g. <group>.<event>). If you do, the App Portal UI will logically group them for your users and make it easier for them to subscribe an endpoint to all events in a particular group of event types.

Using event types

You can add, edit, and delete event types in the dashboard or through the API below.

JavaScript

import { Svix } from "svix";

const svix = new Svix("AUTH_TOKEN");
const eventType = await svix.eventType.create({
  name: "user.signup",
  description: "A user has signed up",
});

Python

from svix.api import Svix, EventTypeIn

svix = Svix("AUTH_TOKEN")
app = svix.event_type.create(EventTypeIn(
    name="user.signup",
    description="A user has signed up"
))

Rust

import (
    svix "github.com/svix/svix-webhooks/go"
)

svixClient := svix.New("AUTH_TOKEN", nil)
app, err := svixClient.EventType.Create(&svix.EventTypeIn{
    Name: "user.signup",
    Description: "A user has signed up",
})}

Go

use svix::api::{ApplicationIn, Svix, SvixOptions};

let svix = Svix::new("AUTH_TOKEN".to_string(), None);
let event_type = svix.event_type().create(EventTypeIn {
    name: "user.signup".to_string(),
    description: "A user has signed up".to_string(),
    ..EventTypeIn::default()
}).await?;

Java

import com.svix.Svix;
import com.svix.models.EventTypeIn;


Svix svix = new Svix("AUTH_TOKEN");
svix.getEventType()
  .create(new EventTypeIn()
    .name("user.signup")
    .description("A user has signed up")
  );

Kotlin

import com.svix.kotlin.Svix;
import com.svix.kotlin.models.EventTypeIn;

val svix = Svix("AUTH_TOKEN");
svix.eventType.create(
                EventTypeIn(
                    name = "user.signup",
                    description = "A user has signed up",
                ));

Ruby

svix = Svix::Client.new("AUTH_TOKEN")
svix.event_type.create(Svix::EventTypeIn.new({
        "name" => "user.signup",
        "description" => "A user has signed up"}))

C#

var svix = new SvixClient("AUTH_TOKEN", new SvixOptions("https://api.svix.com"));
await svix.EventType.CreateAsync(new EventTypeIn(
    name: "user.signup",
    description: "A user has signed up"
))

CLI

export SVIX_AUTH_TOKEN='AUTH_TOKEN'
svix event-type create '{ "name": "user.signup", "description": "A user has signed up" }'

cURL

export SVIX_AUTH_TOKEN='AUTH_TOKEN'

curl -X POST "https://api.svix.com/api/v1/event-type/" \
    -H  "Accept: application/json" \
    -H  "Content-Type: application/json" \
    -H  "Authorization: Bearer ${SVIX_AUTH_TOKEN}" \
    -d '{ "name": "user.signup", "description": "A user has signed up" }'

Event Type Schema

One of the best ways to help your users integrate with you is by defining schemas for your event types. Event type schemas allow your users to anticipate the shape of the message body they will receive as well as introduce guardrails for each data type.

Schemas can be created using our visual schema editor, or by providing your own JSONSchema (Draft 7) spec.

Once you have a schema defined, your users will be able to view the schema definition as well as an example event from the Event Catalog in the App Portal.

To learn more about creating schemas, check out our guide on adding your first event type schema.

Bulk creating event types

The easiest way to bulk-create event types is by just writing a simple script to load a pipe delimited CSV file or a JSON file with the event types and make the API requests.

Here is an example CSV file (without headers) of events:

user.created|A user has been created
user.removed|A user has been removed
user.changed|A user has changed

Here are some example scripts for processing the above file:

JavaScript

import { Svix } from "svix";
import fs from "fs";
import readline from "readline";

const svix = new Svix("AUTH_TOKEN");

async function execute() {
  const fileStream = fs.createReadStream("./data.csv");

  const data = readline.createInterface({
    input: fileStream,
    crlfDelay: Infinity,
  });

  for await (const lineItr of data) {
    const line = lineItr.split("|");
    const eventType = await svix.eventType.create({
      name: line[0],
      description: line[1],
    });
  }
}

execute();

Python

import json
from svix.api import Svix, EventTypeIn

svix = Svix("AUTH_TOKEN")

with open("./data.csv", "r") as f:
    for line in f:
        name, description = line.split("|")
        app = svix.event_type.create(EventTypeIn(
            name=name,
            description=description,
        ))

Rust

package main

import (
    "bufio"
    "log"
    "os"
    "strings"

    svix "github.com/svix/svix-webhooks/go"
)

func main() {
    svixClient := svix.New("AUTH_TOKEN", nil)

    f, err := os.Open("./data.csv")
    if err != nil {
        log.Fatal(err)
    }
    defer f.Close()

    scanner := bufio.NewScanner(f)
    for scanner.Scan() {
        line := strings.Split(scanner.Text(), "|")
        _, err = svixClient.EventType.Create(&svix.EventTypeIn{
            Name:        line[0],
            Description: line[1],
        })
        if err != nil {
            log.Println(err)
        }
    }
    if err := scanner.Err(); err != nil {
        log.Fatal(err)
    }
}

Go

// Example TBD
// Read the CSV and create event types

Java

package sviximport;

import java.io.FileReader;
import java.io.IOException;
import java.util.Scanner;
import com.svix.Svix;
import com.svix.models.EventTypeIn;
import com.svix.exceptions.ApiException;

public class App {

    public static void main(String[] args) {
        Svix svix = new Svix("AUTH_TOKEN");

        try (Scanner scanner = new Scanner(new FileReader("/path/to/data.csv"));) {
            while (scanner.hasNextLine()) {
                try {
                    String[] line = scanner.nextLine().split("|");
                    svix.getEventType().create(new EventTypeIn().name(line[0]).description(line[1]));
                } catch(ApiException e) {
                    if (e.getCode() != 409) {
                        System.out.println(e.getResponseBody());
                        System.exit(1);
                    }
                }
            }
        } catch(IOException e) {
            System.out.println(e.toString());
            System.exit(1);
        }
    }
}

Kotlin

package sviximport

import com.svix.kotlin.Svix
import com.svix.kotlin.models.EventTypeIn
import com.svix.kotlin.exceptions.ApiException
import java.io.File
import java.io.IOException
import kotlinx.coroutines.runBlocking
import kotlin.system.exitProcess

fun main() = runBlocking {
    val svix = Svix("AUTH_TOKEN")
    try {
        File("/path/to/data.csv").useLines { lines ->
            lines.forEach {
                try {
                    val line = it.split("|")
                    svix.eventType.create(EventTypeIn(
                        name = line[0],
                        description = line[1]
                    ))
                } catch (e: ApiException) {
                    println(e.message)
                    exitProcess(1)
                }
            }
        }
    } catch (e: IOException) {
        println(e.toString())
        exitProcess(1)
    }
}

Ruby

require "svix"
require "csv"

svix = Svix::Client.new("AUTH_TOKEN")

CSV.foreach('data.csv', {:col_sep => "|"}) do |line|
    event_type = svix.event_type.create(Svix::EventTypeIn.new({
        "name" => line[0],
        "description" => line[1]}))
end

C#

// Example TBD
// Read the CSV and create event types

CLI

export SVIX_AUTH_TOKEN='AUTH_TOKEN'

while IFS=$'|', read -r name description
do
    svix event-type create "{ \"name\": \"${name}\", \"description\": \"${description}\" }"
done < data.csv

cURL

export SVIX_AUTH_TOKEN='AUTH_TOKEN'

while IFS=$'|', read -r name description
do
    curl -X POST "https://api.svix.com/api/v1/event-type/" \
        -H  "Accept: application/json" \
        -H  "Content-Type: application/json" \
        -H  "Authorization: Bearer ${SVIX_AUTH_TOKEN}" \
        -d  "{ \"name\": \"${name}\", \"description\": \"${description}\" }"
done < data.csv

Publishing your Event Catalog

By default, your event types are only accessible to users from within an authenticated session on the Application Portal.

If you would like to have them publicly accessible, you can enable the "Make Publish" setting from the Event Catalog configuration screen in the Dashboard settings.

Enabling this setting will cause your event types to be statically served on svix.com. You can link or embed that site within your own documentation.

Configuration Options

• Make Public: Whether or not the Event Catalog will be publicly accessible from svix.com.
• Display Name: Required to make your Event Catalog public. The display name will be shown in the heading of the published page. It should be the name of your company or product.

What it looks like

Event type feature flags

When introducing new features in your application it can be useful to only expose them to a select set of users.

Event types can be hidden from users by setting a feature flag on them. If a feature flag is set on an event type users won't see the event type in the Event Catalog and the API, unless they have an authorization token that explicitly allows them.

A feature flag is an arbitrary string that you can set at event type creation time. You can also remove or add back the feature flag by updating an existing event type. Feature flags follow the same naming rules as the event type name itself: ^[a-zA-Z0-9\\-_.]+$.

Here's how you can create an event type with a feature flag:

JavaScript

import { Svix } from "svix";

const svix = new Svix("AUTH_TOKEN");
const eventType = await svix.eventType.create({
  name: "user.signup",
  description: "A user has signed up",
  featureFlag: "beta-feature-a",
});

Python

from svix.api import Svix, EventTypeIn

svix = Svix("AUTH_TOKEN")
app = svix.event_type.create(EventTypeIn(
    name="user.signup",
    description="A user has signed up",
    feature_flag="beta-feature-a"
))

Rust

import (
    svix "github.com/svix/svix-webhooks/go"
)

svixClient := svix.New("AUTH_TOKEN", nil)
app, err := svixClient.EventType.Create(&svix.EventTypeIn{
    Name: "user.signup",
    Description: "A user has signed up",
    FeatureFlag: svix.NullableStrig("beta-feature-a"),
})}

Go

use svix::api::{ApplicationIn, Svix, SvixOptions};

let svix = Svix::new("AUTH_TOKEN".to_string(), None);
let event_type = svix.event_type().create(EventTypeIn {
    name: "user.signup".to_string(),
    description: "A user has signed up".to_string(),
    feature_flag: Some("beta-feature-a".to_string()),
    ..EventTypeIn::default()
}).await?;

Java

import com.svix.Svix;
import com.svix.models.EventTypeIn;


Svix svix = new Svix("AUTH_TOKEN");
svix.getEventType()
  .create(new EventTypeIn()
    .name("user.signup")
    .description("A user has signed up")
    .featureFlag("beta-feature-a")
  );

Kotlin

import com.svix.kotlin.Svix;
import com.svix.kotlin.models.EventTypeIn;

val svix = Svix("AUTH_TOKEN");
svix.eventType.create(
                EventTypeIn(
                    name = "user.signup",
                    description = "A user has signed up",
                    featureFlag = "beta-feature-a",
                ));

Ruby

svix = Svix::Client.new("AUTH_TOKEN")
svix.event_type.create(Svix::EventTypeIn.new({
        "name" => "user.signup",
        "description" => "A user has signed up",
        "feature_flag": "beta-feature-a"}))

C#

var svix = new SvixClient("AUTH_TOKEN", new SvixOptions("https://api.svix.com"));
await svix.EventType.CreateAsync(new EventTypeIn(
    name: "user.signup",
    description: "A user has signed up",
    featureFlag: "beta-feature-a"
))

CLI

export SVIX_AUTH_TOKEN='AUTH_TOKEN'
svix event-type create '{ "name": "user.signup", "description": "A user has signed up", "featureFlag": "beta-feature-a" }'

cURL

export SVIX_AUTH_TOKEN='AUTH_TOKEN'

curl -X POST "https://api.svix.com/api/v1/event-type/" \
    -H  "Accept: application/json" \
    -H  "Content-Type: application/json" \
    -H  "Authorization: Bearer ${SVIX_AUTH_TOKEN}" \
    -d '{ "name": "user.signup", "description": "A user has signed up", "featureFlag": "beta-feature-a" }'

If a user tries to retrieve this newly created event type they will get a not-found error. To give them access you need to give them an access token that explicity allows them to see event types with the feature flag set during creation.

JavaScript

const svix = new Svix("AUTH_TOKEN");
const dashboard = await svix.authentication.appPortalAccess("app_Xzx8bQeOB1D1XEYmAJaRGoj0", {
    featureFlags: ["beta-feature-a"]
});
// A URL that automatically logs user into the dashboard
console.log(dashboard.url);

Python

svix = Svix("AUTH_TOKEN")
dashboard = svix.authentication.app_portal_access("app_Xzx8bQeOB1D1XEYmAJaRGoj0", AppPortalAccessIn(
    feature_flags=["beta-feature-a"]
))
# A URL that automatically logs user into the dashboard
print(dashboard.url)

Rust

svixClient := svix.New("AUTH_TOKEN", nil)
dashboard, _ := svixClient.Authentication.AppPortalAccess("app_Xzx8bQeOB1D1XEYmAJaRGoj0", &svix.AppPortalAccessIn{
    FeatureFlags: []string{"beta-feature-a"}
})
// A URL that automatically logs user into the dashboard
fmt.Println(dashboard.Url)

Go

let svix = Svix::new("AUTH_TOKEN".to_string(), None);
let dashboard = svix.authentication().app_portal_access(
    "app_Xzx8bQeOB1D1XEYmAJaRGoj0".to_string(),
    AppPortalAccessIn { 
        feature_flags: Some(vec!["beta-feature-a".to_string()]),
        .. Default::default() 
    }
}).await?;
// A URL that automatically logs user into the dashboard
println!("{}", dashboard.url);

Java

Svix svix = new Svix("AUTH_TOKEN");
AppPortalAccessOut dashboard = svix.getAuthentication().appPortalAccess("app_Xzx8bQeOB1D1XEYmAJaRGoj0", new AppPortalAccessIn()
    .featureFlags(new String[]{"beta-feature-a"})
);
// A URL that automatically logs user into the dashboard
System.out.println(dashboard.getUrl());

Kotlin

val svix = Svix("AUTH_TOKEN")
val dashboard = svix.authentication.appPortalAccess("app_Xzx8bQeOB1D1XEYmAJaRGoj0", AppPortalAccessIn()
    .featureFlags(arrayOf("beta-feature-a"))
)
// A URL that automatically logs user into the dashboard
println(dashboard.url)

Ruby

svix = Svix::Client.new("AUTH_TOKEN")
dashboard = svix.authentication.app_portal_access("app_Xzx8bQeOB1D1XEYmAJaRGoj0", Svix::AppPortalAccessIn.new({
    "feature_flags": ["beta-feature-a"]
}))
# A URL that automatically logs user into the dashboard
puts dashboard.url

C#

var svix = new SvixClient("AUTH_TOKEN", new SvixOptions("https://api.svix.com"));
var dashboard = await svix.Authentication.AppPortalAccessAsync("app_Xzx8bQeOB1D1XEYmAJaRGoj0", new AppPortalAccessIn{
    featureFlags: new string[] {"beta-feature-a"}
});
// A URL that automatically logs user into the dashboard
Console.WriteLine(dashboard.Url)

CLI

export SVIX_AUTH_TOKEN="AUTH_TOKEN"
svix authentication app-portal app_Xzx8bQeOB1D1XEYmAJaRGoj0 '{
    "featureFlags": ["beta-feature-a"]
}'

cURL

curl -X POST "https://api.svix.com/api/v1/auth/app-portal-access/app_Xzx8bQeOB1D1XEYmAJaRGoj0/" \
    -H  "Accept: application/json" \
    -H  "Authorization:  Bearer AUTH_TOKEN" \
    -H 'Content-Type: application/json' \
    -d '{"featureFlags": ["beta-feature-a"]}'

A user with this newly minted dashboard access token will be able to see this new event type.

Once you're ready to release this new event type to all of your users simply remove the feature flag from it.

JavaScript

const svix = new Svix("AUTH_TOKEN");
await svix.eventType.update("user.signup", { featureFlag: null });

Python

svix = Svix("AUTH_TOKEN")
svix.event_type.update("user.signup", EventTypeUpdate(feature_flag=None))

Rust

svixClient := svix.New("AUTH_TOKEN", nil)
eventTypeOut, _ := svixClient.EventType.Update("user.signup", &svix.EventTypeUpdate{ FeatureFlag: nil })

Go

let svix = Svix::new("AUTH_TOKEN".to_string(), None);
let event_type_out = svix.event_type().update(
    "user.signup".to_string(),
    EventTypeUpdate { 
        feature_flag: None,
        .. Default::default() 
    }
}).await?;

Java

Svix svix = new Svix("AUTH_TOKEN");
EventTypeOut eventTypeOut = svix.getEventType().update("user.signup", new EventTypeUpdate()
    .featureFlag(null)
);

Kotlin

val svix = Svix("AUTH_TOKEN")
val eventTypeOut = svix.eventType.update("user.signup", EventTypeUpdate().featureFlag(null))

Ruby

svix = Svix::Client.new("AUTH_TOKEN")
event_type_out = svix.event_type.update("user.signup", Svix::EventTypeUpdate.new({
    "feature_flag": nil
}))

C#

var svix = new SvixClient("AUTH_TOKEN", new SvixOptions("https://api.svix.com"));
var eventTypeOut = await svix.EventType.Update("user.signup", new EventTypeUpdate{
    featureFlag: null
});

CLI

export SVIX_AUTH_TOKEN="AUTH_TOKEN"
svix event-type update user.signup '{"featureFlag": null}'

cURL

curl -X POST "https://api.svix.com/api/v1/event-type/user.signup/" \
    -H  "Accept: application/json" \
    -H  "Authorization:  Bearer AUTH_TOKEN" \
    -H 'Content-Type: application/json' \
    -d '{"featureFlag": null}'

Important

Keep in mind that endpoints with no event type filtering will receive all messages regardless of feature flags. Also, users with knowledge of a feature flag-gated event type can subscribe to that event type regardless of feature flags. Feature flags only impact event types' visibility in the catalog and the API, not their deliverability.