Network shows every request a run makes: the page's own requests (from the browser), your nodes' requests (HTTP Request, Code, integrations) and the engine's (an AI agent's model, MCP and HTTP tools). Rules change requests while your flow runs: block them, answer them yourself, change them, slow them down or hold them so you can edit them. Timeline shows where the run's time went.
Both are windows in the bottom area, next to Logs.
What gets recorded
The flow's Network › Rules › Record setting decides:
| Record | What you see |
|---|---|
| Nothing | No requests (rules still work) |
| Pages, API calls and sockets (default) | Pages, fetch/XHR calls, WebSockets and event streams, plus every node and engine request |
| Every request | Also scripts, styles, images and other files |
Each request shows its method, status, URL, type, source (Page, Nodes, Engine) and time. Clear the list (the ⊘ button) empties it; the run's saved requests come back when you open the run again. Open a request for the same tabs as Chrome's DevTools:
| Tab | What it shows |
|---|---|
| Headers | General (URL, method, status, remote address, protocol h2/h3, type, source, node, size, from cache), then response and request headers |
| Payload | Query string parameters and form data as tables, a JSON payload as a tree |
| Preview | JSON as a tree you can fold, HTML rendered (without its scripts), other text as it is |
| Response | The body: JSON indented, anything else as it came. Text bodies up to 256 KB; binary bodies (images, files) show their size only |
| Timing | Where a page request's time went (stalled, DNS, connection, SSL, request sent, waiting for the first byte, download), its total, and its initiator (the script and line, or the node) |
| Messages | A WebSocket's or event stream's messages (the last 200); a JSON message opens as a tree |
Requests a run makes between steps (a page that keeps polling) belong to the run but to no node. A popup belongs to the run of the page that opened it.
Hidden values
Cookies, Authorization and other session headers always show as ••••, and so do values whose names look secret (token, password, session, csrf, api_key…) in URLs and bodies, and your credentials' secrets. Nobody sees an account's session in Network, and neither does the AI.
Do something with a request
| Button | What it does |
|---|---|
| Resend | Sends the page's request again from the run's page, with the page's cookies. Only while the run still holds its browser windows. Hidden values aren't sent; the page's own cookies are |
| cURL / fetch | Copies the request as a command or as JavaScript (hidden values left out) |
| Make node | Adds a node that makes this request: a page's request becomes a Run script node (the page's session goes with it), a node's or the engine's an HTTP Request node |
Example: a site loads its posts from https://example.com/api/feed?page=2. Filter Network by api/feed, open the request, click Make node, and your flow reads the feed directly instead of scrolling the page.
Tamper rules
Open Network › Rules › Add rule. A rule says which requests it matches, when it acts, and what it does.
Matching
- URL: a pattern with
*(*api.example.com/graphql*) or a/regex/. Empty matches every request. - Method, Type, Source (Page, Nodes, Engine) and While node runs (only while that node's step runs) narrow it down.
What it does
| Do | When | Effect |
|---|---|---|
| Block it | Before it's sent | The request fails (the page sees a blocked request; a node's fetch throws) |
| Answer it here | Before it's sent | Never sent: your status, headers and body come back instead |
| Change it | Before it's sent | Send it to another URL, change headers (null removes one) or the body |
| Change it | When its answer comes | Change the status, headers or body the page or node gets |
| Slow it down | Either | Waits the given milliseconds first |
| Hold it for me | Either | The run waits for you with the request (or its answer) in an editor: Continue sends your version, Drop fails it. A hold the page made goes on unchanged after a minute |
Editing a held request
Hold it for me shows the request in the run's waiting bar, ready to change:
- Method and URL (before it's sent), or the Status (its answer).
- Headers as rows: change a value, add one, remove one.
- Query: the URL's parameters as rows; editing them rewrites the URL.
- Body as its type reads best: JSON pretty-printed and checked as you type (it goes back on one line if it came on one), a form as rows, anything else as text.
Example: hold *api.example.com/search* before it's sent, change q in Query from shoes to sandals, and Continue: the page shows the results for sandals.
Body replaces the whole body. Replace in the body finds text and swaps it, in order: [{ "find": "\"count\":0", "to": "\"count\":5" }].
Streams (event streams, a failed answer) are never held or changed, only recorded.
Example: test what happens when the site is down. Add a rule: URL *api.example.com*, Answer it here, status 503, body {"error":"down"}. Run the flow and check its error path. Turn the rule off when you're done.
Example: an AI node that always answers the same. Rule: Source Engine, URL *api.openai.com*, Answer it here, with a body in the model's answer format. Your downstream nodes now get a fixed answer to test against.
Studio runs and campaigns
Rules apply to runs you start in Studio. A rule's Campaigns too switch (off by default) also applies it to your campaigns' runs. That's useful for blocking something heavy, but leave it off for test rules: a rule that changes requests on a real run changes what really happens, like a post's text.
Runs started after you change a rule use it; runs already going keep the rules they started with.
The page's console
Network › Rules › The page's console (debug) adds the page's console messages and uncaught errors to Logs (type Page), Studio runs only. Leave it off unless you're debugging: a site can notice that it's on.
Your own console.log (and info, warn, error, debug) in a Code node always goes to Logs as type Console, with no switch. Each line shows its node (click it to open the node) and the line of your code it came from (line 3). Python's print() goes there too.
Timeline
One bar per node, from when it started to when it ended (waits included: a limit, a free browser window, waiting for you), with its requests as thin bars underneath (red: failed). Each row also shows the page's memory after the node's step (JS heap in MB and DOM nodes), which helps spot a page that keeps growing in a long run. Open a row for its number of requests and the fields it ran with, {{ }} already filled in.
When a step fails
A failed browser step also logs (level debug) the page's storage at that moment: cookie names and when they expire, and localStorage keys. Never their values. A session that expired shows up here.
FAQ
Why don't I see a request I know the page makes?
Check Record: Pages, API calls and sockets leaves out scripts, styles and images. Requests a site's service worker makes on its own may not show.
Why does Resend fail when the original worked?
Resend leaves out hidden values. A request that needs an Authorization header the page's script added (not a cookie) fails without it. Use Make node and add the header from a credential.
Do rules slow my run down?
Only the requests a rule matches pause, and only while a rule is on. With no rules, nothing is intercepted.
Can a website tell that Network is on?
Recording doesn't change what the page sees. Tamper rules and the page's console can be noticed by a careful site, so keep them for testing.