# Datasource Pulse · full site text

> Complete text content of https://datasourcepulse.com/ in one file, for LLMs and agents. Datasource Pulse health-checks any HTTP endpoint — anything with a URL — with 35+ vendors pre-wired as a head start, not a limit: credentials AND quotas across any endpoint, plus output quality of Apify Actors you don't own, with one deduplicated alert per state change, machine-readable failure classes, and live x402 pay-per-check for agents. The curated index is at https://datasourcepulse.com/llms.txt.

Last updated: 2026-08-06

---

Datasource Pulse
The Problem How it Works Integrations Pricing Blog For Agents
Run it on Apify (https://datasourcepulse.com/agents/)

System Operational
x402-payable · no approval

# Know when any data connector fails silently.

Even when everything looks "up." Monitor API credentials, usage quotas, and scraper output quality across your whole pipeline on a schedule you choose. One alert when it degrades, one notice when it recovers.
Run it on Apify (https://datasourcepulse.com/agents/)
$0.02 per check • No subscription

slack_alerts / #data-ops

Datasource Pulse 10:42 AM
Recovered: GitHub · main PAT
GitHub PAT validity + core rate-limit remaining. Rate limit reset.

Datasource Pulse 3:14 AM
Failing: OpenAI · production key
Failure class: quota_exhausted
Impact: Summarization worker will crash on next batch.
Action required: Rotate key or increase billing limit at platform.openai.com

## Your pipeline degrades silently.

Your SerpAPI quota runs out. Your GitHub PAT expires over the weekend. The TikTok or LinkedIn Actor your pipeline depends on ships a changed output schema. Its maintainer's decision, not yours. None of it crashes your app. Your output just gets quietly worse until a customer notices. Datasource Pulse notices first.

### Catch expiration before it breaks

Rotate a key on your schedule, not after a customer complains.

### Track quota proactively

Know when you're at 80% before you hit the 100% wall.

### Catch output schema changes

A maintainer renames one field and your tables fill with nulls → you'll know the run it happens, not weeks later.

### Reduce incident response time

One message the moment something degrades, not hours later.

### Maintain downstream SLAs

Your data products stay reliable even when your vendors aren't.

### Visibility across your stack

One check instead of logging into every vendor console separately.

## The steady pulse of reliable infrastructure.

Datasource Pulse runs on a schedule you choose. It probes your connectors, compares them to the last known state, and fires exactly one deduplicated alert when things change.

### 1. Scheduled Trigger

Runs every 1-6 hours, or triggered on-demand by an AI agent.

### 2. Probe Data

Checks credential health, quotas, or scraper output quality across any source you point it at.

### 3. State Check

Compares result to previous memory. Detects degradation or recovery.

### 4. One Alert

Fires a single Slack message on change. Logs a record to your dataset.

### No alert storms.

If a connector fails, you get one alert. If it's still failing on the next run, we stay quiet. You only hear from us again when it escalates (like a quota going from 80% to 100%) or when it recovers.

- Includes the specific failure classification (e.g., quota_exhausted ) so you know exactly what to fix.
- Echoes your custom impact note verbatim so the on-call engineer knows what broke downstream.

POST /webhook

{
"transition": "healthy -> failing",
"connector_id": "serpapi-main",
"failure_class": "quota_exhausted",
"message": "SerpAPI failing...",
"impact": "Search indexing halted",
"metadata": {
"quota_used_pct": 100.0
}
}

Probe Type 1

## Credential & Quota Health

We make the cheapest authenticated call per vendor: enough to prove your token is alive and read your current usage. Know when you're at 80% capacity before you hit the wall.

-

#### Catch Dead Tokens

Validates API keys, OAuth refresh tokens, and Bearer tokens without consuming expensive credits.

-

#### Custom Quota Soft Caps

Evaluate warnings against your budget line, not the vendor's billing wall. Get notified before an unexpected spike costs you thousands.

### Any endpoint. The current 35+ pre-wired list is a head start, not a limit.

OpenAI Anthropic GitHub Stripe SerpAPI Resend X/Twitter Reddit Gemini Groq Mistral Cohere Perplexity Together OpenRouter Firecrawl Exa Tavily Bright Data ScrapingBee ZenRows ElevenLabs Deepgram AssemblyAI Replicate Hugging Face Pinecone Supabase Airtable Google OAuth + Any HTTP endpoint

Not on the list? One generic_http check monitors anything with a URL: your own API, a partner feed, your database's REST or health endpoint. And the pre-wired list keeps growing.
Example: OpenRouter
"type": "credential",
"vendor": "openrouter",
"quotaSoftCap": 50.00

Pipe alerts anywhere. Ready-made templates and webhook recipes for your automation stack:
n8n Zapier Make

Probe Type 2

## Scraper Output Quality

Official APIs are locked down, so your pipeline probably depends on third-party scrapers (TikTok, Google Maps, LinkedIn) built by someone else. When their maintainer pushes a breaking schema change, your app quietly consumes garbage data.

Datasource Pulse monitors the Actors you don't own.
Success / Failure Rate
7-day and 30-day rolling baselines

Output Schema Drift
Alerts immediately if field names change

Actor Staleness
Detects abandoned or outdated scrapers

Volume Drops
Catches silent empty-result runs

Cost Spikes
Warns if compute time suddenly balloons

dataset_record.json

{ "check_type": "actor", "connector_label": "Compass Google Maps", "state": "failing", "failure_class": "schema_drift", "message": "Output schema changed.", "metadata": { "missing_fields": [ "reviewsCount", "price" ], "new_fields": [ "review_metrics" ], "actor_id": "compass~google-maps" } }

Alert fired before your ETL job ingested the missing fields.

Built for Agents

## Agent-first architecture.

AI agents build autonomous data pipelines. Datasource Pulse is the drop-in reliability check that tells them when their tools are broken.

### API & MCP Ready

Discoverable and callable as a tool via the Apify API and MCP. Takes a structured JSON input manifest, returns exactly one status record per connector.
Agent access docs →

### Machine-Readable Errors

No parsing human error strings. A stable failure_class enum ( dead_token, schema_drift, rate_limited ) lets agents branch logic automatically.

### x402 Payments · Live

Agents buy health checks from our API today: $0.02 in USDC on Base, no account of any kind. Listed in Coinbase’s x402 Bazaar, settled on-chain, verifiable by anyone.
How the first payment went → Live payment feed on x402scan (https://www.x402scan.com/recipient/0x7cCb91a3ad4c45097bDA4C3C29d2Cc89fA93Ab36)

## Radically simple pricing.

Pay for the check, not the result. A dead token or exhausted quota still bills, because catching that failure is exactly the value you're paying for.

### Pay per event

No subscriptions. No per-run minimums.

- Charge applies on attempt (failures count)
- Subset recheck: preflight expensive jobs by checking just one key
- Set a hard max cost ceiling per run
- x402 agentic payments supported (USDC on Base)
Total = number of checks × $0.02

$0.02
per connector checked
Run it on Apify (https://datasourcepulse.com/agents/)
Runs on your Apify account.

Light Setup
3 connectors, every 6h
~$7 / mo

Standard
5 connectors, every 3h
~$24 / mo

Heavy
10 connectors, hourly
~$144 / mo

## Frequently asked questions

### How do I get an alert when a data feed goes stale?

Watch freshness, not uptime: a stale feed still answers 200. The manual route is a daily job comparing the feed’s newest timestamp against a threshold set just past its update cadence. The automated route is a Datasource Pulse check on the actor or endpoint producing the feed: zero-yield streaks, volume drops against a learned baseline, and abandoned-scraper warnings, each as a named alert with a recovery notice when the feed comes back, at $0.02 per check. Full walkthrough of both routes: how to get an alert when a data feed goes stale.

Datasource Pulse

The heartbeat monitor for your data supply chain.

Datasource Pulse monitors Apify Actors for failures and failed runs, plus API credentials, usage quotas, and scraper output quality across your data pipeline. It knows when your SerpAPI quota runs out, when your GitHub PAT expires, and when the TikTok or LinkedIn Actor your pipeline depends on ships a changed output schema. Its maintainer’s decision, not yours. One alert when something degrades, one notice when it recovers. Runs on your schedule as an Apify Actor · $0.02 per check, billed per connector, no subscription.

Run it on Apify (https://datasourcepulse.com/agents/) Blog · For Agents · n8n · Zapier · Make llms.txt · llms-full.txt

© 2026 Datasource Pulse

Monitor after you adopt. Audit before you adopt with Audit Tools (https://audit-tools.ai) · independent, evidence-backed evaluation of Apify actors. From the maker of Demand Discovery AI (https://demanddiscovery.ai).

---

# Page: https://datasourcepulse.com/blog

Datasource Pulse
The Problem How it Works Integrations Pricing Blog For Agents
Run it on Apify (https://datasourcepulse.com/agents/)

Blog · Datasource Pulse

# Field notes from the data supply chain.

What we learn running health checks on APIs, keys, and scrapers: staged failures, agents that pay their own way, and the quiet ways data pipelines break.

August 6, 2026 · Case study

## Two scrapers changed their output on the same week. Triage took one question.

Our own monitoring flagged schema drift on a Reddit scraper and the Instagram scraper within the same week. Both runs exited green. The full incident with timestamps, the one triage question that closed it in minutes, and why drift severity is defined by the consumer, not the vendor.
Read the post →
August 2, 2026 · Field guide

## How to Detect When a Scraper’s Output Schema Changes

A renamed field never throws an error: the run exits green and a downstream column quietly fills with nulls. The fingerprint-and-diff pattern, the three traps that make homemade detectors page you at 3 a.m., and the automated schema_drift check at $0.02 per run.
Read the post →
August 2, 2026 · Apify

## How to Monitor an Apify Actor for Failures, Even One You Don’t Own

A failed run is the easy case. The costly failures keep the run status green: successful runs that deliver zero items, field names that quietly changed, record counts that collapsed. Six alarms for any Store actor you depend on but did not build, read-only, $0.02 per check.
Read the post →
August 1, 2026 · Quota watch

## How to Detect When an API Key Expires or Silently Fails

A dead key never announces itself: the job exits green and the vendor emailed an inbox nobody reads. The scheduled canary-call pattern with the four outcomes your checker must tell apart, real field names for GitHub, SerpAPI, and OpenAI, and the automated route at $0.02 per check.
Read the post →
August 1, 2026 · Quota watch

## How to get an alert when a data feed goes stale

The nastiest data failure has no red anywhere: the feed is up, the data is old. The cron-plus-timestamp pattern and its three traps, then supply-side freshness detection: zero-yield streaks, volume drops, and abandoned-scraper warnings.
Read the post →
August 1, 2026 · Quota watch

## How to monitor GitHub personal access token expiration

GitHub emails one inbox before a PAT expires, then your pipelines hit 401s. Read the expiry header from the free /rate_limit endpoint for the heads-up, and run a daily liveness check that also catches revocations and permission downgrades no reminder will.
Read the post →
August 1, 2026 · Quota watch

## How to get alerted before your SerpAPI quota runs out

The manual route with SerpAPI’s own account endpoint, the field trap that makes naive scripts report 0% used forever, and the automated route: one JSON block, $0.02 per check, with a heads-up at 80% and escalation at your own budget line.
Read the post →
July 24, 2026 · Featured

## An AI agent just paid our API two cents. No account. No card. No human.

An AI agent hit our x402 endpoint, paid $0.02 in USDC on Base, and got a live connector health verdict back. The payment settled on a public blockchain, so the payer, the receiver, and the amount are all checkable. On-chain proof inside.
Read the post →
July 25, 2026 · n8n

## We broke an endpoint on purpose

We pointed one of our n8n templates at a deliberately broken endpoint and watched the Slack alert land in about a minute. Every check is JSON you design: any endpoint, key, or actor, with 35+ vendors pre-wired as a head start.
Read the post →

Datasource Pulse

The heartbeat monitor for your data supply chain.

Datasource Pulse monitors Apify Actors for failures and failed runs, plus API credentials, usage quotas, and scraper output quality across your data pipeline. It knows when your SerpAPI quota runs out, when your GitHub PAT expires, and when the TikTok or LinkedIn Actor your pipeline depends on ships a changed output schema. Its maintainer’s decision, not yours. One alert when something degrades, one notice when it recovers. Runs on your schedule as an Apify Actor · $0.02 per check, billed per connector, no subscription.

Run it on Apify (https://datasourcepulse.com/agents/) Blog · For Agents · n8n · Zapier · Make llms.txt · llms-full.txt

© 2026 Datasource Pulse

Monitor after you adopt. Audit before you adopt with Audit Tools (https://audit-tools.ai) · independent, evidence-backed evaluation of Apify actors. From the maker of Demand Discovery AI (https://demanddiscovery.ai).

---

# Page: https://datasourcepulse.com/blog/an-ai-agent-just-paid-us

Datasource Pulse
The Problem How it Works Integrations Pricing Blog For Agents
Run it on Apify (https://datasourcepulse.com/agents/)

July 2026 · Datasource Pulse

# An AI agent just paid our API two cents. No account. No card. No human.

This week an AI agent called our API, was told the price, paid it, and got what it paid for. The whole exchange took a few seconds. Nobody created an account, nobody typed a card number, nobody was awake. The price was two cents.

Full disclosure, first: the agent was ours. We built it to prove the pipe end to end with real money before saying a word publicly. That is also why this post can exist: the payment settled on a public blockchain, so you can check the payer, the receiver, and the amount yourself. The links are below. The pipe neither knows nor cares whose agent is calling, and that is the entire point.

## The 30-year-old error code that finally works

HTTP has reserved status code 402, “Payment Required,” since the 1990s. It sat unused for three decades because software had no way to just pay. x402, an open standard launched by Coinbase and others, finally fills it in: when a machine hits a paid endpoint, the 402 response carries exact payment instructions. The machine pays in USDC (a digital dollar), retries the request with the receipt attached, and gets its answer. No checkout page, no OAuth dance, no invoice at the end of the month.

## Why a monitoring API wants to be paid this way

Datasource Pulse answers one question: is this data connector actually working? Agents have exactly that question at exactly one moment, right before committing to an expensive run. That preflight is now a two-cent purchase: POST a credential or an actor id to our endpoint, pay $0.02, and get back a machine-readable verdict with a stable failure class an agent can branch on.

A machine about to spend real money on a scrape first buys a health check on its own dependency. Machines buying insurance for machines, two cents at a time. We find this both completely sensible and slightly surreal.

## Check the receipts

- The settlement, on the public record: the transaction on Base (https://basescan.org/tx/0xb3f2cb9bd5a839d40d1d9bf816f381a00e616f0ebc5115c01270afba2fb2faa5)
- Every payment to our receiving address, as it happens: our page on x402scan (https://www.x402scan.com/recipient/0x7cCb91a3ad4c45097bDA4C3C29d2Cc89fA93Ab36)
- The listing: Coinbase’s public x402 catalog (the Bazaar) carries our endpoint, its price, and its full input and output schemas, so any agent can discover it through the discovery API without ever visiting this site.
- The endpoint itself: POST https://datasourcepulse.com/api/x402/check · calling it without payment returns the 402 envelope, which is also the price list.

## For the technical readers

Standard HTTPS. The POST returns 402 with an x402 v1 envelope: $0.02 in USDC on Base, settled through the Coinbase facilitator, 90-second timeout, input and output schemas included in the envelope and mirrored in the public listing. With x402-fetch it is a wrapped fetch call and nothing else. The paid response is a machine-readable verdict: state, failure class, message, recommended action, and probe latency.

## What happens next

The rail is live, the listing is public, and the endpoint does not know whose agent is calling. If you are building an agent that depends on third-party data, give it two cents and let it check its own dependencies before it trusts them.

Datasource Pulse watches the data sources your product depends on: credentials, quotas, and scraper output quality. One alert when something degrades, one notice when it recovers.
Run it on Apify (https://datasourcepulse.com/agents/) Back to datasourcepulse.com

Datasource Pulse

The heartbeat monitor for your data supply chain.

Datasource Pulse monitors Apify Actors for failures and failed runs, plus API credentials, usage quotas, and scraper output quality across your data pipeline. It knows when your SerpAPI quota runs out, when your GitHub PAT expires, and when the TikTok or LinkedIn Actor your pipeline depends on ships a changed output schema. Its maintainer’s decision, not yours. One alert when something degrades, one notice when it recovers. Runs on your schedule as an Apify Actor · $0.02 per check, billed per connector, no subscription.

Run it on Apify (https://datasourcepulse.com/agents/) Blog · For Agents · n8n · Zapier · Make llms.txt · llms-full.txt

© 2026 Datasource Pulse

Monitor after you adopt. Audit before you adopt with Audit Tools (https://audit-tools.ai) · independent, evidence-backed evaluation of Apify actors. From the maker of Demand Discovery AI (https://demanddiscovery.ai).

---

# Page: https://datasourcepulse.com/blog/we-broke-an-endpoint-on-purpose

Datasource Pulse
The Problem How it Works Integrations Pricing Blog For Agents
Run it on Apify (https://datasourcepulse.com/agents/)

July 2026 · Datasource Pulse

# We broke an endpoint on purpose. Slack knew within a minute.

This week we imported one of our own n8n templates into a fresh n8n cloud workspace, pointed it at a web address we knew would fail, and pressed run. About a minute later a Slack channel got the message below. That is the whole product in one sentence: something you depend on broke, and the right room heard about it before any human went looking.

Full disclosure, as usual: the outage was staged. The check points at a URL that answers 404 on purpose, because the only way to trust an alarm is to hear it ring before there is a real fire. Everything else was production grade: a real n8n workspace, the real Datasource Pulse actor on Apify, a real two-cent charge, and a real Slack message.

🚨 Datasource Pulse · Test endpoint · reachable

State: failing · unexpected_response

Expected HTTP 200, got 404.

Automated with this n8n workflow

Recreated as a graphic for legibility. The wording is verbatim from the real alert.

## Sixty seconds, four boxes

The workflow is four nodes and no code. A schedule fires. The Apify node runs one Datasource Pulse health pass, which is where the two cents go. An IF node reads the verdict and lets healthy results die quietly. Anything else becomes a Slack message carrying the state, the failure class, and what was expected versus what actually came back.

The part that makes this work is that the verdict is built for branching, not for reading. Every check returns state, failure_class and a one-line message as stable strings, so the entire routing logic in n8n is one condition: state ≠ healthy. No parsing, no regex, no glue function.

## Three templates, import and go

The one we fire-drilled above is one of three ready-made workflows. Each is a JSON file you import into n8n, connect your Apify account to with one OAuth click, and point at your own scrapers, keys, or actors. Costs are billed by Apify per check, with no subscription:

- Scraper health check → Slack · Watches a scraper and the endpoint it feeds, every six hours, and posts unhealthy verdicts to a channel. 2 checks × 4 runs a day ≈ $4.90 a month.
- Daily API key + quota watchdog → Gmail · Validates three API keys once a day and emails you before a dead key takes the pipeline down with it. 3 keys × 1 run a day ≈ $1.83 a month.
- Actor output drift monitor → email · Checks one Apify actor a day for schema drift, volume drops, and staleness, and emails on anything unhealthy. 1 actor × 1 run a day ≈ $0.61 a month.

Full setup steps, the input JSON reference, and the verdict schema live on the n8n integration page.

## You design the checks. The list is just the head start.

One thing the templates can make easy to miss: none of this is fixed to a vendor list. Every check is a small block of JSON that you write, so Datasource Pulse watches whatever you point it at. Any HTTP endpoint, any API key, any Apify actor, including services we have never heard of. If it has a URL, it can have a health check.

The 35+ vendors that come pre-wired (OpenAI, Anthropic, Stripe, GitHub, and the rest) are there so your first checks take thirty seconds instead of an afternoon, with each vendor’s credential and quota quirks already handled. We keep wiring more, but the list is a head start, not a limit: anything missing from it is one generic_http block away, today, without waiting on us. And if you are an agent reading this, the same applies to you: the input schema is public, and any check you can describe in JSON is a check you can run.

## Four things that will bite you, so they bite you here instead

We import-tested these in a clean workspace this week and hit every one of the following. Learn from our morning:

- Imports merge into whatever workflow is open. Create a fresh empty workflow first, then use Import from File, or you will find three schedules sharing one canvas.
- Operation names drift between node versions. The current Apify node calls the right operation “Run an Actor and Get Dataset”. If an older tutorial names something close but not identical, trust the dropdown, not the tutorial. Our templates are current as of this week.
- Create the Apify credential from inside the node. The “Connect to Apify” button in the node panel gets you the right credential type with one OAuth click.
- Leave Timeout and Build Tag empty. Empty means sensible defaults: wait as long as the check needs, run the newest build.

## An alarm you have never heard ring is a liability

Whatever monitoring you set up, in n8n or anywhere else, break something on purpose once. Point a check at a URL that does not exist, watch the alert arrive, then swap in the real thing. The thirty seconds of staged failure is what turns “we have monitoring” into “we have monitoring we have heard.”

Datasource Pulse watches the data sources your product depends on: credentials, quotas, and scraper output quality. One alert when something degrades, one notice when it recovers.
Run it on Apify (https://datasourcepulse.com/agents/) Get the n8n templates Back to datasourcepulse.com

Datasource Pulse

The heartbeat monitor for your data supply chain.

Datasource Pulse monitors Apify Actors for failures and failed runs, plus API credentials, usage quotas, and scraper output quality across your data pipeline. It knows when your SerpAPI quota runs out, when your GitHub PAT expires, and when the TikTok or LinkedIn Actor your pipeline depends on ships a changed output schema. Its maintainer’s decision, not yours. One alert when something degrades, one notice when it recovers. Runs on your schedule as an Apify Actor · $0.02 per check, billed per connector, no subscription.

Run it on Apify (https://datasourcepulse.com/agents/) Blog · For Agents · n8n · Zapier · Make llms.txt · llms-full.txt

© 2026 Datasource Pulse

Monitor after you adopt. Audit before you adopt with Audit Tools (https://audit-tools.ai) · independent, evidence-backed evaluation of Apify actors. From the maker of Demand Discovery AI (https://demanddiscovery.ai).

---

# Page: https://datasourcepulse.com/blog/detect-when-an-api-key-expires-or-silently-fails

Datasource Pulse
The Problem How it Works Integrations Pricing Blog For Agents
Run it on Apify (https://datasourcepulse.com/agents/)

August 2026 · Quota watch series

# How to Detect When an API Key Expires or Silently Fails

The answer: make one small authenticated call with the key on a schedule, against the vendor’s cheapest endpoint, and classify the response instead of just checking for “not 200”. A 401 or 403 means the key itself is dead. A 429 or an empty usage counter means the key is fine but the budget behind it is gone. Anything else that answers but no longer looks like the response you expect is its own alarm. You need the scheduled call because nothing else will tell you: vendors email an expiry notice to whoever created the key, if they send one at all, and most application code swallows auth errors inside retry loops until someone asks why yesterday’s data is missing.

## Why a dead key never announces itself

An expired key does not throw an alarm anywhere you look. The job that used it often exits green: the HTTP client retried, got 401 three times, logged a warning nobody reads, and returned an empty result that the rest of the pipeline happily processed. Dashboards render yesterday’s cache. The one email the vendor sent went to the inbox of a person who set the key up two teams ago. By the time the failure is visible, it is visible as missing data, and you are debugging the pipeline instead of rotating a credential.

## The manual route: a canary call and a response you actually read

Every serious vendor has one endpoint that is cheap or free to call and requires real authentication. That is your canary. Three examples we use in our own probes, with the real field names:

GitHub: /rate_limit is authenticated, free, and does not consume quota. As a bonus, if the token has an expiration date, every response carries it in the github-authentication-token-expiration header, which is the rare advance signal in this space:
curl -sI https://api.github.com/rate_limit \
-H "Authorization: Bearer YOUR_TOKEN" \
| grep -i token-expiration

SerpAPI: https://serpapi.com/account?api_key=KEY returns plan_searches_left, this_month_usage, and extra_credits. A dead key gets a 401. A live key with plan_searches_left plus extra_credits at zero is the silent-failure case: every search from here on fails while the key itself is perfectly valid.

OpenAI: a GET to /v1/models validates the key without spending a token. The trap here is 429: it can mean a rate limit, which passes, or it can carry the error code insufficient_quota in the body, which means your key works and your account cannot pay. Those need opposite responses from you, and only the body tells them apart.

The mistake in most homemade checkers: collapsing everything into “up” or “down”. A key check has at least four distinct outcomes: the key is dead (401, and on some vendors 403), the budget is exhausted, you are temporarily rate limited, or the response no longer has the fields your parser expects. A checker that pages you to rotate a healthy key on a rate-limit blip trains you to ignore it, and one that reports “up” on an empty quota misses the exact failure you built it for. Building our probes, GitHub’s 403 took us a header to disambiguate: x-ratelimit-remaining at zero means rate limit, budget left means the token lost a permission.

Wrap those calls in a daily cron job that posts anything other than a clean pass to the channel where your incidents live, and you have a working manual monitor for one or two keys.

## The automated route: one JSON block per key

Datasource Pulse runs that same classification as a service: one block per credential, $0.02 per check, no subscription. A key checked daily is about $0.61 a month.
{
"type": "credential",
"id": "serpapi-prod-key",
"label": "SerpAPI · production",
"vendor": "serpapi",
"apiKey": "YOUR_KEY",
"quotaSoftCap": 4000
}

The four outcomes above come back as stable verdict strings: a dead or revoked key is state: failing with dead_token, an empty budget is quota_exhausted, a temporary throttle is rate_limited, and a response that stopped matching the vendor’s own schema is unexpected_response. Alerts fire on state transitions, not on every run, so a key that is down for six hours produces one alert and one recovery notice when it comes back, not seventy identical pages. One honest scope note: this is a dead man’s switch. It fires when a key stops working, not days before a dated expiry. Where a vendor offers an advance signal, like GitHub’s expiration header, read that too; for the majority of vendors that expire keys with no date and no warning, the switch is all there is.

## Which route should you take?

For one key at one vendor, write the cron script; the endpoints above are stable and the classification logic is an afternoon of work to get right. The automated route earns its keep when the key count grows: five keys across three vendors means five response formats, five sets of edge cases like the 403 and 429 ambiguities above, and a recovery-notice problem your one-shot script does not solve. One daily run covering every credential, with the same verdict strings across vendors, is the point where buying beats building.

Whichever route you take, trip the alarm once on purpose: run a check with a scrambled key, watch dead_token land where you expect it, then put the real key back. An alert you have never seen fire is a guess, not a monitor.

Datasource Pulse watches the data sources your product depends on: credentials, quotas, and scraper output quality. One alert when something degrades, one notice when it recovers. 35+ vendors are pre-wired as a head start, and any endpoint the list is missing is one generic_http block away.
Run it on Apify (https://datasourcepulse.com/agents/) Get the watchdog template Back to datasourcepulse.com

Datasource Pulse

The heartbeat monitor for your data supply chain.

Datasource Pulse monitors Apify Actors for failures and failed runs, plus API credentials, usage quotas, and scraper output quality across your data pipeline. It knows when your SerpAPI quota runs out, when your GitHub PAT expires, and when the TikTok or LinkedIn Actor your pipeline depends on ships a changed output schema. Its maintainer’s decision, not yours. One alert when something degrades, one notice when it recovers. Runs on your schedule as an Apify Actor · $0.02 per check, billed per connector, no subscription.

Run it on Apify (https://datasourcepulse.com/agents/) Blog · For Agents · n8n · Zapier · Make llms.txt · llms-full.txt

© 2026 Datasource Pulse

Monitor after you adopt. Audit before you adopt with Audit Tools (https://audit-tools.ai) · independent, evidence-backed evaluation of Apify actors. From the maker of Demand Discovery AI (https://demanddiscovery.ai).

---

# Page: https://datasourcepulse.com/blog/alert-when-data-feed-goes-stale

Datasource Pulse
The Problem How it Works Integrations Pricing Blog For Agents
Run it on Apify (https://datasourcepulse.com/agents/)

August 2026 · Quota watch series

# How to get an alert when a data feed goes stale

A stale feed is the nastiest data failure because nothing is red. The scraper exits zero, the API answers 200, the dashboard renders, and every record on it is from last Tuesday. Uptime monitoring cannot see this by definition: the feed is up, the data is old. What you need is a freshness alarm, and there are two working ways to build one.

## The manual route: cron plus a timestamp

The pattern behind every GitHub snippet on this topic is the same three lines of logic: find the newest timestamp your feed carries, compare its age against a threshold, and alert when the age wins. The timestamp can be a max(updated_at) in the database, the newest record’s date field in the feed itself, or the HTTP Last-Modified header if the source is well behaved:
newest = max(record.updated_at for record in feed)
age_hours = (now_utc - newest) / 3600
if age_hours > 26: alert(f"feed stale: {age_hours:.0f}h old")

Three traps take down most homemade versions. Compare in UTC on both sides, because a timezone-naive timestamp makes the feed look eight hours stale or eight hours fresh depending on where your server lives. Set the threshold slightly past the update cadence, not at it: a daily feed deserves a 26-hour threshold, so one slow run does not page anyone. And treat an empty feed as its own alarm, not as fresh: an empty array is valid JSON with no timestamps in it, and max() of nothing either throws or, worse, gets defaulted to “now”.

## The automated route: freshness as a named detection

If the feed is produced by a scraper or actor on Apify, yours or one you merely depend on, Datasource Pulse watches its freshness from the supply side with one JSON block:
{
"type": "actor",
"id": "listings-feed",
"label": "Listings feed · source actor",
"actorId": "OWNER~ACTOR-NAME",
"apifyToken": "YOUR_READ_TOKEN",
"enableVolumeBaseline": true,
"stalenessThresholdDays": 30
}

Three of its verdict classes are staleness in different disguises. zero_yield fires when runs keep succeeding while returning nothing, three runs in a row by default, which is exactly the “exit zero, deliver nothing” case that keeps a feed frozen. volume_drop catches the feed thinning out against its own learned baseline before it stops entirely. And actor_stale fires when the actor itself has not been updated past your threshold, the early warning that an abandoned scraper is about to become a stale feed. Each alert names the class and the numbers, and a recovery notice follows when the feed comes back.

Honest scope note: for a feed that is just an HTTP endpoint with no Apify actor behind it, Datasource Pulse’s generic_http check will catch the feed dying, changing shape, or losing auth, but the timestamp-age comparison itself stays your cron script’s job for now. The two compose well: cheap freshness math where the data lands, supply-side detection where it is produced.

Each check costs $0.02, billed per run through Apify with no subscription; one feed watched daily is about $0.61 a month. The actor output drift template for n8n emails you on anything unhealthy, and the Zapier and Make routes do the same with webhooks.

## Which route should you take?

Honest answer: if you have one feed, one database, and a place to run cron, the timestamp script is the right tool and takes an afternoon including the Slack webhook. The automated route earns its keep when the feed depends on scrapers you do not control, when “successful but empty” runs are your actual failure mode, or when one stale feed is really five sources feeding one pipeline and you want one daily run with recovery notices instead of five scripts.

Either way, trip the alarm once on purpose: set the threshold below the feed’s current age, watch the alert arrive, then set it back. An alert you have never seen fire is a guess, not a monitor.

Datasource Pulse watches the data sources your product depends on: credentials, quotas, and scraper output quality. One alert when something degrades, one notice when it recovers. Freshness checks ride alongside 35+ pre-wired credential vendors, and any endpoint the list is missing is one generic_http block away.
Run it on Apify (https://datasourcepulse.com/agents/) Get the drift template Back to datasourcepulse.com

Datasource Pulse

The heartbeat monitor for your data supply chain.

Datasource Pulse monitors Apify Actors for failures and failed runs, plus API credentials, usage quotas, and scraper output quality across your data pipeline. It knows when your SerpAPI quota runs out, when your GitHub PAT expires, and when the TikTok or LinkedIn Actor your pipeline depends on ships a changed output schema. Its maintainer’s decision, not yours. One alert when something degrades, one notice when it recovers. Runs on your schedule as an Apify Actor · $0.02 per check, billed per connector, no subscription.

Run it on Apify (https://datasourcepulse.com/agents/) Blog · For Agents · n8n · Zapier · Make llms.txt · llms-full.txt

© 2026 Datasource Pulse

Monitor after you adopt. Audit before you adopt with Audit Tools (https://audit-tools.ai) · independent, evidence-backed evaluation of Apify actors. From the maker of Demand Discovery AI (https://demanddiscovery.ai).

---

# Page: https://datasourcepulse.com/blog/monitor-github-personal-access-token-expiration

Datasource Pulse
The Problem How it Works Integrations Pricing Blog For Agents
Run it on Apify (https://datasourcepulse.com/agents/)

August 2026 · Quota watch series

# How to monitor GitHub personal access token expiration

GitHub’s documentation is thorough about setting an expiration on a personal access token and thin on what happens next: an email to the token owner’s inbox as the date approaches, and then a wall of 401s. That email goes to one person, not to the channel where your incidents live, and the person who created the token is rarely the person on call when the nightly sync starts failing. Here is how to see expiry coming, and how to catch the failure the moment it lands.

## The manual route: GitHub tells you the expiry date on every call

Any authenticated API request made with a token that has an expiration set returns the exact expiry timestamp in a response header, github-authentication-token-expiration. You can read it without consuming any rate limit:
curl -sI https://api.github.com/rate_limit \
-H "Authorization: Bearer YOUR_PAT" \
| grep -i token-expiration

We point this at /rate_limit on purpose: it is the one authenticated endpoint that is free and does not count against your quota, which makes it the right target for anything that polls. A complete manual monitor is a daily job that reads the header, computes days remaining, and posts to Slack when it drops below seven. Note the header only appears when the token actually has an expiration; a classic PAT set to no expiration returns nothing, and your script should treat that as its own finding.

The trap in naive checkers: treating every non-200 as “token expired”. GitHub uses 401 for an invalid or revoked token, but 403 is ambiguous: it can mean the token lacks a permission, or that you have exhausted the rate limit and the token is perfectly fine. The tell is the x-ratelimit-remaining header: 403 with 0 remaining is a rate-limit problem, 403 with budget left is a permissions problem. We learned to split those cases building our own probe, because a monitor that pages you to rotate a healthy token is worse than no monitor.

## The automated route: a dead man’s switch in one JSON block

Datasource Pulse’s pre-wired GitHub connector runs that exact free /rate_limit probe and turns the outcomes above into stable verdict strings:
{
"type": "credential",
"id": "github-ci-pat",
"label": "GitHub PAT · CI pipeline",
"vendor": "github",
"apiKey": "YOUR_GITHUB_PAT"
}

An expired or revoked PAT comes back as state: failing with dead_token, a permissions downgrade surfaces as dead_token with a message naming the 403, and an exhausted rate limit is its own class, rate_limited, with the reset time in the alert. Healthy runs report remaining core and GraphQL budget, so quota creep is visible before it becomes a 403. One honest scope note: this fires when the token stops working or the budget runs dry, not days before an expiry date. That is what a dead man’s switch is for, and it also catches the two failures no calendar reminder ever will: an admin revoking the token early, and a permission being quietly removed from it.

Each check costs $0.02, billed per run through Apify with no subscription; one PAT checked daily is about $0.61 a month. The daily key and quota watchdog template for n8n emails you on anything unhealthy, and the Zapier and Make routes do the same with webhooks.

## Which route should you take?

Honest answer, including about the competition. If your only need is advance reminders for source-control tokens, TokenTimer is a small product that does exactly that job for SCM tokens, and the header script above gets you the same thing for free. The strongest setup pairs prevention with detection: a seven-day heads-up from the expiration header, plus a daily liveness check that tells you the moment the token actually stops working, whatever the reason. Datasource Pulse earns its keep on the detection side, and because a GitHub PAT is rarely your only credential: the same one-block-per-check pattern watches your OpenAI keys, SerpAPI quota, Stripe keys, and the rest of the 35+ pre-wired vendors from a single daily run, with recovery notices when things come back.

And whichever route you take, trip the alarm once on purpose: run a check with a scrambled token, watch dead_token arrive where you expect it, then swap the real one back in. An alert you have never seen fire is a guess, not a monitor.

Datasource Pulse watches the data sources your product depends on: credentials, quotas, and scraper output quality. One alert when something degrades, one notice when it recovers. GitHub is one of 35+ pre-wired vendors, and any endpoint the list is missing is one generic_http block away.
Run it on Apify (https://datasourcepulse.com/agents/) Get the watchdog template Back to datasourcepulse.com

Datasource Pulse

The heartbeat monitor for your data supply chain.

Datasource Pulse monitors Apify Actors for failures and failed runs, plus API credentials, usage quotas, and scraper output quality across your data pipeline. It knows when your SerpAPI quota runs out, when your GitHub PAT expires, and when the TikTok or LinkedIn Actor your pipeline depends on ships a changed output schema. Its maintainer’s decision, not yours. One alert when something degrades, one notice when it recovers. Runs on your schedule as an Apify Actor · $0.02 per check, billed per connector, no subscription.

Run it on Apify (https://datasourcepulse.com/agents/) Blog · For Agents · n8n · Zapier · Make llms.txt · llms-full.txt

© 2026 Datasource Pulse

Monitor after you adopt. Audit before you adopt with Audit Tools (https://audit-tools.ai) · independent, evidence-backed evaluation of Apify actors. From the maker of Demand Discovery AI (https://demanddiscovery.ai).

---

# Page: https://datasourcepulse.com/blog/alert-before-serpapi-quota-runs-out

Datasource Pulse
The Problem How it Works Integrations Pricing Blog For Agents
Run it on Apify (https://datasourcepulse.com/agents/)

August 2026 · Quota watch series

# How to get alerted before your SerpAPI quota runs out

SerpAPI meters by searches per month, and when the meter hits zero your searches start failing while everything downstream keeps running: rank trackers report stale positions, SEO dashboards quietly stop updating, and nobody finds out until someone asks why the numbers have not moved in four days. The fix is boring and reliable: read your own usage before the wall, not after. Here is the manual route with SerpAPI’s own account endpoint, then the automated route. Both work today.

## The manual route: SerpAPI’s account endpoint

SerpAPI exposes your live usage on a single authenticated endpoint. No SDK needed:
curl "https://serpapi.com/account?api_key=YOUR_KEY"

The response is JSON, and the four fields that matter are plan_searches_left, this_month_usage, searches_per_month and extra_credits. Percentage used is this_month_usage divided by searches_per_month.

One trap worth knowing about: several older snippets floating around read a field called total_searches_used from this endpoint. That field does not exist in the account response. In loosely typed scripts the read comes back undefined, the math coerces it to zero, and your monitor reports 0% used forever. We know because our own first probe made exactly this mistake, and it passed every test that did not compare against the real dashboard. If you write your own checker, assert that the fields you read are actually numbers before trusting the percentage.

A complete manual monitor is a scheduled job (cron, GitHub Actions, anything that runs daily) that fetches the endpoint, computes the percentage, and posts to Slack or email when it crosses a threshold. Twenty lines of code, and 80% is a good default threshold: late enough to not nag, early enough to upgrade the plan or shed load before the wall.

One refinement worth stealing whichever route you take: alert on your budget line, not just the plan wall. If your plan carries 10,000 searches but your product only budgets 4,000 a month for this pipeline, the incident that matters happens at 4,000. Track both numbers.

## The automated route: one JSON block

Datasource Pulse ships with a pre-wired SerpAPI connector that does the above, with the field pitfalls already handled. The whole check is this block:
{
"type": "credential",
"id": "serpapi-main",
"label": "SerpAPI · main account",
"vendor": "serpapi",
"apiKey": "YOUR_SERPAPI_KEY",
"quotaSoftCap": 4000
}

Each run validates the key, reads the live quota, and returns a verdict with stable strings, escalating in three steps. Crossing the warning threshold (80% by default, tunable) fires a quota warning alert while state stays healthy: a heads-up, not an incident. Crossing 100% of your quotaSoftCap, the budget line from the previous section, flips state to warning, with the vendor-account percentage always reported alongside your own. And when the meter truly hits zero (plan searches plus any extra credits), state goes to failing with quota_exhausted. A revoked key surfaces separately as dead_token, so you can tell “we ran out” from “someone rotated the key” without reading logs.

Each check costs $0.02, billed per run through Apify with no subscription. Checking one key daily is about $0.61 a month. To get the verdict somewhere useful, the daily key and quota watchdog template for n8n emails you on anything unhealthy, and the Zapier and Make routes do the same with webhooks.

## Which route should you take?

Honest answer: if you have one SerpAPI key, a place to run cron, and a Slack webhook, the manual script is a fine tool and you do not need us. The automated route earns its keep when the list grows: multiple keys across vendors, each with its own account endpoint, response shape, and dead-signal quirks, plus recovery notices when things come back and one alert instead of one per run while a problem persists. That is the part that stops being twenty lines.

Either way, do the thing most teams skip: trip the alarm once on purpose. Set the threshold below your current usage, watch the alert arrive, then set it back. An alert you have never seen fire is a guess, not a monitor.

Datasource Pulse watches the data sources your product depends on: credentials, quotas, and scraper output quality. One alert when something degrades, one notice when it recovers. SerpAPI is one of 35+ pre-wired vendors, and any endpoint the list is missing is one generic_http block away.
Run it on Apify (https://datasourcepulse.com/agents/) Get the watchdog template Back to datasourcepulse.com

Datasource Pulse

The heartbeat monitor for your data supply chain.

Datasource Pulse monitors Apify Actors for failures and failed runs, plus API credentials, usage quotas, and scraper output quality across your data pipeline. It knows when your SerpAPI quota runs out, when your GitHub PAT expires, and when the TikTok or LinkedIn Actor your pipeline depends on ships a changed output schema. Its maintainer’s decision, not yours. One alert when something degrades, one notice when it recovers. Runs on your schedule as an Apify Actor · $0.02 per check, billed per connector, no subscription.

Run it on Apify (https://datasourcepulse.com/agents/) Blog · For Agents · n8n · Zapier · Make llms.txt · llms-full.txt

© 2026 Datasource Pulse

Monitor after you adopt. Audit before you adopt with Audit Tools (https://audit-tools.ai) · independent, evidence-backed evaluation of Apify actors. From the maker of Demand Discovery AI (https://demanddiscovery.ai).

---

# Page: https://datasourcepulse.com/agents

Datasource Pulse
The Problem How it Works Integrations Pricing Blog For Agents
Run it on Apify (https://datasourcepulse.com/agents/)

For agents · Datasource Pulse

# Agent access

Three ways for an agent (or the human wiring one up) to run Datasource Pulse: Apify’s official MCP server, the plain Apify API, or the x402 endpoint that needs no account of any kind. Every snippet below is copy-paste ready; the example check pings a public URL, so no secrets are required to try it.

From the blog · July 24, 2026

An AI agent just paid our API two cents. No account. No card. No human.

The full story of the first agent payment: $0.02 in USDC on Base, settled on a public blockchain, with the transaction receipt inside.
Read the post →

## MCP

Apify runs an official MCP server; the URL below scopes it to this Actor, so a connected agent sees Datasource Pulse as a callable tool with its full input schema. Works today in any MCP client. Bring an Apify token; clients that support OAuth can omit the header and sign in instead.

{
"mcpServers": {
"datasource-pulse": {
"url": "https://datasourcepulse.com/agents/",
"headers": {
"Authorization": "Bearer YOUR_APIFY_TOKEN"
}
}
}
}

## Direct API (curl)

One synchronous call: run the Actor and get the dataset back. The response is one status record per connector checked, with a stable failure_class enum an agent can branch on.

curl -X POST \
"https://api.apify.com/v2/acts/<apify account · current handle at /agents/>~datasource-pulse/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"checks": [{
"type": "credential",
"id": "public-ping",
"label": "Public ping - GitHub Zen",
"vendor": "generic_http",
"url": "https://api.github.com/zen",
"successStatusCode": 200
}]
}'

## LangChain

Via Apify’s official LangChain integration. The tool exposes the same JSON input; results come back as the run’s dataset records.

# pip install langchain-apify
# export APIFY_API_TOKEN=your_token
from langchain_apify import ApifyActorsTool

tool = ApifyActorsTool("<apify account · current handle at /agents/>/datasource-pulse")
result = tool.invoke(input={"run_input": {"checks": [{
"type": "credential",
"id": "public-ping",
"vendor": "generic_http",
"url": "https://api.github.com/zen",
"successStatusCode": 200
}]}})

## x402: no account at all

A single health check for $0.02 in USDC on Base, paid per request. No Apify account, no API key, no signup. Calling the endpoint unpaid returns a standard x402 v1 envelope carrying the price, the pay-to address, and the full input and output schemas: the 402 is the documentation.

curl -si -X POST https://datasourcepulse.com/api/x402/check \
-H "Content-Type: application/json" -d '{}'
# -> HTTP 402 + JSON envelope: price, pay-to, input/output schemas
Paying takes one wrapped fetch:

// npm i x402-fetch viem
import { wrapFetchWithPayment } from "x402-fetch";
import { privateKeyToAccount } from "viem/accounts";

const account = privateKeyToAccount(process.env.WALLET_KEY);
const payFetch = wrapFetchWithPayment(fetch, account);

const res = await payFetch("https://datasourcepulse.com/api/x402/check", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
vendor: "generic_http",
url: "https://api.github.com/zen",
successStatusCode: 200,
}),
});
console.log(await res.json()); // { state, failure_class,... }
The endpoint is listed in Coinbase’s public x402 catalog (the Bazaar), and every settlement is public: live payment feed on x402scan (https://www.x402scan.com/recipient/0x7cCb91a3ad4c45097bDA4C3C29d2Cc89fA93Ab36) · how the first payment went.

This origin also publishes its x402 manifest at /.well-known/x402.json: the standard DiscoveredResource envelope with full input and output schemas, so an agent can learn what is payable here without a facilitator or a prior transaction.

## Prefer an automation platform?

If the agent you are wiring up lives inside an automation platform, or you would rather not write code at all, the same checks run there too. Importable workflow templates and webhook-first recipes:

- n8n · three importable workflow templates (Slack, Gmail, and email alerts), also published on n8n.io
- Zapier · webhook-first recipes using Catch Hook
- Make · custom webhook recipes for the same alert payloads

Datasource Pulse watches the data sources your product depends on: credentials, quotas, and scraper output quality. One alert when something degrades, one notice when it recovers.
Run it on Apify (https://datasourcepulse.com/agents/) Back to datasourcepulse.com

Datasource Pulse

The heartbeat monitor for your data supply chain.

Datasource Pulse monitors Apify Actors for failures and failed runs, plus API credentials, usage quotas, and scraper output quality across your data pipeline. It knows when your SerpAPI quota runs out, when your GitHub PAT expires, and when the TikTok or LinkedIn Actor your pipeline depends on ships a changed output schema. Its maintainer’s decision, not yours. One alert when something degrades, one notice when it recovers. Runs on your schedule as an Apify Actor · $0.02 per check, billed per connector, no subscription.

Run it on Apify (https://datasourcepulse.com/agents/) Blog · For Agents · n8n · Zapier · Make llms.txt · llms-full.txt

© 2026 Datasource Pulse

Monitor after you adopt. Audit before you adopt with Audit Tools (https://audit-tools.ai) · independent, evidence-backed evaluation of Apify actors. From the maker of Demand Discovery AI (https://demanddiscovery.ai).

---

# Page: https://datasourcepulse.com/integrations/n8n

Datasource Pulse
The Problem How it Works Integrations Pricing Blog For Agents
Run it on Apify (https://datasourcepulse.com/agents/)

Integrations · n8n

# Monitor scrapers, APIs, and keys from n8n

Datasource Pulse runs as an Apify Actor, and Apify ships a verified community node for n8n - so a health pass over your scrapers, endpoints, and API keys is one node in a workflow. No custom code, no separate account: your existing Apify credential runs everything, billed at $0.02 per check.

## Ready-made workflows

Three importable templates. Download the JSON, then in n8n choose Workflow → Import from File, connect your Apify credential, and replace the placeholders flagged in the sticky note inside each workflow.

### Scraper health check → Slack alert

Every 6 hours: one pass over your scraper and the endpoint it feeds. Unhealthy verdicts become Slack messages with the failure class and what breaks downstream.

Cost on your Apify account: 2 checks × 4 runs/day ≈ $4.90/month
Download workflow JSON

### Daily API key + quota watchdog → Gmail

Every morning: validates your keys against the live vendor APIs (35+ vendors pre-wired, plus generic_http for any endpoint you add) and checks usage against your own budget caps. A silently revoked key or a blown quota lands in your inbox, not in production.

Cost on your Apify account: 3 keys × 1 run/day ≈ $1.83/month
Download workflow JSON

### Actor output drift monitor → email

Daily: baselines a watched actor’s recent runs and alerts on volume drops, cost spikes, and staleness - the quiet failure modes where a scraper keeps running but the data degrades.

Cost on your Apify account: 1 actor × 1 run/day ≈ $0.61/month
Download workflow JSON

Want proof the alarm rings before you trust it with production? We broke an endpoint on purpose and timed how long Slack took to hear about it.

## How it works

Install the Apify node once (n8n Cloud: open the nodes panel, search “Apify”, Install; self-hosted: Settings → Community Nodes → @apify/n8n-nodes-apify ). Then a single node runs the whole health pass: resource Actors, operation Run an Actor and Get Dataset, actor <apify account · current handle at /agents/>~datasource-pulse, and your checks as the Input JSON:

{
"checks": [
{
"type": "credential",
"id": "openai-prod",
"label": "OpenAI · production key",
"vendor": "openai",
"apiKey": "YOUR_OPENAI_KEY",
"impact": "LLM features fail when this key dies"
},
{
"type": "actor",
"id": "my-scraper",
"label": "My scraper · output drift",
"actorId": "username~my-scraper",
"apifyToken": "APIFY_TOKEN_WITH_READ_SCOPES",
"enableVolumeBaseline": true,
"enableCostBaseline": true
}
]
}
The node returns one item per check, so standard n8n routing applies from there. Each verdict carries state, a stable failure_class enum, a human-readable message, and your own impact note echoed back - so the alert answers “what breaks?” by itself. An IF node on state ≠ healthy feeds Slack, Gmail, or anything else n8n talks to.

## Common questions

### Can n8n monitor an Apify actor for silent failures?

Yes. An actor check baselines recent runs and flags volume drops, cost spikes, and staleness - failure modes that never throw an error. It works for your own actors and for public actors you depend on.

### How do I get alerted in n8n when an API key stops working?

A credential check calls the vendor’s live API with your key and classifies the result: dead credential, rate limited, quota exhausted, or healthy. Schedule it daily and route anything unhealthy to your alert channel - the API key + quota watchdog template above is exactly that.

### What does it cost?

$0.02 per check per run, billed through your Apify account (pay-per-event, no subscription). A daily three-key watchdog is about $1.83/month.

Also available: Zapier · Make · agent access (MCP, API, x402)
Run it on Apify (https://datasourcepulse.com/agents/) Back to datasourcepulse.com

Datasource Pulse

The heartbeat monitor for your data supply chain.

Datasource Pulse monitors Apify Actors for failures and failed runs, plus API credentials, usage quotas, and scraper output quality across your data pipeline. It knows when your SerpAPI quota runs out, when your GitHub PAT expires, and when the TikTok or LinkedIn Actor your pipeline depends on ships a changed output schema. Its maintainer’s decision, not yours. One alert when something degrades, one notice when it recovers. Runs on your schedule as an Apify Actor · $0.02 per check, billed per connector, no subscription.

Run it on Apify (https://datasourcepulse.com/agents/) Blog · For Agents · n8n · Zapier · Make llms.txt · llms-full.txt

© 2026 Datasource Pulse

Monitor after you adopt. Audit before you adopt with Audit Tools (https://audit-tools.ai) · independent, evidence-backed evaluation of Apify actors. From the maker of Demand Discovery AI (https://demanddiscovery.ai).

---

# Page: https://datasourcepulse.com/integrations/zapier

Datasource Pulse
The Problem How it Works Integrations Pricing Blog For Agents
Run it on Apify (https://datasourcepulse.com/agents/)

Integrations · Zapier

# API and scraper health alerts in Zapier

Two ways to wire Datasource Pulse into Zapier: run scheduled health checks through Apify’s official Zapier integration, or let Datasource Pulse push state-change alerts into a Zap the moment something breaks. Both use your existing accounts - no new integration to install. Or skip the wiring and start from a guided template below.

## Fastest path · three guided templates

Each link opens a pre-built Zap: trigger, subject lines, and formatting done, with one decision left - where alerts go. Publish it, then paste your hook URL into the Apify schedule input shown on the template page.

### Scraper or endpoint failures → Slack

State-change alerts only: a Slack message when a scraper or the endpoint it feeds degrades, and one more when it recovers - with the failure class and what breaks downstream.
Open the template in Zapier (https://zapier.com/templates/details/get-slack-alerts-when-datasource-pulse-detects-scraper-or-endpoint-failures-f4a2cb?secret=MTp0ZW1wbGF0ZTppYnp4TUpva0hZSXdEMVJGZkQySWJzMVdvM0w0Yng0bXhBRVhjNFNlaHNBOnI2am0zNA)

### Dead API keys + quota risks → Gmail

Every morning: validates each key against the live vendor API and checks usage against your own budget caps. A revoked key or a quota near its cap lands in your inbox, not in production.
Open the template in Zapier (https://zapier.com/templates/details/get-gmail-alerts-when-datasource-pulse-finds-dead-api-keys-or-quota-risks-f40737?secret=MTp0ZW1wbGF0ZTowN2syUTBpOVBWcFM0U0ZCazh6TlI3QkI4RGM5NVRYMUdQMnpobkVETDBzOnhlb2RnYg)

### Actor output drift → email

Daily: baselines a watched actor and emails you when volume drops, costs spike, or output goes stale. Sends through Email by Zapier, so there is no email account to connect.
Open the template in Zapier (https://zapier.com/templates/details/get-email-alerts-when-an-apify-actors-output-drifts-with-datasource-pulse-d61a73?secret=MTp0ZW1wbGF0ZTpVYnYtSlZ0dl9oUENmOFF6U2VNdHl6UHAtZ0tEcVNOeXozUmFoTHQxWVpFOnp3N29obw)

Guided templates use Webhooks by Zapier, a premium app, so they need a paid Zapier plan or an active trial. Checks themselves run on your Apify account at $0.02 each. On the free Zapier tier? The n8n templates cover the same three alarms.

## Path 1 · Instant alerts via webhook (recommended)

Datasource Pulse fires a JSON POST on every state transition - when a connector degrades and once when it recovers, not a message per run. Point that at a Zapier catch hook and every alert becomes a Zap trigger:

1. In Zapier, create a Zap with the Webhooks by Zapier trigger, event Catch Hook, and copy the hook URL.
2. In your Datasource Pulse input (wherever you run it - an Apify schedule works well), set:

{
"checks": [...your checks... ],
"webhookUrl": "https://hooks.zapier.com/hooks/catch/...",
"webhookFormat": "json",
"webhookSecret": "optional · adds X-DP-Signature for verification"
}
3. The hook receives top-level fields like transition, connector_label, failure_class, message, and recommended_action - map them straight into Slack, email, PagerDuty, a ticket, or any of Zapier’s apps. No polling, no filter step needed: only real transitions arrive.

## Path 2 · Scheduled checks inside a Zap

If you’d rather keep the schedule in Zapier: trigger with Schedule by Zapier, add the Apify app’s run-actor action for <apify account · current handle at /agents/>/datasource-pulse with the input below, fetch the run’s dataset items, then add a Filter step that only continues when state is not healthy:

{
"checks": [
{
"type": "credential",
"id": "openai-prod",
"label": "OpenAI · production key",
"vendor": "openai",
"apiKey": "YOUR_OPENAI_KEY",
"impact": "LLM features fail when this key dies"
},
{
"type": "credential",
"id": "feed-endpoint",
"label": "Data endpoint · reachable",
"vendor": "generic_http",
"url": "https://example.com/api/data",
"successStatusCode": 200
}
]
}
Each dataset item is one verdict with state, a stable failure_class enum (dead credential, rate limited, quota exhausted, schema drift, stale data, and more), and a plain-language message. Checks cost $0.02 each on your Apify account.

## Common questions

### Can Zapier tell me when an API key stops working?

Yes - Datasource Pulse validates keys against the live vendor APIs. 35+ vendors come pre-wired (OpenAI, Anthropic, Stripe, GitHub, SerpAPI and more), and any other endpoint takes one generic_http check, so the list is a head start, not a limit. Either path above turns an unhealthy verdict into any Zapier action you like.

### Which path should I pick?

The webhook path alerts only on change and saves Zap tasks; run the checks on an Apify schedule. Pick the scheduled path when you want everything visible in one Zap, or when the verdict should drive a multi-step workflow every run.

### How do I verify an alert really came from Datasource Pulse?

Set webhookSecret and every POST carries an X-DP-Signature HMAC header your receiver can check before acting.

Also available: n8n (with ready-made templates) · Make · agent access (MCP, API, x402)
Run it on Apify (https://datasourcepulse.com/agents/) Back to datasourcepulse.com

Datasource Pulse

The heartbeat monitor for your data supply chain.

Datasource Pulse monitors Apify Actors for failures and failed runs, plus API credentials, usage quotas, and scraper output quality across your data pipeline. It knows when your SerpAPI quota runs out, when your GitHub PAT expires, and when the TikTok or LinkedIn Actor your pipeline depends on ships a changed output schema. Its maintainer’s decision, not yours. One alert when something degrades, one notice when it recovers. Runs on your schedule as an Apify Actor · $0.02 per check, billed per connector, no subscription.

Run it on Apify (https://datasourcepulse.com/agents/) Blog · For Agents · n8n · Zapier · Make llms.txt · llms-full.txt

© 2026 Datasource Pulse

Monitor after you adopt. Audit before you adopt with Audit Tools (https://audit-tools.ai) · independent, evidence-backed evaluation of Apify actors. From the maker of Demand Discovery AI (https://demanddiscovery.ai).

---

# Page: https://datasourcepulse.com/integrations/make

Datasource Pulse
The Problem How it Works Integrations Pricing Blog For Agents
Run it on Apify (https://datasourcepulse.com/agents/)

Integrations · Make

# Data source health alerts in Make

Datasource Pulse plugs into Make two ways: as a scheduled scenario built on Apify’s official Make app, or as an instant trigger where Datasource Pulse pushes a webhook the moment a data source degrades. Both run on your existing Apify account at $0.02 per check.

## Path 1 · Instant trigger via custom webhook (recommended)

Datasource Pulse posts JSON on every state transition - one alert when a connector degrades, one notice when it recovers. In Make that’s a native instant scenario:

1. Add a Webhooks → Custom webhook module and copy its URL.
2. Put that URL in your Datasource Pulse input (an Apify schedule is the usual runner):

{
"checks": [...your checks... ],
"webhookUrl": "https://hook.make.com/...",
"webhookFormat": "json",
"webhookSecret": "optional · adds X-DP-Signature for verification"
}
3. Run it once so Make learns the payload structure, then route transition, connector_label, failure_class, message, and recommended_action into Slack, email, Telegram, or any Make module. No polling and no filter needed - only real transitions arrive.

## Path 2 · Scheduled scenario with the Apify app

To keep the schedule in Make: start a scenario with the Apify app’s Run an Actor module, pick <apify account · current handle at /agents/>/datasource-pulse, paste the input below, wait for finish, then fetch the run’s dataset items and add a filter that passes only items where state is not healthy:

{
"checks": [
{
"type": "credential",
"id": "serpapi-main",
"label": "SerpAPI · search quota",
"vendor": "serpapi",
"apiKey": "YOUR_SERPAPI_KEY",
"quotaSoftCap": 4500,
"impact": "Search enrichment stops at quota"
},
{
"type": "actor",
"id": "my-scraper",
"label": "My scraper · output drift",
"actorId": "username~my-scraper",
"apifyToken": "APIFY_TOKEN_WITH_READ_SCOPES",
"enableVolumeBaseline": true,
"enableCostBaseline": true
}
]
}
Each dataset item is one verdict: state, a stable failure_class enum, a human-readable message, and your own impact note echoed back, so the alert itself says what breaks downstream.

## Common questions

### Can Make monitor scrapers that fail silently?

Yes. An actor check baselines recent runs and flags volume drops, cost spikes, and staleness - the cases where a scraper still finishes green but returns thin or stale data. Works for your own actors and public actors you depend on.

### Quota warnings before a hard stop?

Set quotaSoftCap on a credential check - your own budget line in the vendor’s native unit - and you get a warning when usage crosses 80% of it (configurable), with the vendor-account percentage shown alongside.

### What does it cost?

$0.02 per check per run through your Apify account, pay-per-event. A daily two-check scenario is about $1.22/month.

Also available: n8n (with ready-made templates) · Zapier · agent access (MCP, API, x402)
Run it on Apify (https://datasourcepulse.com/agents/) Back to datasourcepulse.com

Datasource Pulse

The heartbeat monitor for your data supply chain.

Datasource Pulse monitors Apify Actors for failures and failed runs, plus API credentials, usage quotas, and scraper output quality across your data pipeline. It knows when your SerpAPI quota runs out, when your GitHub PAT expires, and when the TikTok or LinkedIn Actor your pipeline depends on ships a changed output schema. Its maintainer’s decision, not yours. One alert when something degrades, one notice when it recovers. Runs on your schedule as an Apify Actor · $0.02 per check, billed per connector, no subscription.

Run it on Apify (https://datasourcepulse.com/agents/) Blog · For Agents · n8n · Zapier · Make llms.txt · llms-full.txt

© 2026 Datasource Pulse

Monitor after you adopt. Audit before you adopt with Audit Tools (https://audit-tools.ai) · independent, evidence-backed evaluation of Apify actors. From the maker of Demand Discovery AI (https://demanddiscovery.ai).

---

# Page: https://datasourcepulse.com/blog/detect-scraper-output-schema-changes

Datasource Pulse
The Problem How it Works Integrations Pricing Blog For Agents
Run it on Apify (https://datasourcepulse.com/agents/)

August 2026 · Datasource Pulse

# How to Detect When a Scraper’s Output Schema Changes

The answer: fingerprint the fields of a known-good run, then compare a sample of every new run against that fingerprint and alert at two severities. A field that was present in nearly every record and is now missing or null in most of them is a break; a field that still exists but is increasingly empty is a warning. You need the fingerprint because a schema change never throws an error: the scraper exits green, the JSON still parses, and the first symptom anyone sees is a downstream column full of nulls, days later.

## Why a renamed field is the quietest failure in the stack

When a maintainer renames jobTitle to job_title, nothing breaks loudly. Run status: succeeded. Item count: normal. Your pipeline reads the old path, gets undefined, and writes it somewhere as an empty value, which most schemas happily accept. Uptime monitors see 200s. Run-status monitors see green. The only thing that changed is that a slice of your data went hollow, and the only way to see that is to look at the shape of the output itself.

## The manual route: a fingerprint and a diff

The core loop fits in a shell script. Take the latest output, list which fields are filled at what rate, and diff that against the same list from a run you trust:
# fill rate per field across a sample of items
jq -r '.[] | to_entries[] | select(.value!= null and.value!= "")
|.key' sample.json | sort | uniq -c | sort -rn

Run that against a saved known-good sample and against each new run, compare the two lists, and you have a working schema-drift detector. The logic is genuinely simple. What makes homemade versions page people at 3 a.m. is three traps that are not simple, and we hit all three building ours:

Trap one: sampling from the top. Many scrapers emit items in clusters: a places scraper can return every open business first and every closed one last, with different fields filled in each. Fingerprint the first ten items and you learn the shape of the first cluster, not the dataset. Draw the sample from spread positions instead: first, middle, last.

Trap two: alerting on sparse fields. Some fields are legitimately empty on a third of records or more. Check ten items against a field that is 70% filled on a good day and simple binomial variance will hand you a false alarm on a meaningful fraction of perfectly healthy runs, which is how a monitor teaches its owner to ignore it. Sparse fields should be checked for presence only, and emptiness thresholds belong only on fields that are nearly always filled.

Trap three: comparing across different inputs. The same scraper pointed at a different target legitimately returns a different shape. A baseline is only valid for one configuration; when the input changes, the old fingerprint must be thrown away and relearned, not diffed against.

## The automated route: the same math as a service

Datasource Pulse runs this exact comparison on every check. It samples up to ten items, drawn from spread positions rather than the top of the file, and validates them against a curated field fingerprint or, for generic scrapers, a baseline learned from your own recent runs. Two severities come back under the schema_drift failure class: a required field missing in most of the sample is a break, a usually-filled field going hollow past its threshold is a warning. Alerts fire on state transitions only, so a drifted schema produces one alert and one recovery notice, not a page per run.
{
"type": "actor",
"id": "linkedin-scraper-watch",
"label": "LinkedIn jobs scraper",
"actorId": "OWNER~ACTOR_NAME",
"apifyToken": "YOUR_APIFY_TOKEN"
}

Two honest scope notes. First, if there is no curated fingerprint and no established baseline yet, the check skips the schema verdict rather than guessing; the baseline needs a few successful runs before it is trusted, and the other alarms cover you in the meantime. Second, this watches the shape of the data, not its truth: a field that exists and is filled with the wrong value is a correctness problem no fingerprint can catch. Shape drift is simply the earliest signal that something upstream changed, which is why it is the one worth automating.

## Which route should you take?

For one scraper with a stable query, the jq script plus a saved known-good sample is an honest afternoon of work, provided you respect the three traps. The automated route earns its keep the same way it does for API keys: more scrapers means more fingerprints to maintain, more sparse-field judgment calls, and a recovery-notice problem the script does not solve. At $0.02 per check with a daily schedule, a watched scraper costs about $0.61 a month. If the scraper is a Store actor you did not build, the same check also watches failed runs, zero-yield runs, and maintainer staleness; that lane has its own guide.

Whichever route you take, trip the alarm once on purpose: rename a field in a copy of your known-good sample, run the comparison, and watch the drift verdict land where you expect it. An alert you have never seen fire is a guess, not a monitor.

Datasource Pulse watches the data sources your product depends on: Apify Actors, credentials, quotas, and scraper output quality. One alert when something degrades, one notice when it recovers. Any endpoint. 35+ vendors pre-wired, and the list is a head start, not a limit.
Run it on Apify (https://datasourcepulse.com/agents/) Get the n8n templates Back to datasourcepulse.com

Datasource Pulse

The heartbeat monitor for your data supply chain.

Datasource Pulse monitors Apify Actors for failures and failed runs, plus API credentials, usage quotas, and scraper output quality across your data pipeline. It knows when your SerpAPI quota runs out, when your GitHub PAT expires, and when the TikTok or LinkedIn Actor your pipeline depends on ships a changed output schema. Its maintainer’s decision, not yours. One alert when something degrades, one notice when it recovers. Runs on your schedule as an Apify Actor · $0.02 per check, billed per connector, no subscription.

Run it on Apify (https://datasourcepulse.com/agents/) Blog · For Agents · n8n · Zapier · Make llms.txt · llms-full.txt

© 2026 Datasource Pulse

Monitor after you adopt. Audit before you adopt with Audit Tools (https://audit-tools.ai) · independent, evidence-backed evaluation of Apify actors. From the maker of Demand Discovery AI (https://demanddiscovery.ai).

---

# Page: https://datasourcepulse.com/blog/two-scrapers-changed-their-output-schema-drift-case-study

Datasource Pulse
The Problem How it Works Integrations Pricing Blog For Agents
Run it on Apify (https://datasourcepulse.com/agents/)

August 6, 2026 · Case study

# Two scrapers changed their output on the same week. Triage took one question.

This week our own monitoring flagged schema drift on two Apify Store scrapers we depend on: a Reddit scraper stopped returning post titles and community names, and the Instagram scraper dropped alt text, image dimensions, and tagged users. Both runs exited green. Both datasets parsed fine. Without a fingerprint comparison, nothing anywhere would have looked wrong. Here is the full incident, timestamps and all, and the one question that resolved it in minutes: do we even read those fields?

## What the alerts said

We run Datasource Pulse on our own stack daily. The 06:00 UTC run on August 5 came back 38 healthy, 3 failing. One failure was a known rate-limit flap. The other two were new, both filed under the schema_drift failure class at high severity:
reddit scraper: field(s) [parsedCommunityName, title]
missing in >5/10 sampled items
instagram scraper: field(s) [alt, originalHeight,
originalWidth, taggedUsers]
missing in >5/10 sampled items

A single drifted run can be noise: a bad sample, a partial response, a vendor hiccup. So the first move was no move. The next scheduled run, roughly thirty hours later, reported the identical field lists on both scrapers. Two consecutive runs with the same missing fields upgraded the verdict from possibly transient to confirmed: the vendors changed what they ship.

## The triage question nobody starts with

The instinct when a vendor drifts is to open the vendor's changelog, or their issue tracker, or a support ticket. All of that is the slow path, and most of it is someone else's queue. The fast path is one question about your own code: which of the missing fields does our pipeline actually read?

The team consuming these scrapers audited their readers the same day. The result, field by field:

Instagram: the pipeline works entirely from post captions and hashtags. Alt text, image dimensions, tagged users: none of them are read anywhere. Impact of a high-severity drift: zero.

Reddit: post titles are consumed, but they arrive from a separate search-based discovery pass, not from the scraper that drifted. Community names were read from this scraper, but as one of several redundant sources, so the pipeline degrades to still works without a code change.

Total remediation: update the stored schema baselines so the new shape is treated as normal and the alerts go quiet. No code shipped. No customer-facing data affected. The entire incident, from first alert to closed, spanned about a day, and most of that was deliberately waiting for the confirming run.

## Severity lives in the consumer, not the vendor

The uncomfortable lesson in this incident is that the vendor cannot tell you how bad a drift is, and neither can the monitor. Both scrapers genuinely lost fields; the monitor was right to call it high severity, because a missing usually-present field is exactly what a breaking change looks like from the outside. Whether it actually breaks anything is decided entirely by which fields your pipeline reads. The same drift that was harmless for this pipeline would have been a production incident for a team rendering Instagram alt text or grouping Reddit posts by community name.

That is why the triage order matters: confirm the drift is real (two consecutive runs), then interrogate your own readers, and only then, if you do read a lost field, go looking for where the data went. When you do, there are three endings. The field was renamed or moved, which is a small reader fix. The field moved behind an input option, common when scraper vendors gate detail levels to cut cost, which is a one-line input change. Or the field is genuinely gone, which is not a code fix at all but a product decision: degrade, re-source, or drop the feature that needed it.

## The counterfactual, priced

Without the fingerprint comparison, this incident has a different shape. The fields go hollow silently. Downstream tables accept the empty values, because most schemas do. Nothing pages. Weeks later a report looks thin, someone traces it backward through the pipeline, and the diagnosis that took one question now takes a day of archaeology, starting from the symptom instead of the cause. That delayed version is the normal way teams discover schema drift, and it is the expensive one even when, as here, the drift turns out not to matter.

The vigilance layer that produced the early version of the story costs almost nothing. Our own daily run checks 41 sources, scrapers, keyed APIs, public registries, and the platform quota itself, and bills well under a cent per run as the account owner; at the public Store price the same drift check is $0.02 per scraper per run, about $0.61 a month on a daily schedule. The mechanics of the fingerprint-and-diff pattern, including the sampling traps that make homemade detectors page you at 3 a.m., are in the schema drift field guide; watching a Store actor you did not build, including failed runs and maintainer staleness, has its own guide.

One caveat we are keeping in our own back pocket, and you should too: vendors that silently drop fields tend to keep drifting. The day this Reddit scraper loses comment bodies or the Instagram scraper loses captions is the day the same alert means a real incident for us. The monitor does not know the difference. The triage question does, and it takes minutes when you can start from the exact fields and the exact date they vanished.

Datasource Pulse watches the data sources your product depends on: Apify Actors, credentials, quotas, and scraper output quality. One alert when something degrades, one notice when it recovers. Any endpoint. 35+ vendors pre-wired, and the list is a head start, not a limit.
Run it on Apify (https://datasourcepulse.com/agents/) Get the n8n templates Back to datasourcepulse.com

Datasource Pulse

The heartbeat monitor for your data supply chain.

Datasource Pulse monitors Apify Actors for failures and failed runs, plus API credentials, usage quotas, and scraper output quality across your data pipeline. It knows when your SerpAPI quota runs out, when your GitHub PAT expires, and when the TikTok or LinkedIn Actor your pipeline depends on ships a changed output schema. Its maintainer’s decision, not yours. One alert when something degrades, one notice when it recovers. Runs on your schedule as an Apify Actor · $0.02 per check, billed per connector, no subscription.

Run it on Apify (https://datasourcepulse.com/agents/) Blog · For Agents · n8n · Zapier · Make llms.txt · llms-full.txt

© 2026 Datasource Pulse

Monitor after you adopt. Audit before you adopt with Audit Tools (https://audit-tools.ai) · independent, evidence-backed evaluation of Apify actors. From the maker of Demand Discovery AI (https://demanddiscovery.ai).

---

# Page: https://datasourcepulse.com/blog/monitor-an-apify-actor-for-failures

Datasource Pulse
The Problem How it Works Integrations Pricing Blog For Agents
Run it on Apify (https://datasourcepulse.com/agents/)

August 2026 · Datasource Pulse

# How to Monitor an Apify Actor for Failures, Even One You Don’t Own

The answer: watch the actor’s run history and its output, not just its run status. A failed run is the easy case; any monitor catches a red run. The failures that actually cost you are the ones where the run status stays green: successful runs that deliver zero items, output whose field names quietly changed, record counts that collapsed without a single error. Reading run metadata and sampling the latest dataset through the Apify API catches both kinds, it needs only a read-scoped token, and it works on any public actor, including actors you did not build and cannot see the code of.

That last part matters because most Apify pipelines run on rented wheels. The TikTok scraper, the Google Maps scraper, the LinkedIn one: you did not write them, and the maintainer does not know you exist. When a breaking change ships, nothing in your stack crashes. Your pipeline just starts inheriting someone else’s decisions, silently. The usual conclusion is that you cannot monitor what you do not own. This post is the practical version of why that conclusion is wrong.

## What a green run status does not tell you

SUCCEEDED is a process statement, not a data statement. It means the container exited cleanly. It does not mean the scraper found anything, that the fields your parser expects still exist, or that the 900 records you got yesterday did not become 9 today. Run-status monitoring catches failed runs and timeouts, which is necessary and not sufficient: the expensive incidents are the silent ones your downstream tables discover days later.

## What you can actually see

You cannot put a log line inside code you do not control. But through the Apify API, with an ordinary read-scoped token, you can see everything that matters operationally: the actor’s public release history, the metadata of recent runs, and a sample of the latest output. Datasource Pulse turns those windows into six distinct alarms, each with a stable failure_class your automation can branch on:

- actor_failed The runs stop finishing successfully. The classic failed run. Datasource Pulse tracks the most recent run and the 7-day and 30-day success rates, so one flaky retry does not page you but a real regression does.
- zero_yield Runs keep succeeding and keep delivering nothing. Consecutive successful runs that each produce zero dataset items. The run status is green the whole time; the output is empty. This is the failure that looks like success, and run-status monitoring cannot see it by definition.
- schema_drift The field names in the output changed. A renamed or dropped field is the silent killer: nothing errors, and every downstream join quietly starts returning nulls. The probe samples items from the latest successful run and compares them against a learned baseline.
- volume_drop The record count fell below its rolling baseline. Nine hundred rows yesterday, ninety today, zero error messages. This signal is a per-check toggle, for reasons covered below.
- cost_spike Compute cost per run climbed above its baseline. The failure mode that shows up on your bill instead of in your data. Also a per-check toggle.
- actor_stale The maintainer stopped shipping. If the actor has not been updated in longer than your threshold, you get a heads-up. Not an outage, a forecast: unmaintained scrapers break on the next platform change.

## One block of JSON

A watch on someone else’s actor is one entry in the checks array of the Datasource Pulse input. Here is a real one, pointed at a popular TikTok scraper:

{
"type": "actor",
"id": "tiktok-scraper-watch",
"label": "clockworks TikTok Scraper",
"actorId": "clockworks~tiktok-scraper",
"apifyToken": "YOUR_APIFY_TOKEN",
"enableVolumeBaseline": false,
"enableCostBaseline": false,
"stalenessThresholdDays": 30
}
The probe is read-only: it looks at the actor record, run metadata, and a dataset sample, and never executes the actor itself. It starts no runs and adds nothing to anyone’s compute bill, so a token scoped to Actor and run read access is all it needs, and a slow multi-phase scraper does not slow the check. A typical healthy check answers in one to three seconds.

## The false-alarm footnote

The volume and cost baselines assume the same query runs repeatedly. If you run the actor with different inputs each time, different search terms, different targets, leave both baseline toggles off, exactly as in the block above. The always-on signals, failed runs, zero yield, schema drift, and staleness, still cover you, and you skip the false alarms entirely.

## What it costs

Two cents per check, charged per attempt, with no subscription and no start fee. Dependency actors change on release cadence, not by the hour, so once a day is the right frequency. That works out to about $0.61 a month to watch one actor. If the scraper feeds anything a customer sees, that is the cheapest insurance in your stack.

## Three ways to switch it on

- A ready-made example task. Monitor Clockworks TikTok Scraper for failures and drift (https://datasourcepulse.com/agents//examples/clockworks-tiktok-scraper-health-monitor) is a one-click task: open it, swap in your token and actor ID, hit Run.
- The n8n route. The actor output drift monitor template on the n8n integration page wraps the same check in a daily schedule and emails you anything unhealthy.
- A plain Apify schedule. Paste the block into the actor’s input on the Datasource Pulse page (https://datasourcepulse.com/agents/) and attach a daily schedule in the Apify console. No other tooling required.

## Where the other monitors end

To be fair to the landscape: Apify’s built-in monitoring is free on every plan and alerts on run status, run metrics, and, if you configure a dataset schema, on output validation too. Community monitors in the Store watch failed runs, empty datasets, and long runs for actors in your own account, and do it well. Both stop at the same two boundaries. They watch actors you own, not the Store dependencies you rent, and they watch the actor alone, not the API keys, quotas, and vendor endpoints around it that fail just as silently. Those two boundaries are exactly where the six alarms above take over. The credential half of that story, dead keys, exhausted quotas, and the four verdict classes that separate them, has its own field guide.

Datasource Pulse watches the data sources your product depends on: Apify Actors, credentials, quotas, and scraper output quality. One alert when something degrades, one notice when it recovers. Any endpoint. 35+ vendors pre-wired, and the list is a head start, not a limit.
Run it on Apify (https://datasourcepulse.com/agents/) Get the n8n templates Back to datasourcepulse.com

Datasource Pulse

The heartbeat monitor for your data supply chain.

Datasource Pulse monitors Apify Actors for failures and failed runs, plus API credentials, usage quotas, and scraper output quality across your data pipeline. It knows when your SerpAPI quota runs out, when your GitHub PAT expires, and when the TikTok or LinkedIn Actor your pipeline depends on ships a changed output schema. Its maintainer’s decision, not yours. One alert when something degrades, one notice when it recovers. Runs on your schedule as an Apify Actor · $0.02 per check, billed per connector, no subscription.

Run it on Apify (https://datasourcepulse.com/agents/) Blog · For Agents · n8n · Zapier · Make llms.txt · llms-full.txt

© 2026 Datasource Pulse

Monitor after you adopt. Audit before you adopt with Audit Tools (https://audit-tools.ai) · independent, evidence-backed evaluation of Apify actors. From the maker of Demand Discovery AI (https://demanddiscovery.ai).

---

- Index for LLMs: https://datasourcepulse.com/llms.txt
- Crawl policy: https://datasourcepulse.com/robots.txt · Sitemap: https://datasourcepulse.com/sitemap.xml