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

# Quickstart

Get up and running with hookstream in under 5 minutes.

Create a source, send a webhook, and watch it get delivered — end to end in about five minutes. No local setup required.

## Prerequisites

You'll need a hookstream account (sign up at [hookstream.io](https://hookstream.io) — free for small projects) and a way to send HTTP requests: cURL, Postman, or your own application.

## Walkthrough

**Create a Source**

A source is your webhook ingestion endpoint. In the dashboard go to **Sources** and click **Create Source**. Name it something like `My App Webhooks`.

    hookstream generates a unique ingestion URL for you:

    ```text
    https://hookstream.io/v1/ingest/<source_id>
    ```

    Any HTTP request sent to this URL becomes an event in hookstream. See [Sources](/concepts/sources) for configuration options like signature verification and IP filtering.

  **Create a Destination**

A destination is where events get delivered. Go to **Destinations > Create Destination**, choose **HTTP/Webhook**, and enter your application's webhook handler URL.

    hookstream supports 8 destination types: HTTP, AWS SQS, AWS S3, AWS EventBridge, GCP Pub/Sub, Kafka, RabbitMQ, and WebSocket. See [Destinations](/concepts/destinations) for the full list.

  **Create a Connection**

A connection links a source to a destination. Go to **Connections > Create Connection** and pick the source and destination you just created.

    Optionally add content-based filters (e.g. only route events where `type` equals `"order.created"`) or a [JSONata transform](/concepts/filters-transforms) to reshape the payload before delivery.

  **Send a Webhook**

Fire a POST request at your source URL:

    ```bash curl
    curl -X POST https://hookstream.io/v1/ingest/<source_id> \
      -H 'Content-Type: application/json' \
      -d '{"type": "order.created", "data": {"id": "ord_123", "amount": 4999}}'
    ```

    ```javascript fetch
    await fetch("https://hookstream.io/v1/ingest/<source_id>", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        type: "order.created",
        data: { id: "ord_123", amount: 4999 },
      }),
    });
    ```

    ```python requests
    import requests

    requests.post(
        "https://hookstream.io/v1/ingest/<source_id>",
        json={"type": "order.created", "data": {"id": "ord_123", "amount": 4999}},
    )
    ```

    hookstream receives the event, runs it through every matching connection, and delivers it to each destination.

  **Verify Delivery**

Open **Events** in the dashboard to see your event. Click into the detail view for delivery attempts, status codes, and latency.

    If delivery fails, hookstream retries automatically with exponential backoff. After five consecutive failures the circuit breaker opens and events are routed to the dead letter queue.

## Next Steps

You now have a working webhook pipeline. Secure your source with signature verification, tighten routing with filters, and keep an eye on metrics.

**[Your First Webhook](/getting-started/first-webhook)**

A longer walkthrough that includes CLI setup and event inspection.
  **[How It Works](/getting-started/how-it-works)**

The architecture behind the pipeline — ingest, routing, delivery, monitoring.
  **[API Authentication](/api/authentication)**

Use API keys to manage sources, destinations, and connections programmatically.