Create Monitors

curl -X POST https://api.context.dev/v1/monitors \
  -H "Authorization: Bearer $CONTEXT_DEV_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Acme pricing page",
    "target": { "type": "page", "url": "https://acme.com/pricing" },
    "change_detection": { "type": "exact" },
    "schedule": { "type": "interval", "frequency": 6, "unit": "hours" },
    "webhook": { "url": "https://example.com/webhook" }
  }'

import ContextDev from "context.dev";

const client = new ContextDev({ apiKey: process.env.CONTEXT_DEV_API_KEY });

const monitor = await client.monitors.create({
  name: "Acme pricing page",
  target: { type: "page", url: "https://acme.com/pricing" },
  change_detection: { type: "exact" },
  schedule: { type: "interval", frequency: 6, unit: "hours" },
  webhook: { url: "https://example.com/webhook" },
});

console.log(monitor.id, monitor.webhook?.secret);

import os
from context.dev import ContextDev

client = ContextDev(api_key=os.environ["CONTEXT_DEV_API_KEY"])

monitor = client.monitors.create(
    name="Acme pricing page",
    target={"type": "page", "url": "https://acme.com/pricing"},
    change_detection={"type": "exact"},
    schedule={"type": "interval", "frequency": 6, "unit": "hours"},
    webhook={"url": "https://example.com/webhook"},
)

print(monitor.id, monitor.webhook.secret)

require "context_dev"

client = ContextDev::Client.new(api_key: ENV.fetch("CONTEXT_DEV_API_KEY"))

monitor = client.monitors.create(
  name: "Acme pricing page",
  target: {type: :page, url: "https://acme.com/pricing"},
  change_detection: {type: :exact},
  schedule: {type: :interval, frequency: 6, unit: :hours},
  webhook: {url: "https://example.com/webhook"}
)

puts monitor.id

package main

import (
    "context"
    "fmt"
    "os"

    contextdev "github.com/context-dot-dev/context-go-sdk"
    "github.com/context-dot-dev/context-go-sdk/option"
)

func main() {
    client := contextdev.NewClient(
        option.WithAPIKey(os.Getenv("CONTEXT_DEV_API_KEY")),
    )

    monitor, err := client.Monitors.New(context.TODO(), contextdev.MonitorNewParams{
        Name: "Acme pricing page",
        Target: contextdev.MonitorNewParamsTargetUnion{
            OfPage: &contextdev.MonitorNewParamsTargetPage{
                URL: "https://acme.com/pricing",
            },
        },
        ChangeDetection: contextdev.MonitorNewParamsChangeDetectionUnion{
            OfExact: &contextdev.MonitorNewParamsChangeDetectionExact{},
        },
        Schedule: contextdev.MonitorNewParamsSchedule{
            Type:      "interval",
            Frequency: 6,
            Unit:      "hours",
        },
        Webhook: contextdev.MonitorNewParamsWebhook{
            URL: "https://example.com/webhook",
        },
    })
    if err != nil {
        panic(err)
    }

    fmt.Println(monitor.ID)
}

<?php

use ContextDev\Client;

$client = new Client(apiKey: getenv('CONTEXT_DEV_API_KEY'));

$monitor = $client->monitors->create(
    name: 'Acme pricing page',
    target: ['type' => 'page', 'url' => 'https://acme.com/pricing'],
    changeDetection: ['type' => 'exact'],
    schedule: ['type' => 'interval', 'frequency' => 6, 'unit' => 'hours'],
    webhook: ['url' => 'https://example.com/webhook'],
);

echo $monitor->id;

import crypto from "node:crypto";

function verifyWebhook(rawBody: string, signatureHeader: string, secret: string): boolean {
  const parts = Object.fromEntries(
    signatureHeader.split(",").map((pair) => pair.split("=")),
  );
  const expected = crypto
    .createHmac("sha256", secret)
    .update(`${parts.t}.${rawBody}`)
    .digest();

  const isFresh = Math.abs(Date.now() / 1000 - Number(parts.t)) < 300;
  const received = Buffer.from(parts.v1 ?? "", "hex");
  return (
    isFresh &&
    received.length === expected.length &&
    crypto.timingSafeEqual(expected, received)
  );
}

import hashlib
import hmac
import time

def verify_webhook(raw_body: bytes, signature_header: str, secret: str) -> bool:
    parts = dict(pair.split("=", 1) for pair in signature_header.split(","))
    message = parts["t"].encode() + b"." + raw_body
    expected = hmac.new(secret.encode(), message, hashlib.sha256).hexdigest()

    is_fresh = abs(time.time() - int(parts["t"])) < 300
    return is_fresh and hmac.compare_digest(expected, parts["v1"])

curl "https://api.context.dev/v1/monitors/mon_123/changes?limit=20" \
  -H "Authorization: Bearer $CONTEXT_DEV_API_KEY"

curl https://api.context.dev/v1/monitors/changes/chg_123 \
  -H "Authorization: Bearer $CONTEXT_DEV_API_KEY"

const changes = await client.monitors.listChanges("mon_123", { limit: 20 });

for (const change of changes.data) {
  const detail = await client.monitors.retrieveChange(change.id);
  console.log(detail.title, detail.diff);
}

changes = client.monitors.list_changes(monitor_id="mon_123", limit=20)

for change in changes.data:
    detail = client.monitors.retrieve_change(change.id)
    print(detail.title, detail.diff)

changes = client.monitors.list_changes("mon_123", limit: 20)

changes.data.each do |change|
  detail = client.monitors.retrieve_change(change.id)
  puts detail.title
end

changes, err := client.Monitors.ListChanges(
    context.TODO(),
    "mon_123",
    contextdev.MonitorListChangesParams{},
)
if err != nil {
    panic(err)
}

for _, change := range changes.Data {
    detail, err := client.Monitors.GetChange(context.TODO(), change.ID)
    if err != nil {
        panic(err)
    }
    fmt.Println(detail.Title)
}

<?php

$changes = $client->monitors->listChanges('mon_123', limit: 20);

foreach ($changes->data as $change) {
    $detail = $client->monitors->retrieveChange($change->id);
    echo $detail->title;
}

curl -X POST https://api.context.dev/v1/monitors/mon_123/run \
  -H "Authorization: Bearer $CONTEXT_DEV_API_KEY"

curl -X PATCH https://api.context.dev/v1/monitors/mon_123 \
  -H "Authorization: Bearer $CONTEXT_DEV_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "status": "paused" }'

curl -X DELETE https://api.context.dev/v1/monitors/mon_123 \
  -H "Authorization: Bearer $CONTEXT_DEV_API_KEY"

await client.monitors.run("mon_123");

await client.monitors.update("mon_123", { status: "paused" });

await client.monitors.delete("mon_123");

client.monitors.run("mon_123")

client.monitors.update(monitor_id="mon_123", status="paused")

client.monitors.delete("mon_123")