Synchronize Data Across Systems

​

Why synchronize identity data

• Run analytics, reporting, or compliance queries without calling the Management API.
• Power search experiences that require low-latency lookups across user attributes.
• Feed data pipelines that join identity records with other business data.
• Maintain a backup of user profile state for disaster recovery.

​

How it works

1. Auth0 publishes an event each time a user profile changes.
2. Your Event Stream delivers that event to a destination (webhook, AWS EventBridge, or Auth0 Action).
3. Your handler inspects the event type and applies the corresponding write operation to the external system.

​

Prerequisites

• An Auth0 tenant with Events enabled. To learn more about plan availability, read Create an Event Stream.
• An active Event Stream subscribed to user.created, user.updated, and user.deleted. To learn more, read Create an Event Stream.
• An external data store (for example, PostgreSQL, MySQL, or a data warehouse) that you can write to from your handler.

​

Implement data synchronization

​

Handle user.created

async function handleUserCreated(user, time) {
    const { user_id, email, name, nickname, created_at, updated_at } = user;

    const query = `
        INSERT INTO users (user_id, email, name, nickname, created_at, updated_at, last_event_processed)
        VALUES ($1, $2, $3, $4, $5, $6, $7)
    `;
    const values = [user_id, email, name, nickname, created_at, updated_at, time];

    await pool.query(query, values);
}

​

Handle user.updated

async function handleUserUpdated(user, time) {
    const { user_id, email, name, nickname, updated_at } = user;

    const query = `
        UPDATE users
        SET email = $1, name = $2, nickname = $3, updated_at = $4, last_event_processed = $5
        WHERE user_id = $6 AND last_event_processed < $5
    `;
    const values = [email, name, nickname, updated_at, time, user_id];

    await pool.query(query, values);
}

​

Handle user.deleted

async function handleUserDeleted(user) {
    const { user_id } = user;

    const query = `DELETE FROM users WHERE user_id = $1`;

    await pool.query(query, [user_id]);
}

​

Route events by type

app.post("/webhook", async (req, res) => {
    const { type, time, data } = req.body;
    const user = data.object;

    try {
        switch (type) {
            case "user.created":
                await handleUserCreated(user, time);
                break;
            case "user.updated":
                await handleUserUpdated(user, time);
                break;
            case "user.deleted":
                await handleUserDeleted(user);
                break;
            default:
                console.log(`Unhandled event type: ${type}`);
        }

        res.sendStatus(204);
    } catch (err) {
        console.error("Error processing event:", err);
        res.status(500).json({ error: "Internal server error" });
    }
});

exports.onExecuteEventStream = async (event, api) => {
    const eventType = event.message.type;
    const user = event.message.data.object;
    const time = event.message.time;

    switch (eventType) {
        case "user.created":
            await handleUserCreated(user, time);
            break;
        case "user.updated":
            await handleUserUpdated(user, time);
            break;
        case "user.deleted":
            await handleUserDeleted(user);
            break;
        default:
            console.log(`Unhandled event type: ${eventType}`);
    }
};

​

Guard against duplicates and ordering issues

• Track event IDs. Store each processed event id and skip any event you have already handled.
• Compare timestamps. Each event payload includes created_at and updated_at fields on the data.object. Use these fields to determine whether an incoming event is newer than what your system has already recorded.
• Use idempotent writes. Structure your database operations so that applying the same event twice produces the same result. For example, use INSERT ... ON CONFLICT DO UPDATE in PostgreSQL.

INSERT INTO users (user_id, email, name, nickname, created_at, updated_at, last_event_processed)
VALUES ($1, $2, $3, $4, $5, $6, $7)
ON CONFLICT (user_id) DO UPDATE
SET email = EXCLUDED.email,
    name = EXCLUDED.name,
    nickname = EXCLUDED.nickname,
    updated_at = EXCLUDED.updated_at,
    last_event_processed = EXCLUDED.last_event_processed
WHERE users.last_event_processed < EXCLUDED.last_event_processed;

​

Verify synchronization

1. A new row appears in your external database with the correct profile data.
2. Update the user’s name or email in Auth0. Confirm the database row reflects the change.
3. Delete the user in Auth0. Confirm the row is removed (or marked as deleted) in your database.

​

Learn more

• Event Types
• Create an Event Stream
• Events Best Practices