
Network Request Auditing
- 235 installs
- 655 repo stars
- Updated August 2, 2026
- spencerpauly/awesome-cursor-skills
network-request-auditing is a Cursor skill that inspects every fetch and XHR after browser interactions to surface failed, slow, duplicate, and suspicious network requests.
About
This skill audits a web app's network layer by driving Cursor's built-in browser and inspecting every fetch and XHR for failures, slow requests, duplicate calls, oversized payloads, and suspicious data. It classifies findings across failures, performance, security, and correctness, then reports issues with URL patterns, status codes, and recommended fixes. A developer uses it after backend or client networking changes on API-heavy pages. It relies on the cursor-ide-browser MCP's browser_network_requests tool.
- Audits every fetch/XHR via browser_network_requests
- Flags 4xx/5xx, CORS errors, slow and duplicate calls
- Detects tokens/PII in URLs and missing auth
- Classifies findings as failure, perf, security, or correctness
Network Request Auditing by the numbers
- 235 all-time installs (skills.sh)
- +27 installs in the week ending Aug 5, 2026 (Skillselion tracking)
- Ranked #155 of 596 Debugging skills by installs in the Skillselion catalog
- Data as of Aug 5, 2026 (Skillselion catalog sync)
network-request-auditing capabilities & compatibility
Free skill; requires Cursor and its built-in browser MCP.
- Capabilities
- network request audit · fetch xhr inspection · duplicate call detection · network performance audit
- Use cases
- debugging · testing · web search
- IDEs
- cursor ide
- Pricing
- Free
What network-request-auditing says it does
use browser_network_requests to audit every fetch/XHR for failures, slowness, duplicate calls, and suspicious payloads
Deep-dive **network** health using the `cursor-ide-browser` MCP.
**Duplicate calls** — same URL + method fired multiple times in one user action
npx skills add https://github.com/spencerpauly/awesome-cursor-skills --skill network-request-auditingAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 235 |
|---|---|
| repo stars | ★ 655 |
| Last updated | August 2, 2026 |
| Repository | spencerpauly/awesome-cursor-skills ↗ |
Which fetch/XHR calls are failing, slow, duplicated, oversized, or leaking sensitive data after my changes?
Auditing fetch/XHR requests in Cursor's browser for failures, slowness, duplicate calls, and leaked data.
Who is it for?
Developers debugging network health of API-heavy pages who want failed, slow, and duplicate requests surfaced.
Skip if: Static pages with little client traffic, or teams needing a formal application security assessment.
When should I use this skill?
After navigating and interacting in Cursor's browser on API-heavy pages or after backend or client networking changes.
What you get
A structured report of failed, slow, and duplicate requests with URL patterns, statuses, and recommended code changes.
- Summary counts of failed, slow, and duplicate request groups
- Issue list with URL pattern, status, and category
- Recommended next code changes or investigations
Files
Network Request Auditing
Deep-dive network health using the cursor-ide-browser MCP. This skill focuses on browser_network_requests — not just “any 500s” but patterns that indicate bugs, waste, or security issues.
How it works
1. Drive the app in the browser (navigate, click, submit forms) so real requests fire. 2. Call `browser_network_requests` after meaningful interactions (and after navigation settles). 3. Classify and report findings using the criteria below.
Follow cursor-ide-browser workflow rules: use browser_snapshot before structural interactions; after actions that change the page, take a fresh snapshot before the next interaction.
Audit checklist
Failures
- 4xx / 5xx — list method, URL (path + query), status, and whether the UI handled the error.
- CORS or network errors — often misconfigured origins or mixed content.
Performance
- Slow requests — flag requests with high latency (e.g. > 500 ms server time if timings are visible; otherwise note unusually large waterfalls).
- Duplicate calls — same URL + method fired multiple times in one user action (often a React effect or missing deduplication).
- Oversized payloads — responses that look huge for what the UI needs (suggest pagination, field selection, or compression).
Security and privacy
- Sensitive data in URLs — tokens or PII in query strings.
- Missing auth — API calls that should send credentials or bearer tokens but do not (compare with adjacent authenticated calls).
Correctness
- Unexpected hosts — calls to third parties not documented for the feature (trackers, accidental leaks).
- Preflight storms — excessive OPTIONS requests may indicate wrong CORS caching or too many distinct origins.
Steps
1. Start from a clean navigation — browser_navigate to the target URL (or use an existing tab via browser_tabs).
2. Exercise the feature — interactions that trigger API usage (filters, infinite scroll, form save, modal open).
3. Fetch network log — browser_network_requests after each logical step if the page does multiple round-trips.
4. Report — structured output:
- Summary counts (failed, slow, duplicate groups).
- Table or bullet list of issues with URL pattern (not necessarily full secrets), status, category (failure / perf / security / correctness).
- Recommended next code changes or investigations.
Notes
- Iframe traffic may not appear in the same log — note if the feature runs inside an iframe.
- Compare against expected API design; a 404 might be correct for “optional resource not found” if handled in UI.
- Pair with
browser_console_messagesfor errors that do not surface as failed HTTP (e.g. parse errors after 200).
Related skills
FAQ
What does this skill check?
Failures (4xx/5xx, CORS), performance (slow and duplicate calls, oversized payloads), security (tokens/PII in URLs, missing auth), and correctness (unexpected hosts, preflight storms).
What does it depend on?
The cursor-ide-browser MCP, specifically the browser_network_requests tool, driven after real interactions fire requests.
When should I run it?
On API-heavy pages and after backend or client networking changes, once you have driven the app to fire real requests.