requestly/requestly

Features

• 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.
• Request-Level Role Authorization - Enforces role-based permissions on each request, blocking unauthorized actions at runtime.
• 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.
• Traffic Interception and Modification - Captures and alters network requests and responses in transit for debugging and testing.
• 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.
• Input Validation and Sanitization - Checks and cleans all incoming data to block injection attacks and malformed payloads.
• 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.
• Regex-Based Request Modifications - Provides regex-based matching to apply targeted modifications to HTTP requests.
• Test Data Generators - Generates dynamic values like random strings, numbers, timestamps, and UUIDs for use in HTTP request modifications.
• Map Endpoint Redirections - Forwards requests from one URL to another for testing against staging or local servers instead of production.
• HTTP Header Analyzers - Examines the content and structure of authorization headers sent in HTTP requests to understand authentication mechanisms.
• Bypasses - Removes or modifies CSP response headers to allow scripts and resources that would otherwise be blocked by the browser.
• Domain Name Blocking - Blocks all traffic to specified domains so pages and resources from those domains never load.
• X-Frame-Options Header Overrides - Overrides X-Frame-Options headers to allow embedding pages in iframes during testing.
• 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.
• Query Parameter Modifications - Alters query parameters in HTTP requests on the fly to test different scenarios.
• 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.
• API and Web Development Tools - Platform for API development, testing, and mocking.
• API Clients - Lightweight API client for modern development workflows.
• API Development - Listed in the “API Development” section of the Awesome Mac awesome list.
• API Development Tools - Lightweight API client designed for modern developer workflows.
• API Testing Tools - A platform for intercepting and modifying network requests.

Star-Verlauf