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

# Quickstart

> Create your first uptime monitor with DevHelm in under 5 minutes using the CLI, YAML, SDK, or REST API

Create your first HTTP monitor in under 5 minutes. Pick the approach that fits your workflow.

## Prerequisites

* A DevHelm account — [sign up at app.devhelm.io](https://app.devhelm.io)
* An API key — create one from **Settings → API Keys** in the Dashboard

Set your token as an environment variable:

```bash theme={null}
export DEVHELM_API_TOKEN=dh_live_xxxxxxxx
```

<Note>
  Each API token is scoped to a single organization and workspace, so the
  examples below work without any org/workspace flag. If your token grants
  access to multiple orgs or workspaces, set `DEVHELM_ORG_ID` and
  `DEVHELM_WORKSPACE_ID` as well — see
  [CLI authentication](/cli/authentication) for switching contexts in the CLI.
</Note>

<Note>
  The examples below use a 60-second check frequency, which requires a paid
  plan (the Free plan minimum is 300 seconds). Omit the frequency entirely to
  default to your plan's minimum.
</Note>

***

## Create a monitor

<Tabs>
  <Tab title="CLI">
    Install the CLI globally:

    ```bash theme={null}
    npm install -g devhelm
    ```

    Create a monitor:

    ```bash theme={null}
    devhelm monitors create \
      --name "My API" \
      --type HTTP \
      --url https://api.example.com/health \
      --frequency 60 \
      --regions us-east
    ```

    Check your monitor status:

    ```bash theme={null}
    devhelm monitors list
    ```
  </Tab>

  <Tab title="YAML + Deploy">
    Create a `devhelm.yml` file:

    ```yaml theme={null}
    version: "1"

    tags:
      - name: production
        color: "#10b981"

    monitors:
      - name: API Health
        type: HTTP
        config:
          url: https://api.example.com/health
          method: GET
        frequencySeconds: 60
        regions:
          - us-east
          - eu-west
        tags:
          - production

      - name: Marketing Site
        type: HTTP
        config:
          url: https://example.com
          method: GET
        frequencySeconds: 300
        regions:
          - us-east

    alertChannels:
      - name: Engineering Slack
        config:
          channelType: slack
          webhookUrl: ${SLACK_WEBHOOK_URL}
    ```

    Preview and deploy:

    ```bash theme={null}
    devhelm validate devhelm.yml
    devhelm plan -f devhelm.yml
    devhelm deploy -f devhelm.yml
    ```
  </Tab>

  <Tab title="TypeScript">
    ```bash theme={null}
    npm install @devhelm/sdk
    ```

    ```typescript theme={null}
    import { Devhelm } from "@devhelm/sdk";

    const client = new Devhelm({
      token: process.env.DEVHELM_API_TOKEN!,
    });

    const monitor = await client.monitors.create({
      name: "My API",
      type: "HTTP",
      config: { url: "https://api.example.com/health", method: "GET" },
      frequencySeconds: 60,
      regions: ["us-east"],
    });

    console.log(`Monitor created: ${monitor.id}`);
    ```
  </Tab>

  <Tab title="Python">
    ```bash theme={null}
    pip install devhelm
    ```

    ```python theme={null}
    import os
    from devhelm import Devhelm

    client = Devhelm(token=os.environ["DEVHELM_API_TOKEN"])

    monitor = client.monitors.create({
        "name": "My API",
        "type": "HTTP",
        "config": {"url": "https://api.example.com/health", "method": "GET"},
        "frequencySeconds": 60,
        "regions": ["us-east"],
    })

    print(f"Monitor created: {monitor.id}")
    ```
  </Tab>

  <Tab title="REST API">
    ```bash theme={null}
    curl -X POST https://api.devhelm.io/api/v1/monitors \
      -H "Authorization: Bearer $DEVHELM_API_TOKEN" \
      -H "Content-Type: application/json" \
      -d '{
        "name": "My API",
        "type": "HTTP",
        "config": { "url": "https://api.example.com/health", "method": "GET" },
        "frequencySeconds": 60,
        "regions": ["us-east"]
      }'
    ```
  </Tab>
</Tabs>

***

## What happens next

Once your monitor is running, DevHelm will:

1. **Check your endpoint** from the selected probe regions at the configured frequency
2. **Create an incident** automatically if the endpoint fails or violates assertions
3. **Alert your team** through connected alert channels (Slack, PagerDuty, email, etc.)
4. **Resolve the incident** automatically when the endpoint recovers

## Next steps

<CardGroup cols={2}>
  <Card title="Monitoring overview" icon="signal" href="/monitoring/overview">
    Learn about all six monitor types, assertions, and regions.
  </Card>

  <Card title="Alerting guide" icon="bell" href="/guides/alerting">
    Set up alert channels, notification policies, and escalation rules.
  </Card>

  <Card title="Monitoring as Code" icon="file-code" href="/mac/overview">
    Manage your monitoring stack in YAML or Terraform and deploy from CI/CD.
  </Card>

  <Card title="CLI overview" icon="terminal" href="/cli/overview">
    Full command reference for all CLI operations.
  </Card>
</CardGroup>