Now liveThe Skillselion MCP - thousands of ranked skills, loaded into your agent mid-task. No install.Get it →
spencerpauly avatar

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)
At a glance

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
From the docs

What network-request-auditing says it does

use browser_network_requests to audit every fetch/XHR for failures, slowness, duplicate calls, and suspicious payloads
SKILL.md
Deep-dive **network** health using the `cursor-ide-browser` MCP.
SKILL.md
**Duplicate calls** — same URL + method fired multiple times in one user action
SKILL.md
npx skills add https://github.com/spencerpauly/awesome-cursor-skills --skill network-request-auditing

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

Listed on Skillselion
Installs235
repo stars655
Last updatedAugust 2, 2026
Repositoryspencerpauly/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

SKILL.mdMarkdownGitHub ↗

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 navigationbrowser_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 logbrowser_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_messages for 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.

Debuggingfrontendtestingintegrations

This week in AI coding

Five minutes, every Monday - the tools, releases and tactics for developers.

unsubscribe anytime.