Monitor Your First API in 5 Minutes: A Hands-On Rumbliq Tutorial

If you depend on third-party APIs — Stripe, Twilio, Shopify, or any vendor — you've probably been burned by an undocumented change. A field gets renamed. A type shifts from string to integer. A required parameter quietly appears. Your tests still pass because you mocked the response. Your users are the first to find out.

This API monitoring tutorial walks you through setting up Rumbliq to watch a live API endpoint and alert you the moment its schema changes. No credit card required. Takes about 5 minutes.

What You'll Need

A free Rumbliq account — up to 25 monitors, no credit card
curl installed locally (to test your setup)
The URL of an API endpoint you want to monitor

Step 1: Sign Up (60 seconds)

Go to rumbliq.com/signup and create a free account. You can sign up with GitHub, Google, or an email/password.

After signup, confirm your email and you'll land on the Rumbliq dashboard. The free tier gives you 25 monitors — enough to cover the critical third-party APIs your product relies on.

Step 2: Create Your First Monitor (2 minutes)

Click "New Monitor" in the top-right corner of the dashboard.

Configure the endpoint

Let's monitor a real endpoint. For this tutorial, we'll use GitHub's public API as an example — it requires no authentication and has a stable, well-known schema:

URL:    https://api.github.com/repos/torvalds/linux
Method: GET

In the monitor setup form, fill in:

Field	Value
Name	`GitHub Repo API`
URL	`https://api.github.com/repos/torvalds/linux`
Method	`GET`
Check Interval	`60 minutes` (free tier minimum)

Add required headers

GitHub's API requires a User-Agent header. In the Headers section, add:

User-Agent: rumbliq-monitor

For your own private APIs, you'll add authentication here too. For example, a Bearer token:

Authorization: Bearer YOUR_API_TOKEN

Or an API key header:

X-API-Key: YOUR_API_KEY

Test the endpoint first with curl

Before creating the monitor, it's worth validating your endpoint returns a healthy response. Run this locally:

curl -s \
  -H "User-Agent: rumbliq-monitor" \
  https://api.github.com/repos/torvalds/linux \
  | head -c 500

You should see JSON like:

{
  "id": 2325298,
  "node_id": "MDEwOlJlcG9zaXRvcnkyMzI1Mjk4",
  "name": "linux",
  "full_name": "torvalds/linux",
  "private": false,
  "owner": {
    "login": "torvalds",
    ...
  },
  "html_url": "https://github.com/torvalds/linux",
  "description": "Linux kernel source tree",
  ...
}

If curl returns a valid JSON response, your monitor configuration is good. Click "Save Monitor".

Step 3: Rumbliq Establishes a Baseline (30 seconds)

After saving, Rumbliq immediately runs its first check against the endpoint. This first check establishes the baseline schema — the structural fingerprint of the API response that all future checks are compared against.

Navigate to your monitor and click "Baseline" to see what Rumbliq captured:

{
  "id": "integer",
  "name": "string",
  "full_name": "string",
  "private": "boolean",
  "owner": {
    "login": "string",
    "id": "integer",
    "avatar_url": "string"
  },
  "html_url": "string",
  "description": "string | null",
  "stargazers_count": "integer",
  "language": "string | null"
}

This schema fingerprint is what Rumbliq will track over time. If any field is renamed, removed, or changes type, Rumbliq will flag it as drift.

Step 4: Configure an Alert (90 seconds)

Rumbliq records all drift events in the check history automatically — but to get notified immediately when drift is detected, configure an alert destination.

Navigate to Alerts → New Alert.

Option A: Slack (recommended for teams)

Create a Slack Incoming Webhook for your #api-alerts channel (Slack docs)
Paste the webhook URL into Rumbliq
Choose "Any change" to be notified of all schema drift

Option B: Webhook (for custom integrations)

Rumbliq will POST a JSON payload to any URL you specify. This is useful for routing alerts to PagerDuty, OpsGenie, or a custom handler.

When drift is detected, the webhook payload looks like:

{
  "event": "drift_detected",
  "monitor": {
    "id": "mon_abc123",
    "name": "GitHub Repo API",
    "url": "https://api.github.com/repos/torvalds/linux"
  },
  "check": {
    "id": "chk_xyz789",
    "timestamp": "2026-03-25T14:22:00Z",
    "severity": "breaking"
  },
  "diff": {
    "removed": ["description"],
    "added": ["topics"],
    "typeChanges": [
      { "field": "stargazers_count", "from": "integer", "to": "string" }
    ]
  },
  "url": "https://rumbliq.com/monitors/mon_abc123/checks/chk_xyz789"
}

The diff block shows you exactly what changed: removed fields, added fields, and any type changes. No guessing, no diffing JSON blobs by hand.

Option C: Email

For solo developers or low-traffic monitors, email alerts work fine. Add your address, set a severity threshold, and you're done.

Step 5: Verify Everything Is Working

Once your alert is saved, your monitor is fully operational. Here's what the end-to-end flow looks like:

Every 60 min:
  Rumbliq polls https://api.github.com/repos/torvalds/linux
        ↓
  Extracts the response schema
        ↓
  Compares to stored baseline
        ↓
  If schema matches → OK, logged, no alert
  If schema changed → Drift event created → Alert sent to Slack/webhook/email

You can verify the monitor is running by checking the Check History tab on your monitor page. You should see a green checkmark for the initial baseline check.

Monitoring a Private API: A Real-World Example

The GitHub example uses a public API with no auth. In practice, you'll monitor your own production endpoints or vendor APIs that require credentials.

Here's how to set up a monitor for a private API with an API key. First, test it with curl:

curl -s \
  -H "Authorization: Bearer sk_live_xxxxxxxxxxxx" \
  -H "Content-Type: application/json" \
  https://api.yourvendor.com/v1/orders \
  | python3 -m json.tool

Then in Rumbliq, use the Credential Vault (Pro and above) to store credentials encrypted rather than pasting them directly:

Go to Credentials → New Credential
Choose type: Bearer Token
Enter your token and save

Back in the monitor setup, select your saved credential from the Credential dropdown. Your API key is now stored with AES-256-GCM encryption and never exposed in plain text in monitor configs.

Monitoring Multiple Endpoints: Import from cURL or OpenAPI

If you want to monitor several endpoints at once, you don't need to set up each one manually.

Import from cURL: Navigate to Monitors → Import → cURL and paste any curl command. Rumbliq extracts the URL, method, headers, and body automatically.

For example, paste this:

curl -X GET https://api.stripe.com/v1/payment_intents \
  -H "Authorization: Bearer sk_test_xxxxxxxxxxxx" \
  -H "Stripe-Version: 2024-06-20"

Rumbliq will pre-populate the monitor with the correct URL, method, headers, and version pin.

Import from OpenAPI spec: Navigate to Monitors → Import → OpenAPI and upload your .yaml or .json spec. Rumbliq will create monitors for every endpoint in the spec in one shot — useful if you're onboarding monitoring for an entire third-party service.

What Happens When Drift Is Detected

When Rumbliq detects schema drift on one of your monitored endpoints, here's what you'll see:

Alert fires — Slack message, webhook POST, or email, depending on your config
Drift event logged — visible in Check History with a full before/after diff
Severity classified — Rumbliq distinguishes breaking changes (removed fields, type changes) from non-breaking changes (added fields)

A breaking change looks like this in the dashboard:

⚠️  Breaking change detected — Stripe Payment Intents
Field removed:     data.items[].payment_method
Field added:       data.items[].payment_method_details
Type changed:      data.items[].amount  integer → string
Detected at:       2026-03-25 14:22 UTC
Monitor interval:  15 minutes

You find out within 15 minutes (or 60 on the free tier) — not when a customer reports a broken checkout flow at 2am.

Free Tier Summary

Feature	Free
Monitors	25
Check interval	60 minutes
Check history	7 days
Alerts	Email only
Credit card required	No

The free tier is enough to cover your most critical third-party integrations. No time limit, no trial expiry — it's just free.

Next Steps

You now have a live API monitor watching your endpoint and an alert configured. Here's what to do next:

Add your most critical APIs — start with payment, auth, and customer-data endpoints
Create a Sequence — chain multiple API calls together (authenticate → fetch → submit) and verify your entire workflow works end-to-end. Free tier includes 3 sequences.
Set tighter intervals — upgrade to Pro for 15-minute or 5-minute checks
Import your Postman collection — get all your existing API tests into Rumbliq at once
Add team alerts — configure Slack or webhook alerts so your whole team knows when something changes

API monitoring isn't just about uptime. It's about knowing when a vendor changes something that will break your integration before your users do. Rumbliq gives you that visibility in minutes — and for the endpoints that matter most, that's everything.

Start monitoring for free →