The observability layer for every API and tool your software depends on
One place for every external API and tool your software depends on, including the ones your AI agents call.
Latency, failures, cost, guardrails: per provider, per operation. Built for the dependency layer. Not generic APM.
Launching soon. Join early access to get first access and help shape the product.
Overview
Last 24 hours
Call volume
By provider
| Provider | p95 | Errors | Cost |
|---|---|---|---|
| OpenAI | 2.1s | 0.8% | $3,240 |
| Stripe | 450ms | 0.1% | — |
| Twilio | 980ms | 1.2% | $420 |
OpenAI
Stripe
TwilioOperations
Every API and tool your software depends on, including the ones your AI agents call
Keys hashed. Data scoped to your project. No lock-in.
The problem
Your product runs on APIs you don't control.
Your product runs on APIs you don't control. So do your AI agents. Payments, messaging, AI, auth: all in third-party infrastructure. Most teams still treat them as invisible.
External dependencies everywhere
Products rely on dozens of external APIs for payments, messaging, AI, and auth. These are infrastructure, but rarely observed like it.
Failures propagate
One dependency fails; impact spreads. You find out from support tickets and outages, not from a control plane.
Invisible costs
Usage grows quietly. Retry storms and high-cost endpoints burn budget before anyone notices.
DependWatch gives you observability over every API and tool your software depends on, including the ones your AI agents call.
What we detect
The signals your team would see in production.
🚨 OpenAI latency spike detected
P95 latency increased 240% in the last 5 minutes.
Openai🚨 Stripe paymentIntent failures
Error rate increased from 0.2% to 3.8%.
Stripe🚨 Twilio SMS retry storm
Traffic anomaly detected across SMS sends.
Twilio🚨 OpenAI cost anomaly
Projected monthly spend increased by $430.
Why logs & APM miss this
Built for the dependency layer
| Problems detected | Logs / APM | DependWatch |
|---|---|---|
| External API latency spikes | No | |
| Retry storms | No | |
| Cost explosions | No | |
| Provider outages | No |
APM and logs trace your code. DependWatch is the observability layer for the other side: every third-party API and tool your software depends on, including the ones your AI agents call. One place. Per provider. Per operation.
One place to see and act on every external dependency. Visibility and signals, not runtime enforcement. That stays in your code.
Insights we generate
From your traffic. No manual thresholds.
Slow endpoints
P95 > 2s
Cost spike
>2.5× baseline
Retry storm
Traffic anomaly
Provider degradation
Reliability drop
Platform
Observability, API Intelligence, guardrails, dependency map
One control plane for every external API your software depends on: Stripe, Twilio, OpenAI, and the rest. Including the tools your AI agents call. Analytics, guardrails, dependency map. Plus patterns for retry and fallback in your code.
API observability
Track total calls, average latency, error rate, and projected monthly spend. Provider breakdown table (calls, P50/P95, errors, cost) and real-time event stream with recent API events and recent failures.
Operation-level analytics
Pro and above. Operations table by endpoint (e.g. openai.chat.completions, stripe.paymentIntents.create). Find slow, failing, or expensive operations, not just provider totals.
API Intelligence
Pro and above. Auto-generated insights from real traffic: cost drivers, reliability issues (e.g. high error rate), slow endpoints (P95 >2s), cost spike vs prior period. No manual dashboards or threshold config.
Guardrails
Pro and above. Cost spike (>2.5× prior period), error spike, latency spike (P95 >2s), traffic anomaly (>3× baseline). Scale adds anomaly detection. Automatic flags; no threshold config required.
Dependency map
Pro and above. See every external provider and operation your project depends on: traffic, reliability score, latency, cost contribution. One view of your API dependency graph.
Protection in code, visibility here
Guardrails surface anomalies so you know when to act. Retries, fallbacks, and circuit breakers live in your code; the docs describe patterns. We monitor; you enforce.
Developer-ready onboarding
Create a project, copy your ingest key (DEPENDWATCH_INGEST_KEY), send test events from the dashboard, and instrument your app with the SDK (wrap()) in minutes. Key reveal, copy, and rotate in the UI.
Connect your coding assistant
Use DependWatch from Cursor or Claude Code via MCP: search docs, list projects, send test events, and validate integration without leaving your editor.
OpenAI, Stripe, Twilio, Resend, Clerk, Supabase, and any API or tool your software depends on, including the ones your AI agents call.
How it works
Four steps to full visibility
Project. SDK. wrap(). Dashboard. Events and guardrails appear automatically.
Create a project and copy your ingest key
Sign in, create a workspace and project. Copy the ingest key (shown once) and set it as DEPENDWATCH_INGEST_KEY.
Install the SDK
Add the DependWatch Node SDK. One dependency, no agents or proxies.
Wrap your API calls
Use wrap() around calls to OpenAI, Stripe, or any HTTP client. We record latency, status, and optional cost.
import { init, wrap } from '@dependwatch/sdk-node';
import OpenAI from 'openai';
init({ ingestKey: process.env.DEPENDWATCH_INGEST_KEY });
const openai = new OpenAI();
const result = await wrap(
{ provider: 'openai', endpoint: 'chat.completions', estimated_cost_usd: 0.002 },
async () => openai.chat.completions.create(
{ model: 'gpt-4', messages })
);
);Watch events, insights, and guardrails in DependWatch
Events are batched and sent automatically. Your dashboard shows volume, latency percentiles, error rates, projected cost, and auto-generated insights and guardrail alerts.
Developer proof
10 lines to instrument
Wrap calls. We capture latency, errors, cost, anomalies.
import { init, wrap } from '@dependwatch/sdk-node';
import OpenAI from 'openai';
init({ ingestKey: process.env.DEPENDWATCH_INGEST_KEY });
const openai = new OpenAI();
const result = await wrap(
{ provider: 'openai', endpoint: 'chat.completions', estimated_cost_usd: 0.002 },
async () => openai.chat.completions.create(
{ model: 'gpt-4', messages })
);
);Captured automatically
- Latency (P50, P95)
- Error rate
- Cost (when you pass estimated_cost_usd)
- Anomalies (spikes, retry storms)
Pricing
Simple, predictable
Plans scale with your API traffic. Early users get priority onboarding and may qualify for a founding user plan.
Early users get priority onboarding.
Free
Side projects and early experimentation.
Best for: Side projects, trials, 1–2 APIs
Pro
Production SaaS. Critical APIs.
Best for: Production apps, 3–10 APIs, guardrails
Scale
Teams. Multiple services. Full observability.
Best for: Teams, unlimited APIs, Slack, anomaly detection
Upgrade or downgrade from Billing. No lock-in. Full comparison →
Real problems, early
Catch API problems before they break your product
OpenAI cost spikes
Prompt inflation and retry storms. Before your bill explodes.
Stripe checkout failures
PaymentIntent errors and latency regressions. Before customers abandon.
Messaging reliability issues
Twilio and Resend delivery failures, rate limits. Caught early.
Auth provider outages
Clerk, Auth0, Supabase Auth failures. Before users get locked out.
Agent workflow dependency failures
Workflows span OpenAI, Notion, Slack, internal APIs. See which dependency failed or spiked.
DependWatch surfaces them automatically: every API and tool your product depends on, including the ones your AI agents call.