# Verify Events Onboarding Guide

> \[!NOTE]
>
> This Verify feature is currently in the Pilot maturity stage, which means that we're actively looking for early-adopter customers to try it out and give feedback. That could be you.
>
> Onboarding is now a self-serve process, follow this guide a step-by-step walkthrough.
>
> Verify Events currently only supports **SMS**, **WhatsApp**, **RCS**, and **Voice** channels.

[Verify Events](/docs/verify/verify-events) allows you to access instantaneous, real-time information on the activity of your Verify Service by subscribing to a stream of Verify interactions.

In this guide we'll walk through the webhook onboarding process and explain the different methods you can use to integrate with Verify Events.

Not using a webhook? For more information on integrating using Amazon Kinesis, see [Twilio Event Streams Kinesis Quickstart](/docs/events/eventstreams-quickstart).

Click on the link to jump to that onboarding method:

* [Twilio Console](#onboarding-with-twilio-console)
* [Events Streams API](#onboarding-with-event-streams-api)

## Onboarding with Twilio Console

Twilio Console allows you to onboard completely within the Console itself, no code or command line required.

### Step 1: Setup

First, you'll need to enable Verify Events in your [Twilio Console](https://console.twilio.com) by navigating to the [Twilio Console > Verify > Services](https://console.twilio.com/us1/develop/verify/services) page
and selecting your Service. This will open the **Service settings** page where you can select the **General** tab and turn on the **Verify Events Subscribed service** option for that Service.

Next, if you haven't used Event Streams before, you'll want to pin it to your [Twilio Console](https://console.twilio.com/develop/explore) so it's easily accessible. Navigate to the [Twilio Console > Explore Products](https://console.twilio.com/develop/explore) page. In the **Developer tools** product section, select the pin icon next to **Event Streams** to keep it pinned to your sidebar.

### Step 2: Configure and create a sink

Now let's create a new sink! A sink is the destination where events will be delivered.

Navigate to the [Twilio Console > Event Streams > Manage](https://console.twilio.com/us1/develop/event-streams/sinks) page and select **Create new sink**.

Give your sink a description. This should be a recognizable, human-readable name to help you identify the sink easily such as `verify-events-webhook-sink`.

Next, select your sink type. In this guide we'll be setting up the webhook sink type.

Before finalizing the sink's creation, you'll need to provide some additional details and configuration information. We recommend setting **Batch** to **False** so you can handle and process each event individually.

### Step 3: (Optional) Validate sink connection

Once your sink is created, you'll be prompted to validate your sink connection.

You can **optionally** validate the webhook sink connection before proceeding. Validating the connection will trigger a send of a test event to your webhook endpoint URL. Once your webhook endpoint receives the test, submit the test event ID from the event's request body to complete the validation.

### Step 4: Configure and create a subscription

To finish up, we need to create a subscription for your sink. A subscription defines which events will be sent to your sink.

Navigate to the [Twilio Console > Event Streams > Manage](https://console.twilio.com/us1/develop/event-streams/sinks) page, select **Create** and choose **New subscription**.

When you reach the **Select event types for this subscription** section, select **Verify** under the **Product groups** menu.

You can subscribe to one or more event types. Select all the events that you would like streamed to your sink destination by choosing their schema version (schema version 1 is the oldest). [Read more about each Verify event type here](/docs/verify/verify-events).

![Verify event subscription page with actions like Approved, Canceled, and Pending.](https://docs-resources.prod.twilio.com/acb94305948ae1a23806dbccbb0628b712ce39ddb64db8d14b8af50a6850f5f8.png)

That's it! Once the subscription is created, Verify events will start flowing into your webhook application when they occur.

## Onboarding with Event Streams API

This onboarding experience involves making calls to the Twilio Event Streams API using a Twilio SDK, twilio-cli, or cURL.

### Step 1: Setup \[#step-1--setup-2]

Note your Twilio Account SID and Auth Token from the [Console](https://console.twilio.com/), these will both be used to authenticate your calls.

### Step 2: Configure and create a sink \[#step-2--configure-and-create-a-sink-2]

Now we'll need to configure and create a sink using the [Twilio Event Streams Sink API](/docs/events/event-streams/sink-resource). A sink is the destination where events will be delivered.

Create a New Sink

```js
// Download the helper library from https://www.twilio.com/docs/node/install
const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";

// Find your Account SID and Auth Token at twilio.com/console
// and set the environment variables. See http://twil.io/secure
const accountSid = process.env.TWILIO_ACCOUNT_SID;
const authToken = process.env.TWILIO_AUTH_TOKEN;
const client = twilio(accountSid, authToken);

async function createSink() {
  const sink = await client.events.v1.sinks.create({
    description: "My Verify Events Webhook Sink",
    sinkConfiguration: {
      destination: "https://configureyourWebhookURLhere.com",
      method: "POST",
      batch_events: false,
    },
    sinkType: "webhook",
  });

  console.log(sink.dateCreated);
}

createSink();
```

```python
# Download the helper library from https://www.twilio.com/docs/python/install
import os
from twilio.rest import Client

# Find your Account SID and Auth Token at twilio.com/console
# and set the environment variables. See http://twil.io/secure
account_sid = os.environ["TWILIO_ACCOUNT_SID"]
auth_token = os.environ["TWILIO_AUTH_TOKEN"]
client = Client(account_sid, auth_token)

sink = client.events.v1.sinks.create(
    description="My Verify Events Webhook Sink",
    sink_type="webhook",
    sink_configuration={
        "destination": "https://configureyourWebhookURLhere.com",
        "method": "POST",
        "batch_events": False,
    },
)

print(sink.date_created)
```

```csharp
// Install the C# / .NET helper library from twilio.com/docs/csharp/install

using System;
using Twilio;
using Twilio.Rest.Events.V1;
using System.Threading.Tasks;
using System.Collections.Generic;

class Program {
    public static async Task Main(string[] args) {
        // Find your Account SID and Auth Token at twilio.com/console
        // and set the environment variables. See http://twil.io/secure
        string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");
        string authToken = Environment.GetEnvironmentVariable("TWILIO_AUTH_TOKEN");

        TwilioClient.Init(accountSid, authToken);

        var sink = await SinkResource.CreateAsync(
            description: "My Verify Events Webhook Sink",
            sinkType: SinkResource.SinkTypeEnum.Webhook,
            sinkConfiguration: new Dictionary<string, Object>() {
                { "destination", "https://configureyourWebhookURLhere.com" },
                { "method", "POST" },
                { "batch_events", false }
            });

        Console.WriteLine(sink.DateCreated);
    }
}
```

```java
// Install the Java helper library from twilio.com/docs/java/install

import java.util.HashMap;
import com.twilio.Twilio;
import com.twilio.rest.events.v1.Sink;

public class Example {
    // Find your Account SID and Auth Token at twilio.com/console
    // and set the environment variables. See http://twil.io/secure
    public static final String ACCOUNT_SID = System.getenv("TWILIO_ACCOUNT_SID");
    public static final String AUTH_TOKEN = System.getenv("TWILIO_AUTH_TOKEN");

    public static void main(String[] args) {
        Twilio.init(ACCOUNT_SID, AUTH_TOKEN);
        Sink sink = Sink.creator("My Verify Events Webhook Sink", new HashMap<String, Object>() {
                            {
                                put("destination", "https://configureyourWebhookURLhere.com");
                                put("method", "POST");
                                put("batch_events", false);
                            }
                        }, Sink.SinkType.WEBHOOK).create();

        System.out.println(sink.getDateCreated());
    }
}
```

```go
// Download the helper library from https://www.twilio.com/docs/go/install
package main

import (
	"fmt"
	"github.com/twilio/twilio-go"
	events "github.com/twilio/twilio-go/rest/events/v1"
	"os"
)

func main() {
	// Find your Account SID and Auth Token at twilio.com/console
	// and set the environment variables. See http://twil.io/secure
	// Make sure TWILIO_ACCOUNT_SID and TWILIO_AUTH_TOKEN exists in your environment
	client := twilio.NewRestClient()

	params := &events.CreateSinkParams{}
	params.SetDescription("My Verify Events Webhook Sink")
	params.SetSinkType("webhook")
	params.SetSinkConfiguration(map[string]interface{}{
		"destination":  "https://configureyourWebhookURLhere.com",
		"method":       "POST",
		"batch_events": false,
	})

	resp, err := client.EventsV1.CreateSink(params)
	if err != nil {
		fmt.Println(err.Error())
		os.Exit(1)
	} else {
		if resp.DateCreated != nil {
			fmt.Println(*resp.DateCreated)
		} else {
			fmt.Println(resp.DateCreated)
		}
	}
}
```

```php
<?php

// Update the path below to your autoload.php,
// see https://getcomposer.org/doc/01-basic-usage.md
require_once "/path/to/vendor/autoload.php";

use Twilio\Rest\Client;

// Find your Account SID and Auth Token at twilio.com/console
// and set the environment variables. See http://twil.io/secure
$sid = getenv("TWILIO_ACCOUNT_SID");
$token = getenv("TWILIO_AUTH_TOKEN");
$twilio = new Client($sid, $token);

$sink = $twilio->events->v1->sinks->create(
    "My Verify Events Webhook Sink", // Description
    [
        "destination" => "https://configureyourWebhookURLhere.com",
        "method" => "POST",
        "batch_events" => false,
    ], // SinkConfiguration
    "webhook" // SinkType
);

print $sink->dateCreated?->format("r");
```

```ruby
# Download the helper library from https://www.twilio.com/docs/ruby/install
require 'twilio-ruby'

# Find your Account SID and Auth Token at twilio.com/console
# and set the environment variables. See http://twil.io/secure
account_sid = ENV['TWILIO_ACCOUNT_SID']
auth_token = ENV['TWILIO_AUTH_TOKEN']
@client = Twilio::REST::Client.new(account_sid, auth_token)

sink = @client
       .events
       .v1
       .sinks
       .create(
         description: 'My Verify Events Webhook Sink',
         sink_type: 'webhook',
         sink_configuration: {
           'destination' => 'https://configureyourWebhookURLhere.com',
           'method' => 'POST',
           'batch_events' => false
         }
       )

puts sink.date_created
```

```bash
# Install the twilio-cli from https://twil.io/cli

twilio api:events:v1:sinks:create \
   --description "My Verify Events Webhook Sink" \
   --sink-type webhook \
   --sink-configuration "{\"destination\":\"https://configureyourWebhookURLhere.com\",\"method\":\"POST\",\"batch_events\":false}"
```

```bash
SINK_CONFIGURATION_OBJ=$(cat << EOF
{
  "destination": "https://configureyourWebhookURLhere.com",
  "method": "POST",
  "batch_events": false
}
EOF
)
curl -X POST "https://events.twilio.com/v1/Sinks" \
--data-urlencode "Description=My Verify Events Webhook Sink" \
--data-urlencode "SinkType=webhook" \
--data-urlencode "SinkConfiguration=$SINK_CONFIGURATION_OBJ" \
-u $TWILIO_ACCOUNT_SID:$TWILIO_AUTH_TOKEN
```

```json
{
  "status": "initialized",
  "sink_configuration": {
    "destination": "https://configureyourWebhookURLhere.com",
    "method": "POST",
    "batch_events": false
  },
  "description": "My Verify Events Webhook Sink",
  "sid": "DGaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
  "date_created": "2015-07-30T20:00:00Z",
  "sink_type": "webhook",
  "date_updated": "2015-07-30T20:00:00Z",
  "url": "https://events.twilio.com/v1/Sinks/DGaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
  "links": {
    "sink_test": "https://events.twilio.com/v1/Sinks/DGaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Test",
    "sink_validate": "https://events.twilio.com/v1/Sinks/DGaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Validate"
  }
}
```

Make a note of the new sink's `sid` included in the response, it will be in the format `DGXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX`. You will use this information when you create a subscription in a later step.

### Step 3: Explore Verify event schemas

The schema of an event defines how its information is organized. You can inspect the schema to explore the fields of an event type before using it, or use it to validate that the events you receive match their published schemas in production.

In this call, we're getting the version 1 schema of all available Verify events:

```bash
curl -X GET https://events-schemas.twilio.com/AccountSecurity.VerifyEventStreamEvent/1
```

### Step 4: Configure and create a subscription \[#step-4--configure-and-create-a-subscription-2]

Lastly, we need to create a subscription for your sink using the [Twilio Event Streams Subscription API](/docs/events/event-streams/subscription). A subscription defines which events will be sent to your sink.

Replace the `SinkSid` variable with your sink's SID. You can subscribe to one or more event types in a single subscription, [check out the available Verify event types here](/docs/verify/verify-events). In this example, we'll subscribe to five different Verify event types.

Create a New Subscription

```js
// Download the helper library from https://www.twilio.com/docs/node/install
const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";

// Find your Account SID and Auth Token at twilio.com/console
// and set the environment variables. See http://twil.io/secure
const accountSid = process.env.TWILIO_ACCOUNT_SID;
const authToken = process.env.TWILIO_AUTH_TOKEN;
const client = twilio(accountSid, authToken);

async function createSubscription() {
  const subscription = await client.events.v1.subscriptions.create({
    description: "My Verify Events Webhook Subscription",
    sinkSid: "DGXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
    types: [
      {
        type: "com.twilio.accountsecurity.verify.verification.approved",
      },
      {
        type: "com.twilio.accountsecurity.verify.verification.pending",
      },
      {
        type: "com.twilio.accountsecurity.verify.verification.canceled",
      },
      {
        type: "com.twilio.accountsecurity.verify.verification.expired",
      },
      {
        type: "com.twilio.accountsecurity.verify.verification.max-attempts-reached",
      },
    ],
  });

  console.log(subscription.accountSid);
}

createSubscription();
```

```python
# Download the helper library from https://www.twilio.com/docs/python/install
import os
from twilio.rest import Client

# Find your Account SID and Auth Token at twilio.com/console
# and set the environment variables. See http://twil.io/secure
account_sid = os.environ["TWILIO_ACCOUNT_SID"]
auth_token = os.environ["TWILIO_AUTH_TOKEN"]
client = Client(account_sid, auth_token)

subscription = client.events.v1.subscriptions.create(
    types=[
        {"type": "com.twilio.accountsecurity.verify.verification.approved"},
        {"type": "com.twilio.accountsecurity.verify.verification.pending"},
        {"type": "com.twilio.accountsecurity.verify.verification.canceled"},
        {"type": "com.twilio.accountsecurity.verify.verification.expired"},
        {
            "type": "com.twilio.accountsecurity.verify.verification.max-attempts-reached"
        },
    ],
    description="My Verify Events Webhook Subscription",
    sink_sid="DGXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
)

print(subscription.account_sid)
```

```csharp
// Install the C# / .NET helper library from twilio.com/docs/csharp/install

using System;
using Twilio;
using Twilio.Rest.Events.V1;
using System.Threading.Tasks;
using System.Collections.Generic;

class Program {
    public static async Task Main(string[] args) {
        // Find your Account SID and Auth Token at twilio.com/console
        // and set the environment variables. See http://twil.io/secure
        string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");
        string authToken = Environment.GetEnvironmentVariable("TWILIO_AUTH_TOKEN");

        TwilioClient.Init(accountSid, authToken);

        var subscription = await
                               SubscriptionResource
                                   .CreateAsync(
                                       types: new List<Object> { new Dictionary<string, Object>() { { "type", "com.twilio.accountsecurity.verify.verification.approved" } }, new Dictionary<string, Object>() { { "type", "com.twilio.accountsecurity.verify.verification.pending" } }, new Dictionary<string, Object>() { { "type", "com.twilio.accountsecurity.verify.verification.canceled" } }, new Dictionary<string, Object>() { { "type", "com.twilio.accountsecurity.verify.verification.expired" } }, new Dictionary<string, Object>() { { "type", "com.twilio.accountsecurity.verify.verification.max-attempts-reached" } } },
                                       description: "My Verify Events Webhook Subscription",
                                       sinkSid: "DGXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");

        Console.WriteLine(subscription.AccountSid);
    }
}
```

```java
// Install the Java helper library from twilio.com/docs/java/install

import java.util.Arrays;
import java.util.HashMap;
import com.twilio.Twilio;
import com.twilio.rest.events.v1.Subscription;

public class Example {
    // Find your Account SID and Auth Token at twilio.com/console
    // and set the environment variables. See http://twil.io/secure
    public static final String ACCOUNT_SID = System.getenv("TWILIO_ACCOUNT_SID");
    public static final String AUTH_TOKEN = System.getenv("TWILIO_AUTH_TOKEN");

    public static void main(String[] args) {
        Twilio.init(ACCOUNT_SID, AUTH_TOKEN);
        Subscription subscription =
            Subscription
                .creator("My Verify Events Webhook Subscription",
                    "DGXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
                    Arrays.asList(
                        new HashMap<String, Object>() {
                            {
                                put("type", "com.twilio.accountsecurity.verify.verification.approved");
                            }
                        },
                        new HashMap<String, Object>() {
                            {
                                put("type", "com.twilio.accountsecurity.verify.verification.pending");
                            }
                        },
                        new HashMap<String, Object>() {
                            {
                                put("type", "com.twilio.accountsecurity.verify.verification.canceled");
                            }
                        },
                        new HashMap<String, Object>() {
                            {
                                put("type", "com.twilio.accountsecurity.verify.verification.expired");
                            }
                        },
                        new HashMap<String, Object>() {
                            {
                                put("type", "com.twilio.accountsecurity.verify.verification.max-attempts-reached");
                            }
                        }))
                .create();

        System.out.println(subscription.getAccountSid());
    }
}
```

```go
// Download the helper library from https://www.twilio.com/docs/go/install
package main

import (
	"fmt"
	"github.com/twilio/twilio-go"
	events "github.com/twilio/twilio-go/rest/events/v1"
	"os"
)

func main() {
	// Find your Account SID and Auth Token at twilio.com/console
	// and set the environment variables. See http://twil.io/secure
	// Make sure TWILIO_ACCOUNT_SID and TWILIO_AUTH_TOKEN exists in your environment
	client := twilio.NewRestClient()

	params := &events.CreateSubscriptionParams{}
	params.SetTypes([]interface{}{
		map[string]interface{}{
			"type": "com.twilio.accountsecurity.verify.verification.approved",
		},
		map[string]interface{}{
			"type": "com.twilio.accountsecurity.verify.verification.pending",
		},
		map[string]interface{}{
			"type": "com.twilio.accountsecurity.verify.verification.canceled",
		},
		map[string]interface{}{
			"type": "com.twilio.accountsecurity.verify.verification.expired",
		},
		map[string]interface{}{
			"type": "com.twilio.accountsecurity.verify.verification.max-attempts-reached",
		},
	})
	params.SetDescription("My Verify Events Webhook Subscription")
	params.SetSinkSid("DGXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")

	resp, err := client.EventsV1.CreateSubscription(params)
	if err != nil {
		fmt.Println(err.Error())
		os.Exit(1)
	} else {
		if resp.AccountSid != nil {
			fmt.Println(*resp.AccountSid)
		} else {
			fmt.Println(resp.AccountSid)
		}
	}
}
```

```php
<?php

// Update the path below to your autoload.php,
// see https://getcomposer.org/doc/01-basic-usage.md
require_once "/path/to/vendor/autoload.php";

use Twilio\Rest\Client;

// Find your Account SID and Auth Token at twilio.com/console
// and set the environment variables. See http://twil.io/secure
$sid = getenv("TWILIO_ACCOUNT_SID");
$token = getenv("TWILIO_AUTH_TOKEN");
$twilio = new Client($sid, $token);

$subscription = $twilio->events->v1->subscriptions->create(
    "My Verify Events Webhook Subscription", // Description
    "DGXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", // SinkSid
    [
        [
            "type" => "com.twilio.accountsecurity.verify.verification.approved",
        ],
        [
            "type" => "com.twilio.accountsecurity.verify.verification.pending",
        ],
        [
            "type" => "com.twilio.accountsecurity.verify.verification.canceled",
        ],
        [
            "type" => "com.twilio.accountsecurity.verify.verification.expired",
        ],
        [
            "type" =>
                "com.twilio.accountsecurity.verify.verification.max-attempts-reached",
        ],
    ] // Types
);

print $subscription->accountSid;
```

```ruby
# Download the helper library from https://www.twilio.com/docs/ruby/install
require 'twilio-ruby'

# Find your Account SID and Auth Token at twilio.com/console
# and set the environment variables. See http://twil.io/secure
account_sid = ENV['TWILIO_ACCOUNT_SID']
auth_token = ENV['TWILIO_AUTH_TOKEN']
@client = Twilio::REST::Client.new(account_sid, auth_token)

subscription = @client
               .events
               .v1
               .subscriptions
               .create(
                 types: [
                   {
                     'type' => 'com.twilio.accountsecurity.verify.verification.approved'
                   },
                   {
                     'type' => 'com.twilio.accountsecurity.verify.verification.pending'
                   },
                   {
                     'type' => 'com.twilio.accountsecurity.verify.verification.canceled'
                   },
                   {
                     'type' => 'com.twilio.accountsecurity.verify.verification.expired'
                   },
                   {
                     'type' => 'com.twilio.accountsecurity.verify.verification.max-attempts-reached'
                   }
                 ],
                 description: 'My Verify Events Webhook Subscription',
                 sink_sid: 'DGXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
               )

puts subscription.account_sid
```

```bash
# Install the twilio-cli from https://twil.io/cli

twilio api:events:v1:subscriptions:create \
   --types "{\"type\":\"com.twilio.accountsecurity.verify.verification.approved\"}" "{\"type\":\"com.twilio.accountsecurity.verify.verification.pending\"}" "{\"type\":\"com.twilio.accountsecurity.verify.verification.canceled\"}" "{\"type\":\"com.twilio.accountsecurity.verify.verification.expired\"}" "{\"type\":\"com.twilio.accountsecurity.verify.verification.max-attempts-reached\"}" \
   --description "My Verify Events Webhook Subscription" \
   --sink-sid DGXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
```

```bash
curl -X POST "https://events.twilio.com/v1/Subscriptions" \
--data-urlencode "Types={\"type\":\"com.twilio.accountsecurity.verify.verification.approved\"}" \
--data-urlencode "Types={\"type\":\"com.twilio.accountsecurity.verify.verification.pending\"}" \
--data-urlencode "Types={\"type\":\"com.twilio.accountsecurity.verify.verification.canceled\"}" \
--data-urlencode "Types={\"type\":\"com.twilio.accountsecurity.verify.verification.expired\"}" \
--data-urlencode "Types={\"type\":\"com.twilio.accountsecurity.verify.verification.max-attempts-reached\"}" \
--data-urlencode "Description=My Verify Events Webhook Subscription" \
--data-urlencode "SinkSid=DGXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" \
-u $TWILIO_ACCOUNT_SID:$TWILIO_AUTH_TOKEN
```

```json
{
  "account_sid": "ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
  "date_created": "2015-07-30T20:00:00Z",
  "date_updated": "2015-07-30T20:01:33Z",
  "sid": "DFaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
  "sink_sid": "DGXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
  "description": "My Verify Events Webhook Subscription",
  "url": "https://events.twilio.com/v1/Subscriptions/DFaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
  "links": {
    "subscribed_events": "https://events.twilio.com/v1/Subscriptions/DFaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/SubscribedEvents"
  }
}
```

That's it! Once the subscription is created, Verify events will start flowing into your webhook application when they occur.