HTTP Debugging Extensions - Operates as a browser extension to intercept and modify web traffic directly within the browser.
HTTP Traffic Analysis - Captures and inspects HTTP traffic from browsers and desktop apps for debugging and analysis.
Session Replay - Captures HTTP traffic during a browsing session and replays it later to reproduce bugs or analyze network patterns.
GraphQL Traffic Inspectors - Provides real-time inspection and modification of GraphQL queries and responses for debugging.
GraphQL Traffic Recorders - Captures and logs GraphQL queries and responses for real-time inspection and debugging.
Session Replay - Records and replays user interactions to reproduce bugs and diagnose issues without relying on incomplete reports.
Traffic Proxying and Interception - Intercepts HTTP traffic at the proxy level to inspect, modify, or block requests and responses in real time.
Response Modification - Intercepts HTTP responses and replaces them with custom data to simulate server behavior during development and testing.
GraphQL Service Mocks - Simulates GraphQL API environments by intercepting requests and returning custom mock responses.
Cross-Platform Network Debuggers - Captures and inspects HTTP traffic from browsers, desktop apps, and mobile devices for unified debugging.
API Endpoint Managers - Provides API endpoint management to switch between development, staging, and production environments.
Frontend API Mocking - Returns custom data from predefined rules instead of actual server responses for frontend development.
Real-time Traffic Monitoring - Captures and displays every HTTP request and response from a browser or desktop app with full detail for inspection.
Custom Request Headers - Provides capabilities to add, modify, or remove custom HTTP headers on requests and responses.
HTTP Traffic Logging - Exports complete HTTP request and response logs from browser sessions for offline debugging and performance analysis.
HTTP Request Debugging - Inspects full HTTP traffic details including headers, payloads, and timing to identify issues during development or testing.
HTTP Traffic Handling - Captures and inspects HTTP(S) requests and responses made by a browser, enabling developers to view and analyze network activity.
Network Traffic Analyzers - Provides tools to inspect, filter, and analyze network traffic to identify and resolve connectivity or performance problems.
Network Traffic Replay Tools - Captures live HTTP traffic and replays recorded responses to eliminate dependency on flaky or unavailable backend services.
CORS Header Injection - Provides CORS header injection to configure cross-origin resource sharing for API requests.
Request Header Overrides - Intercepts and modifies HTTP request headers in transit to bypass CORS restrictions and test authentication scenarios.
HTTP Request Interceptors - Intercepts and alters HTTP requests and responses as they travel between the browser and server, enabling live debugging and testing.
Production Traffic Modifications - Intercepts live HTTP traffic and rewrites request or response data to test changes directly on production sites without deploying code.
Rule-Driven Modifications - Applies user-defined rules to match and alter HTTP requests and responses based on URL patterns, headers, or body content.
Bearer Token Authentication - Verifies bearer tokens on each request to ensure only authorized clients access protected endpoints.
API Request Authentication - Verifies the identity of a client making an API call using methods such as API keys, OAuth tokens, or JWT to control access.
Traffic Inspection and Manipulation - Captures and displays all HTTP traffic from browsers and desktop apps for detailed request and response analysis.
REST API Security - Validates user identity through tokens or credentials before granting access to protected API endpoints.
CORS Restriction Overrides - Provides a feature to modify HTTP response headers to bypass CORS restrictions.
Real-Time Modifications - Alters HTTP request and response data on the fly as traffic passes through the interception layer.
Network Traffic Logs - Captures all HTTP(S) requests and responses from a browser session for later analysis and sharing.
Network Traffic Analysis - Captures and displays HTTP(S) traffic from desktop browsers and apps for debugging and analysis.
API Mocking - Replaces real API calls with mock responses inside Cypress, Playwright, Selenium, and CI pipelines.
GraphQL Testing - Provides specialized support for validating GraphQL queries, mutations, and subscriptions against schemas.
Response Rewriters - Intercepts live HTTP responses and rewrites their content, headers, or status codes for testing.
Local API Response Mocking - Intercepts outgoing API calls and returns predefined responses from local storage, eliminating the need for a live server.
HTTP Mock Servers - Simulates HTTP server behavior by intercepting requests and returning predefined responses.
HTTP Mocking - Intercepts and modifies HTTP requests and responses on a local machine to test product changes without deploying to production.
REST API Testing Tools - Validates HTTP endpoints by checking status codes, response body shape, and idempotency using parameterized requests and post-response scripts.
Session Recording - Captures and replays user interactions within a web application to analyze behavior and identify usability issues.
HTTP Header Manipulators - Alters request or response headers on the fly to test different server behaviors or authentication scenarios.
Request Content Replacements - Replaces specified parts of HTTP request or response data, such as headers, query parameters, or body content, to modify traffic behavior.
Browser Extensions - Operates as a browser extension to intercept and modify web traffic directly within the user's browser environment.
HTTP Interceptor Extensions - Installs the tool as a Firefox extension using the WebExtensions API to intercept and modify browser traffic.
CORS Debugging Tools - Provides tools to intercept and inspect CORS headers for debugging cross-origin failures.
Script Injections - Inserts user-defined scripts into web pages to modify behavior or debug client-side code.
Request Modifiers - Provides real-time interception and modification of GraphQL request bodies and headers for debugging.
Query Modifiers - Ships a built-in proxy that intercepts and rewrites GraphQL queries and responses in real time.
Traffic Inspectors - Intercepts and displays GraphQL request and response details for real-time troubleshooting.
HTTP Redirects - Redirects HTTP requests to different URLs for testing alternate environments or bypassing broken endpoints.
Request and Response Transformers - Alters request headers, query parameters, or response bodies in transit to test different scenarios without changing application code.
URL Redirections - Forwards requests from one URL to another for testing staging or local environments.
Web Application Debugging - Inspects and modifies live HTTP traffic from a production web application to diagnose issues without affecting the user experience.
API Run Schedulers - Triggers a collection of API requests on a fixed timetable without manual intervention for periodic testing or monitoring.
Android - Captures and displays HTTP requests and responses from Android applications for debugging and analysis.
iOS Traffic Inspections - Captures and displays HTTP traffic from iOS applications for debugging and analysis.
Local File Image Replacements - Provides a mechanism to intercept image requests and serve local files for offline testing.
Network Response Mappings - Replaces remote network responses with local files for offline development and rapid testing.
Debugging Session Sharing - Sharing live debugging sessions and HTTP interception rules with team members for collaborative troubleshooting.
HTTP Rule Sharing - Shares HTTP interception and modification rules with team members so everyone works from the same configuration.
Shared Team Inboxes - Shares HTTP interception and modification rules with teammates so everyone uses the same configuration for debugging and testing.
HTTP Workspace Organization - Groups related HTTP rules, mocks, and logs into a shared workspace so teams can collaborate on debugging without interfering with each other's work.
Third-Party Script Debugging - Injects and tests JavaScript tags on external websites to verify their behavior before production deployment.
Response Recordings - Captures live HTTP responses and replays them to eliminate dependency on flaky backend services.
Query-Based Cache Variation - Appends a unique query parameter to each request so the browser treats every URL as a new resource and never serves a stale cached copy.
Cache Bypass Tools - Appends a unique query parameter to each request so the browser treats every URL as a new resource and never serves a stale cached copy.
Collection Sharing - Exports a collection of API requests and its configuration so other users can import and run the same workflow.
Request Chaining - Passes data from one API response as a variable into subsequent requests to enable dynamic data flow across a workflow.
CORS Error Diagnoses - Isolates whether a failing request is caused by CORS or a real API bug by replaying from a non-browser client.
Proxy Rule Migrators - Migrates existing proxy and header modification rules from tools like Charles Proxy and ModHeader with a single click.
cURL Importers - Provides a cURL importer that parses cURL commands into structured HTTP requests.
Response Chained Injections - Provides dynamic data injection by chaining response values into subsequent API requests.
Network Throttling - Throttles or delays selected network requests to test application behavior under poor network conditions.
HTTP Method Tools - Provides utilities for changing HTTP methods on requests to test server behavior.
OpenAPI Specification Imports - Converts an OpenAPI specification file into a ready-to-use API collection for testing and debugging.
Recurring API Collection Schedulers - Triggers a collection of API requests to execute automatically on a fixed timetable, such as daily or hourly.
Remote Script Replacements - Provides a feature to replace production JavaScript files with GitHub-hosted versions for testing.
Latency Simulation Throttling - Adds configurable delays to API responses to simulate slow networks and test application behavior under latency.
API Environment Switchings - Redirects API requests to staging or local environments by modifying host headers.
Traffic Captures - Captures all HTTP traffic from a website and saves it as a downloadable file for offline analysis.
API Payload Inspectors - Displays the full body and headers of an API request so developers can verify what data is being sent.
Request Header Specifications - Displays the headers sent with each HTTP request so developers can verify authentication, caching, and content negotiation details.
Request Delay Configurations - Adds a configurable pause before a request is sent to simulate slow network conditions.
Local File Mappings - Maps HTTP responses to local files, enabling offline development and bypassing CORS restrictions.
Local Resource Exposure - Creates a secure tunnel from a public URL to a local development server, enabling external access for testing and demos.
HAR Network Mocking - Captures all network requests from a browser session and exports them into a standardized HAR file for debugging.
HAR File Exporters - Captures all network requests from a browser session and exports them as a standardized HAR file for debugging.
Response Body Modifiers - Intercepts HTTP responses and replaces the original body with custom content before it reaches the client.
Request Cancellations - Blocks specific requests from being sent by matching their URL pattern and canceling them.
Request Delays - Slows down selected HTTP requests to simulate network latency and test loading states.
API Response Simulators - Provides API response simulation capabilities for Android development by returning custom predefined responses.
Error Status Code Simulations - Intercepts live API endpoints and returns custom HTTP error status codes for testing failure conditions.
GraphQL Header Modifiers - Allows modifying headers on GraphQL requests to test authentication and authorization scenarios.
Response Header Extractors - Displays the complete set of response headers from any request, including Access-Control-Allow-Origin, to diagnose CORS configuration.
HTTPS Enforcements - Redirects all HTTP requests to HTTPS to encrypt data in transit and prevent man-in-the-middle attacks.
Rate Limiting & Abuse Prevention - Caps the number of requests a client can make in a time window to prevent abuse and overload.
Role-Based Access Control - Restricts endpoint access based on user roles to ensure only permitted actions are executed.
401 Unauthorized Resolutions - Provides a dedicated workflow for intercepting and resolving 401 Unauthorized errors during API debugging.
Mock Server Generators - Creates local mock servers that return predefined responses to simulate API endpoints during development.
HTTP Session Recorders - Captures complete HTTP sessions and replays them to reproduce bugs or test without live backend dependencies.
API Response Recordings - Captures live API responses and replays them to eliminate dependency on flaky backend services.
Shareable Network Log Exporters - Exports captured network logs as a shareable link so team members can review traffic without reproducing the issue.
API Audit Logging - Records all API requests and responses for auditing, debugging, and detecting suspicious behavior.
HTTP Interaction Replayers - Captures a sequence of HTTP interactions and replays them later to reproduce bugs or verify consistent behavior.
API Collection Runners - Executes a predefined sequence of API requests in order, automating multi-step workflows without manual intervention.
iOS API Mocks - Replaces real server responses with custom mock data to test iOS app behavior without a live backend.
Subscription Testing Tools - Validates real-time GraphQL subscription streams and server-sent events during development.
Network Latency Simulators - Includes features to simulate slow networks and throttle requests for performance testing.
Data-Driven Testing - Provides data-driven API testing by reading input data from CSV or JSON files.
Request Testing - Sends manual OPTIONS requests with custom headers to verify server CORS permissions.
Preflight - Sends manual OPTIONS requests with custom headers to verify server CORS permissions.
Request Body Editors - Edits the payload of outgoing HTTP requests to alter data sent to a server during testing.
Network Resilience Simulators - Simulates slow network conditions by adding artificial latency to selected HTTP requests.
Latency and Chunking Simulators - Delays responses from specified endpoints by a configurable amount of time to test application behavior under slow network conditions.
Third-Party Integration Simulators - Intercepts and modifies HTTP traffic to simulate third-party integrations on live websites without actual backend connections.
API Test Collections - Groups REST and GraphQL tests into collections with shared environments and variables for organized testing.
Batch Request Execution - Executes a sequence of API calls automatically, chaining responses as inputs for subsequent requests.
Response Header Modifiers - Overwrites or removes specific HTTP response headers to bypass CORS restrictions during development.
Local Response Header Overrides - Adds or modifies CORS headers on responses from a local reverse proxy or browser extension for testing without changing the backend.
Mobile Header Modifications - Intercepts and alters HTTP headers in Android and iOS apps to control traffic behavior.
Response Content Replacements - Swaps parts of a server response with custom content to test UI behavior without backend changes.
Hostname Swaps - Switches the hostname of outgoing HTTP requests to a different target server, enabling environment switching and traffic redirection.
Request Interception and Blocking - Prevents specific requests from being sent, useful for disabling unwanted resources or simulating network failures.
Browser Argument Configuration - Opens a browser session pre-configured with user-defined command-line flags to control behavior like disabling security features or setting a proxy.
Local File Replacements - Ships a feature to replace remote JavaScript files with local versions for testing without deployment.
Pre-Load Injections - Injects custom JavaScript into a web page before any other scripts execute, enabling early modification of page behavior.
Response Interception Injections - Inserts JavaScript or CSS into pages by intercepting responses, enabling dynamic page modifications during development.
Script Attribute Customization - Injects a script tag with user-defined attributes into a webpage to execute custom JavaScript code.
URL-Matched Injections - Inserts JavaScript or CSS into web pages on matched URLs to automate UI tests or modify page behavior.
Schema Explorers - Provides a visual interface for browsing GraphQL type definitions and fields via introspection.
Error Simulators - Intercepts API calls and returns custom HTTP error codes to test application error handling.
iOS Request Interceptors - Intercepts outgoing requests from iOS apps and allows altering headers, parameters, or body content.
Status Code Simulators - Intercepts requests and returns custom HTTP status codes to test application error handling.
Request Body Handling - Intercepts outgoing HTTP requests and alters their payload before the server receives it, enabling testing of different request scenarios.
Request Body Alterations - Alters the body of outgoing HTTP requests for REST and GraphQL APIs before they reach the server.
Android - Intercepts and alters HTTP request headers, parameters, or bodies from Android apps before they reach the server.
Request Body Replacements - Swaps parts of request bodies or URLs with custom text to simulate different inputs.
Script-Based Body Modifiers - Overrides request body content by injecting custom JavaScript logic before the request is sent.
Automated Response Assertions - Check each response in a batch run against custom assertions to verify correctness and flag failures automatically.
API Response Validation - Checks each API response against custom assertions and reports failures to confirm the workflow behaves as expected.
Schema Validation - Checks incoming request payloads against a predefined schema to reject malformed or malicious data.
API Proxy Routings - Provides API proxy routing to bypass CORS during local development.
URL Component Replacements - Replaces specific parts of URLs, such as domains, while preserving the rest of the address.
URL Rewrite Rules - Redirects or modifies the destination URL of an HTTP request to point to a different endpoint.
Environment - Redirects HTTP requests between different environments or local files to test staging, production, or development versions without code changes.
Live Debugging Session Sharers - Shares a live debugging session with team members so everyone sees the same intercepted traffic in real time.
