Developer & Autonomous Agent Documentation

{
  "mcpServers": {
    "seseli": {
      "command": "npx",
      "args": ["-y", "@seseli/mcp-server"],
      "env": {
        "SESELI_API_KEY": "ssl_live_YOUR_API_TOKEN"
      }
    }
  }
}

Set up website monitoring and a public status page for my site with Seseli via MCP.

HOW TO CONNECT TO SESELI MCP (use whichever your client supports):
- Local / stdio: run its MCP server with: npx -y @seseli/mcp-server
- Remote / Streamable HTTP: POST https://api.seseli.io/v1/mcp (JSON-RPC 2.0).
  Discover first with GET https://api.seseli.io/.well-known/mcp.json —
  then call tools/list.

  No API key yet? No problem — get the deep link directly (no auth needed):
  POST https://api.seseli.io/v1/onboarding/deep-link
  with {"siteUrl": "https://example.com", "agent": "Claude Code"}
  (stdio MCP + start_onboarding also work without a key).

SEQUENCE — follow this exactly:
1. Call the Seseli MCP tool `start_onboarding` (or read resource
   `seseli://onboarding/guide` / prompt `onboarding` if you prefer), passing
   my website URL in `siteUrl` if I already gave it to you. The tool returns
   a deep link (https://app.seseli.io/onboarding?... on prod, or the dev/stage
   host in those environments). If remote MCP returns 401/Unauthorized because
   I have no key yet, fall back to POST /v1/onboarding/deep-link above, or
   just give me https://app.seseli.io/onboarding directly.
2. Show me that deep link as a clickable link and explain: open it on your
   phone/computer, sign in (or create a free account if you don't have one),
   then click "Authorize agent". That consent step issues a scoped
   ssl_live_... agent API key. STOP and wait — do not continue until I confirm
   I have consented and paste the key (or set SESELI_API_KEY) for you.
   Never ask for my password; the key is the only credential I should share.
3. Once authenticated, set up monitoring for my website:
   a. If you don't know my website URL yet, ask me for it.
   b. Call `create_monitor` with a sensible name, the URL, intervalSeconds 300,
      and tags ["agent-onboarded"].
   c. Call `trigger_check_now` to verify it is reachable and report
      status, latency, and TLS status in plain language.
4. ASK ME: "Do you want a public status page at status.<my-domain>?"
   - If yes, call `create_status_page` with a slug from my domain,
     title "<My Domain> Status", all monitor IDs you just created, and
     customDomain "status.<my-domain>". Then walk me through DNS step by step:
     add a CNAME record — Host "status" → Value "status.seseli.io" — at my
     registrar (give me Cloudflare/Route 53/Namecheap/GoDaddy wording if you
     can tell which one I use), how to verify with `dig CNAME`, propagation
     timing, and note the TLS certificate is provisioned automatically.
     Show me the public URL https://status.seseli.io/<slug> and the target
     https://status.<my-domain> (after DNS propagates).
   - If no, create the status page without a custom domain and show me the
     public https://status.seseli.io/<slug> URL.
5. Summarize what you did: monitor name + URL + check result, status page
   public URL (+ custom domain + DNS status if requested), and how to view it
   in the dashboard at https://app.seseli.io/dashboard.

RULES:
- Keep me in the loop: tell me before each step, pause at the consent step,
  and never create monitors or pages without my confirmation.
- If no MCP server is connected, tell me the exact 2-minute fix (add
  "seseli" with command "npx", args ["-y", "@seseli/mcp-server"] to my MCP
  client config) and wait for me to reconnect.
- If a step fails, explain the error in plain language and offer the next
  recovery step. Do not print secret keys back in full once set.

import { createSeseliClient } from '@seseli/sdk';

const seseli = createSeseliClient({
  apiKey: process.env.SESELI_API_KEY, // e.g. "ssl_live_..."
});

// 1. Create a synthetic uptime monitor
const monitor = await seseli.monitors.create({
  name: "Production Payment Service",
  url: "https://api.acme.com/v1/payments/healthz",
  intervalSeconds: 60,
  assertions: {
    expectedStatusCodes: [200],
    latency: { thresholdMs: 250, comparison: "LESS_THAN" }
  },
  tags: ["payments", "tier-0", "soc2"]
});

// 2. Trigger an immediate on-demand probe
const checkResult = await seseli.monitors.triggerCheck({
  monitorId: monitor.id,
  region: "us-east-1"
});
console.log("Check latency:", checkResult.timing.totalMs, "ms");

import requests

API_KEY = "ssl_live_YOUR_TOKEN_HERE"
BASE_URL = "https://api.seseli.io/v1"

# Create a monitor via REST
resp = requests.post(
    f"{BASE_URL}/monitors",
    headers={"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"},
    json={
        "name": "AI Vector Search API",
        "url": "https://vector.acme.com/readyz",
        "intervalSeconds": 60,
        "assertions": {"expectedStatusCodes": [200]}
    }
)
print("Monitor Created:", resp.json())