> ## Documentation Index
> Fetch the complete documentation index at: https://sequinstream.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Get started with S2

> Stream Postgres changes to an S2 stream in minutes with Sequin.

In this quickstart, you'll create a real-time data pipeline that streams changes from a Postgres database to an S2 stream. You'll:

* Set up an S2 stream using the S2 web console and CLI
* Boot Sequin and connect to a sample playground database
* Configure Sequin to stream database changes to your S2 stream
* See your changes flow in real-time

By the end, you'll have hands-on experience setting up Postgres change data capture (CDC) with Sequin and S2.

<Tip>
  This is the quickstart for streaming Postgres to S2. See the [how-to guide](/how-to/stream-postgres-to-s2) for an explanation of how to use the S2 sink or the [reference](/reference/sinks/s2) for details on all configuration options.
</Tip>

## Prerequisites

* A [S2 cloud account](https://s2.dev/sign-up)
* The [S2 CLI](https://s2.dev/docs/quickstart#get-started-with-the-cli) installed

<Steps titleSize="h2">
  <Step title="Set up your S2 stream" icon="s">
    First, let's create an S2 stream

    <Steps>
      <Step title="Create an S2 Access Token">
        In the [S2 web console](https://s2.dev/dashboard), navigate to the "Access Tokens" section and click the "+ Issue" button to generate a new token.

        Save this token to a secure location as you'll need it to configure the S2 CLI and your Sequin S2 sink.
      </Step>

      <Step title="Create an S2 Basin">
        Navigate to the ["Basins" tab](https://s2.dev/dashboard/basins) and click the "+ Create Basin" button. Enter a name for your basin (e.g. `sequin-quickstart`) and accept the default settings. Click the "Create Basin" button to create your basin.
      </Step>

      <Step title="Create an S2 Stream">
        Select the basin you just created and click the "+ Create Stream" button. Name your stream `products` and accept the default settings. Click the "Create Stream" button to create your stream.
      </Step>

      <Step title="Connect to your S2 stream using the S2 CLI">
        Now, open your terminal and configure the S2 CLI with your access token:

        ```bash theme={null}
        s2 config set access-token <your-access-token>
        ```

        Then, begin reading from your stream:

        ```bash theme={null}
        s2 read s2://{{your-basin-name}}/products

        $
        ```
      </Step>
    </Steps>

    <Check>
      Your S2 stream is now ready to receive data.
    </Check>
  </Step>

  <Step title="Run Sequin" icon="server">
    The easiest way to get started with Sequin is with our [Docker Compose file](https://github.com/sequinstream/sequin/blob/main/docker/docker-compose.yaml). This file starts a Postgres database, Redis instance, and Sequin server.

    <Steps>
      <Step title="Create directory and start services">
        1. Download [sequin-docker-compose.zip](https://github.com/sequinstream/sequin/releases/latest/download/sequin-docker-compose.zip).
        2. Unzip the file.
        3. Navigate to the unzipped directory and start the services:

        ```bash theme={null}
        cd sequin-docker-compose && docker compose up -d
        ```

        <AccordionGroup>
          <Accordion title="Alternative: Download with curl">
            ```bash theme={null}
            curl -L https://github.com/sequinstream/sequin/releases/latest/download/sequin-docker-compose.zip -o sequin-docker-compose.zip \
              && unzip sequin-docker-compose.zip && rm sequin-docker-compose.zip
            cd sequin-docker-compose && docker compose up -d
            ```
          </Accordion>

          <Accordion title="Alternative: Clone the repository">
            ```bash theme={null}
            git clone git@github.com:sequinstream/sequin.git
            cd sequin/docker
            docker compose up -d
            ```
          </Accordion>
        </AccordionGroup>
      </Step>

      <Step title="Verify services are running">
        Check that Sequin is running using `docker ps`:

        ```bash theme={null}
        docker ps
        ```

        You should see output like the following:

        ```
        CONTAINER ID   IMAGE                           COMMAND                  CREATED          STATUS                    PORTS                              NAMES
        bd5c458cabde   sequin/sequin:latest            "/scripts/start_comm…"   11 seconds ago   Up 9 seconds              4000/tcp, 0.0.0.0:7376->7376/tcp   sequin-sequin-1
        3bacd89765e7   grafana/grafana                 "/run.sh"                11 seconds ago   Up 11 seconds             0.0.0.0:3000->3000/tcp             sequin-sequin_grafana-1
        3ad41319a66c   postgres:16                     "docker-entrypoint.s…"   11 seconds ago   Up 11 seconds (healthy)   0.0.0.0:7377->5432/tcp             sequin-sequin_postgres-1
        6139a5fc4e80   redis:7                         "docker-entrypoint.s…"   11 seconds ago   Up 11 seconds             0.0.0.0:7378->6379/tcp             sequin-sequin_redis-1
        7e07a5b052de   prom/prometheus                 "/bin/prometheus --c…"   11 seconds ago   Up 11 seconds             0.0.0.0:9090->9090/tcp             sequin-sequin_prometheus-1
        ```

        <Check>
          Sequin, Postgres, Redis, Prometheus, and Grafana should be up and running (status: `Up`).
        </Check>
      </Step>
    </Steps>
  </Step>

  <Step title="Login" icon="key">
    The Docker Compose file automatically configures Sequin with an admin user and a playground database.

    Let's log in to the Sequin web console:

    <Steps>
      <Step title="Open the web console">
        After starting the Docker Compose services, open the Sequin web console at [http://localhost:7376](http://localhost:7376):

        <Frame>
          <img src="https://mintcdn.com/sequinstream/drUA755uMUeIaCSH/images/quickstart/login-page.png?fit=max&auto=format&n=drUA755uMUeIaCSH&q=85&s=c5d90b34f56560570696a71370f7e39b" alt="Sequin login page, allowing login with default credentials" width="2070" height="1696" data-path="images/quickstart/login-page.png" />
        </Frame>
      </Step>

      <Step title="Login with default credentials">
        Use the following default credentials to login:

        * Email:

        ```
        admin@sequinstream.com
        ```

        * Password:

        ```
        sequinpassword!
        ```
      </Step>
    </Steps>
  </Step>

  <Step title="View the playground database" icon="database">
    To get you started quickly, Sequin's Docker Compose file creates a logical database called `sequin_playground` with a sample dataset in the `public.products` table.

    Let's take a look:

    <Steps>
      <Step title="Navigate to Databases">
        In the Sequin web console, click **Databases** in the sidebar.
      </Step>

      <Step title="Select playground database">
        Click on the pre-configured `sequin-playground` database:

        <Frame>
          <img src="https://mintcdn.com/sequinstream/drUA755uMUeIaCSH/images/quickstart/playground-database.png?fit=max&auto=format&n=drUA755uMUeIaCSH&q=85&s=01ac1cbf4506cad22c270adb66c0b171" alt="Playground database" width="3376" height="2020" data-path="images/quickstart/playground-database.png" />
        </Frame>

        <Check>
          The database "Health" should be green.
        </Check>
      </Step>

      <Step title="View contents of the products table">
        Let's get a sense of what's in the `products` table. Run the following command:

        ```bash theme={null}
        docker exec -i sequin-sequin_postgres-1 \
          psql -U postgres -d sequin_playground -c \
          "select id, name, price from products;"
        ```

        <Info>
          This command connects to the running Postgres container and runs a `psql` command.
        </Info>

        You should see a list of the rows in the `products` table:

        ```
          id |         name          | price 
        ----+-----------------------+-------
          1 | Avocados (3 pack)     |  5.99
          2 | Flank Steak (1 lb)    |  8.99
          3 | Salmon Fillet (12 oz) | 14.99
          4 | Baby Spinach (16 oz)  |  4.99
          5 | Sourdough Bread       |  6.99
          6 | Blueberries (6 oz)    |  3.99
        (6 rows)
        ```

        We'll make modifications to this table in a bit.
      </Step>
    </Steps>
  </Step>

  <Step title="Create a S2 Sink" icon="s">
    With the playground database connected, create a [sink](/reference/sinks/overview) that will send changes to your S2 stream:

    <Steps>
      <Step title="Navigate to Sinks">
        Click "Sinks" in the sidebar navigation, then click "Create Sink".
      </Step>

      <Step title="Select sink type">
        Select "S2" as the sink type and click "Continue".
      </Step>

      <Step title="Note &#x22;Source&#x22; configuration">
        In the "Source" card, note that the `sequin-playground` database is selected and all schemas and tables are included. Leave these defaults:

        <Frame>
          <img style={{ maxWidth: '500px' }} src="https://mintcdn.com/sequinstream/I2Yx_f_pmUFGglUP/images/quickstart/source-card.png?fit=max&auto=format&n=I2Yx_f_pmUFGglUP&q=85&s=a1ba47d0e4698d439d64db0d582f0951" alt="Source card showing the sequin_playground database and products table" width="1640" height="778" data-path="images/quickstart/source-card.png" />
        </Frame>
      </Step>

      <Step title="Setup a backfill">
        In the `Inital backfill` card, select the `public.products` table to initate a backfill when the sink is created.

        <Frame>
          <img style={{ maxWidth: '700px' }} src="https://mintcdn.com/sequinstream/drUA755uMUeIaCSH/images/quickstart/backfill-card.png?fit=max&auto=format&n=drUA755uMUeIaCSH&q=85&s=2a41931bc2d650f7467f3c7ae92b5b0a" alt="Initial backfill card with public.products table selected" width="1606" height="570" data-path="images/quickstart/backfill-card.png" />
        </Frame>
      </Step>

      <Step title="Configure S2 connection">
        In the S2 configuration card, enter:

        * **Basin**: The name of the basin you created previously
        * **Stream**: The name of the stream you created previously
        * **Access Token**: The access token for the S2 account associated with the basin and stream
      </Step>

      <Step title="Create the sink">
        Click "Create Sink" to finish setting up your S2 sink.
      </Step>
    </Steps>
  </Step>

  <Step title="See changes flow to your S2 stream" icon="waveform-lines">
    On the new sink's overview page, you should see the "Health" status turn green, indicating data is flowing to your stream.

    <Steps>
      <Step title="Messages tab">
        Click the "Messages" tab to see recently delivered messages.
      </Step>

      <Step title="Verify in S2">
        Return to your terminal and you should see the data flowing into your S2 stream.

        ```bash theme={null}
        s2 read s2://sequin-quickstart/products
        ⦿ 3500 bytes (6 records in range 6..=11)
        {"record":{"id":1,"inserted_at":"2025-06-11T01:19:22.402358","name":"Avocados (3 pack)","price":"5.99","updated_at":"2025-06-11T01:19:22.402358"},"metadata":{"consumer":{"id":"282713d8-76c4-42db-8e16-3e0df04cc5f6","name":"sequin-playground-s2-sink","annotations":null},"table_name":"products","commit_timestamp":"2025-06-17T19:19:51.955551Z","commit_lsn":null,"commit_idx":null,"transaction_annotations":null,"table_schema":"public","idempotency_key":"ODQ5NWNhMzEtYTM0MC00MDI5LThjODItMTcxYmRjMmY4YjI2OjE=","database_name":"sequin-playground"},"action":"read","changes":null}
        {"record":{"id":2,"inserted_at":"2025-06-11T01:19:22.402358","name":"Flank Steak (1 lb)","price":"8.99","updated_at":"2025-06-11T01:19:22.402358"},"metadata":{"consumer":{"id":"282713d8-76c4-42db-8e16-3e0df04cc5f6","name":"sequin-playground-s2-sink","annotations":null},"table_name":"products","commit_timestamp":"2025-06-17T19:19:51.955968Z","commit_lsn":null,"commit_idx":null,"transaction_annotations":null,"table_schema":"public","idempotency_key":"ODQ5NWNhMzEtYTM0MC00MDI5LThjODItMTcxYmRjMmY4YjI2OjI=","database_name":"sequin-playground"},"action":"read","changes":null}
        ...
        ```

        <Check>
          Messages are flowing from Sequin to your S2 stream.
        </Check>
      </Step>

      <Step title="Make some changes">
        Let's make some changes to the `products` table and see them flow to your S2 stream.

        In a new terminal window, run the following command to insert a new row into the `products` table:

        ```bash theme={null}
        docker exec -i sequin-sequin_postgres-1 \
          psql -U postgres -d sequin_playground -c \
          "insert into products (name, price) values ('Organic Honey (16 oz)', 12.99);"
        ```

        Back in your S2 stream, you should see a new message appear in the request log:

        ```bash theme={null}
        {"record":{"id":7,"inserted_at":"2025-06-17T21:03:40.350239","name":"Organic Honey (16 oz)","price":"12.99","updated_at":"2025-06-17T21:03:40.350239"},"metadata":{"consumer":{"id":"282713d8-76c4-42db-8e16-3e0df04cc5f6","name":"sequin-playground-s2-sink","annotations":{}},"table_name":"products","commit_timestamp":"2025-06-17T21:03:40.355455Z","commit_lsn":73220408,"commit_idx":0,"transaction_annotations":null,"table_schema":"public","idempotency_key":"NzMyMjA0MDg6MA==","database_name":"sequin-playground"},"action":"insert","changes":null}
        ```

        Feel free to try other changes:

        <AccordionGroup>
          <Accordion title="Update a product's price">
            ```bash theme={null}
            docker exec -i sequin-sequin_postgres-1 \
              psql -U postgres -d sequin_playground -c \
              "update products set price = 7.99 where name = 'Avocados (3 pack)';"
            ```
          </Accordion>

          <Accordion title="Change a product's name">
            ```bash theme={null}
            docker exec -i sequin-sequin_postgres-1 \
              psql -U postgres -d sequin_playground -c \
              "update products set name = 'Organic Avocados (3 pack)' where name = 'Avocados (3 pack)';"
            ```
          </Accordion>

          <Accordion title="Delete a product">
            ```bash theme={null}
            docker exec -i sequin-sequin_postgres-1 \
              psql -U postgres -d sequin_playground -c \
              "delete from products where name = 'Blueberries (6 oz)';"
            ```
          </Accordion>
        </AccordionGroup>

        Each change will appear in your S2 stream within a few seconds.
      </Step>
    </Steps>
  </Step>
</Steps>

<Check>
  Great work!
</Check>

You've successfully:

* Created an S2 stream
* Connected Sequin to stream Postgres changes to S2
* Verified changes are flowing to your S2 stream

## Ready to stream

Now you're ready to connect your own database to Sequin and start streaming changes:

<CardGroup cols={2}>
  <Card title="Guide: Connect Postgres" icon="elephant" href="/connect-postgres">
    Connect your Postgres database to Sequin.
  </Card>

  <Card title="Guide: Setting up a S2 sink" icon="s" href="/how-to/stream-postgres-to-s2">
    Setup a S2 sink to send changes to your stream.
  </Card>
</CardGroup>