Use casesAPI debugging

Debugging APIs with yeet

Give your agent secure visibility into every request and response your APIs exchange. Ask questions, diagnose issues, and set up triggers for every 4xx/5xx.

Real-time API traffic off the wire, no database or per-event pricing
Identify status codes, p50 and p95 per endpoint, with no SDK in the app
Agent-readable. Set notifications, identify new API, change the look and feel

Claude Code v2.1.287
~/code/checkout

> checkout-api.prod.internal is returning 502s. figure out why.

●I’ll follow the failing requests down on the hosts serving them:

read the failing responses and the requests behind them
check what checkout sent to Postgres, Redis and payments while it failed
look underneath: resets, retransmits, drops and DNS answers
tell you whether it’s the code or the infrastructure, with the evidence

Watch your API health live

Give your agent a secure view of your live API traffic. Have it alert you when traffic drifts. Ask it questions to diagnose issues.

Click around, it’s interactive!

Try it yourself

Paste this prompt into your coding agent, and you'll get the same dashboard as above, but with your traffic instead of ours. Give it a try:

Set up httpscope (https://github.com/yeet-src/httpscope) on this Linux machine. Its README has a "Have an agent set it up" prompt: follow it.

Work out where I'll open the page from (this machine, or another computer through SSH or a VM's port forwarding) and make sure it's reachable there. Give me the exact address to type. If `localhost` might resolve to IPv6 and reach something else, give the 127.0.0.1 form.

`npm install` and `make bpf` run code from the repo; if your permissions block them, tell me the exact command to run myself.

Done means: the page loads for me and shows real HTTP traffic. If the machine is quiet, send a couple of harmless requests of your own (not to my services) to prove it. Explain what I'm looking at in plain language.

What your agent can answer now

Investigate symptoms

Which endpoint is slow, and how often it fails
What the 500s actually returned, and the request behind each one
Which client is in a retry storm
Which client keeps getting 401s
Did the deploy change what this endpoint returns

Understand dependencies

What checkout sent to payments while it failed
The slow query, and the one running 200 times
What the third-party API actually sent
What the webhook actually sent
How much rate-limit headroom is left per provider

View from the kernel

Who is resetting the connections
Where the kernel dropped the packets
Is the connection pool exhausted
Which process still connects to the old IP
Why the TLS handshake failed, by process

yeet for API debugging

╭┄ your host ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄╮
│                                                               │░
│  ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐  │░
│  │ gateway │ │ orders  │ │ payments│ │ worker  │ │ curl    │  │░
│  └────┬────┘ └────┬────┘ └────┬────┘ └────┬────┘ └────┬────┘  │░
│       └───────────┴───────────┼───────────┴───────────┘       │░
│                               v                               │░
│          ┌──────────────────────────────────────────┐         │░
│          │ yeet                                     │         │░
│          │ reassemble -> decode -> model            │         │░
│          │ services · endpoints · shapes · drift    │         │░
│          └──────────┬───────────────────────┬───────┘         │░
│                     │                       │                 │░
╰┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄│┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄│┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄╯░
 ░░░░░░░░░░░░░░░░░░░░░│░░░░░░░░░░░░░░░░░░░░░░░│░░░░░░░░░░░░░░░░░░░
                      │                       │
                      v                       v
            ┌───────────────────┐   ┌───────────────────┐
            │ you               │░  │ your agent        │░
            │ in a browser      │░  │ Claude Code, Codex│░
            └───────────────────┘░  └───────────────────┘░
             ░░░░░░░░░░░░░░░░░░░░░   ░░░░░░░░░░░░░░░░░░░░░

Capture

yeet taps every network interface, loopback included, and reads HTTPS inside OpenSSL and rustls before it is encrypted. No proxy, no certificate, no change to your app.

Model

Traffic becomes requests and responses, grouped into services and endpoints and tied to the process on each end. yeet learns each endpoint's status codes, latency and response shape, and flags the moment one changes.

Ask

You get live pages in a browser. Your agent asks questions in GraphQL and decides for itself what counts as a problem.

Loopback included

Local services talking over 127.0.0.1 never pass a proxy or a load balancer. The tap is on every interface, loopback included, so they show up like everything else.

Containers included

Plaintext between containers crosses their veth interfaces, which the tap is on. Each flow is joined to the process behind it, container or not.

Up in a minute

Install yeet and paste the prompt into your coding agent. A table of every API the host serves and calls is there within a minute of starting.

Watch only

It reads what crossed the wire and the TLS libraries. It never blocks, changes or replays a request, and never sends one of its own.

Make your machines readable

See what is actually happening with your APIs in < 60 secs with yeet

Get started