From 0b12c8e0e3920c17e8f654d2179007d57f6c6a29 Mon Sep 17 00:00:00 2001
From: "mintlify[bot]" <109931778+mintlify[bot]@users.noreply.github.com>
Date: Mon, 16 Mar 2026 11:57:57 +0000
Subject: [PATCH 1/8] Add request examples documentation page
Generated-By: mintlify-agent
---
docs.json | 1 +
general/api-client/examples.mdx | 95 +++++++++++++++++++++++++++++++++
2 files changed, 96 insertions(+)
create mode 100644 general/api-client/examples.mdx
diff --git a/docs.json b/docs.json
index 4acf259..7ad5f68 100644
--- a/docs.json
+++ b/docs.json
@@ -83,6 +83,7 @@
"pages": [
"general/api-client/design-apis",
"general/api-client/api-collections",
+ "general/api-client/examples",
{
"group": "Import & Export APIs",
"pages": [
diff --git a/general/api-client/examples.mdx b/general/api-client/examples.mdx
new file mode 100644
index 0000000..8101a7a
--- /dev/null
+++ b/general/api-client/examples.mdx
@@ -0,0 +1,95 @@
+---
+title: "Request Examples"
+label: "Request Examples"
+slug: "examples"
+description: "Save, manage, and reuse request examples in Requestly's API Client. Create snapshots of your API requests with different configurations for quick reuse."
+seoTitle: "Request Examples"
+seoDescription: "Save, manage, and reuse request examples in Requestly's API Client. Create snapshots of your API requests with different configurations for quick reuse."
+visibility: "PUBLIC"
+---
+
+---
+
+Request examples let you save snapshots of an API request with specific configurations—such as different parameters, headers, or body payloads—so you can quickly switch between variations without modifying the original request. Examples are stored as children of their parent request and appear in the sidebar for easy access.
+
+## Why use examples
+
+- **Test multiple scenarios** — Save different request configurations (valid input, edge cases, error states) and switch between them instantly.
+- **Share context with your team** — Examples sync with your workspace so team members can see the exact request configurations you used.
+- **Preserve response data** — Each example captures the request and response together, making it easy to revisit past results.
+
+## Save a request as an example
+
+You can create an example from any HTTP or GraphQL request that has been sent at least once.
+
+
+
+ Navigate to an existing API request in your workspace or send a new request.
+
+
+ Click the **Save** dropdown button in the request view and select **Save as Example**. The current request configuration—including URL, method, headers, parameters, and body—is saved as a new example under that request.
+
+
+ The example opens in a new tab. The parent request in the sidebar expands to show the newly created example beneath it.
+
+
+
+
+ You can also save examples from the request's context menu in the sidebar by right-clicking the request and selecting the save option.
+
+
+## Manage examples in the sidebar
+
+Examples appear as collapsible children under their parent request in the sidebar. Click the expand arrow next to any request to reveal its examples.
+
+### Open an example
+
+Click on an example in the sidebar to open it in a new tab. The example loads with the saved request configuration and response data.
+
+### Rename an example
+
+Right-click the example in the sidebar and select **Rename**, or double-click the example name. Type the new name and press **Enter** to save.
+
+### Duplicate an example
+
+Right-click the example in the sidebar and select **Duplicate**. A copy of the example is created under the same parent request.
+
+### Reorder examples
+
+Drag and drop examples within the same parent request to reorder them. The new order is persisted automatically.
+
+### Delete an example
+
+Right-click the example in the sidebar and select **Delete**. Confirm the action in the prompt that appears.
+
+
+ Deleting an example is permanent and cannot be undone.
+
+
+## Use an example as a template
+
+When viewing an example, click **Use as Template** to load its configuration into a new draft request. This lets you start a new request based on an existing example without modifying the original.
+
+## Duplicating requests with examples
+
+When you duplicate an API request that has examples, all associated examples are duplicated along with it. Each duplicated example retains the original's configuration but is linked to the new request copy.
+
+## How examples are stored
+
+- Examples are stored as separate records linked to their parent request via a `parentRequestId`.
+- Scripts (pre-request and post-response) and authorization settings are not carried over to examples. Each example stores only the request configuration and response data.
+- Examples sync across your team workspace, just like requests and collections.
+
+## What's next?
+
+
+
+ Organize your requests into collections and folders
+
+
+ Use variables to make requests reusable across environments
+
+
+ Add pre-request scripts and tests to automate your workflow
+
+
From 471c72f162dca2ad1b9afdfa1578a4f06fb30459 Mon Sep 17 00:00:00 2001
From: kanishkrawatt
Date: Thu, 2 Apr 2026 17:43:42 +0530
Subject: [PATCH 2/8] Arch changes
---
.cursor/rules.mdc | 414 ++++++++++++++++++
README.md | 36 +-
docs.json | 332 +++++++-------
general/api-client/design-apis.mdx | 2 +-
general/api-client/overview.mdx | 200 +++------
.../api-mocking/create-cloud-based-mocks.mdx | 12 +-
general/getting-started/introduction.mdx | 214 ++++-----
general/getting-started/quick-start-guide.mdx | 101 +++--
.../browser-extension-setup.mdx | 34 +-
.../quick-start-guide/desktop-app-setup.mdx | 28 ++
general/http-interceptor/overview.mdx | 133 +++---
general/http-rules/overview.mdx | 175 +++-----
general/mock-server/create.mdx | 6 +-
.../mock-server/import-and-export-mocks.mdx | 8 +-
general/mock-server/overview.mdx | 49 ++-
general/mock-server/test.mdx | 6 +-
.../sessions/access-control-of-session.mdx | 6 +-
general/sessions/overview.mdx | 73 ++-
general/sessions/record-api-sessions.mdx | 4 +-
general/sessions/record-bug-reports.mdx | 8 +-
...-traffic-on-browser-mobile-or-emulator.mdx | 113 ++---
troubleshoot/http-rules/rules-not-working.mdx | 40 ++
22 files changed, 1213 insertions(+), 781 deletions(-)
create mode 100644 .cursor/rules.mdc
diff --git a/.cursor/rules.mdc b/.cursor/rules.mdc
new file mode 100644
index 0000000..22a9af9
--- /dev/null
+++ b/.cursor/rules.mdc
@@ -0,0 +1,414 @@
+# Mintlify technical writing rule
+
+You are an AI writing assistant specialized in creating exceptional technical documentation using Mintlify components and following industry-leading technical writing practices.
+
+## Core writing principles
+
+### Language and style requirements
+
+- Use clear, direct language appropriate for technical audiences
+- Write in second person ("you") for instructions and procedures
+- Use active voice over passive voice
+- Employ present tense for current states, future tense for outcomes
+- Avoid jargon unless necessary and define terms when first used
+- Maintain consistent terminology throughout all documentation
+- Keep sentences concise while providing necessary context
+- Use parallel structure in lists, headings, and procedures
+
+### Content organization standards
+
+- Lead with the most important information (inverted pyramid structure)
+- Use progressive disclosure: basic concepts before advanced ones
+- Break complex procedures into numbered steps
+- Include prerequisites and context before instructions
+- Provide expected outcomes for each major step
+- Use descriptive, keyword-rich headings for navigation and SEO
+- Group related information logically with clear section breaks
+
+### User-centered approach
+
+- Focus on user goals and outcomes rather than system features
+- Anticipate common questions and address them proactively
+- Include troubleshooting for likely failure points
+- Write for scannability with clear headings, lists, and white space
+- Include verification steps to confirm success
+
+## Mintlify component reference
+
+### docs.json
+
+- Refer to the [docs.json schema](https://mintlify.com/docs.json) when building the docs.json file and site navigation
+
+### Callout components
+
+#### Note - Additional helpful information
+
+
+Supplementary information that supports the main content without interrupting flow
+
+
+#### Tip - Best practices and pro tips
+
+
+Expert advice, shortcuts, or best practices that enhance user success
+
+
+#### Warning - Important cautions
+
+
+Critical information about potential issues, breaking changes, or destructive actions
+
+
+#### Info - Neutral contextual information
+
+
+Background information, context, or neutral announcements
+
+
+#### Check - Success confirmations
+
+
+Positive confirmations, successful completions, or achievement indicators
+
+
+### Code components
+
+#### Single code block
+
+Example of a single code block:
+
+```javascript config.js
+const apiConfig = {
+ baseURL: 'https://api.example.com',
+ timeout: 5000,
+ headers: {
+ 'Authorization': `Bearer ${process.env.API_TOKEN}`
+ }
+};
+```
+
+#### Code group with multiple languages
+
+Example of a code group:
+
+
+```javascript Node.js
+const response = await fetch('/api/endpoint', {
+ headers: { Authorization: `Bearer ${apiKey}` }
+});
+```
+
+```python Python
+import requests
+response = requests.get('/api/endpoint',
+ headers={'Authorization': f'Bearer {api_key}'})
+```
+
+```curl cURL
+curl -X GET '/api/endpoint' \
+ -H 'Authorization: Bearer YOUR_API_KEY'
+```
+
+
+#### Request/response examples
+
+Example of request/response documentation:
+
+
+```bash cURL
+curl -X POST 'https://api.example.com/users' \
+ -H 'Content-Type: application/json' \
+ -d '{"name": "John Doe", "email": "john@example.com"}'
+```
+
+
+
+```json Success
+{
+ "id": "user_123",
+ "name": "John Doe",
+ "email": "john@example.com",
+ "created_at": "2024-01-15T10:30:00Z"
+}
+```
+
+
+### Structural components
+
+#### Steps for procedures
+
+Example of step-by-step instructions:
+
+
+
+ Run `npm install` to install required packages.
+
+
+ Verify installation by running `npm list`.
+
+
+
+
+ Create a `.env` file with your API credentials.
+
+ ```bash
+ API_KEY=your_api_key_here
+ ```
+
+
+ Never commit API keys to version control.
+
+
+
+
+#### Tabs for alternative content
+
+Example of tabbed content:
+
+
+
+ ```bash
+ brew install node
+ npm install -g package-name
+ ```
+
+
+
+ ```powershell
+ choco install nodejs
+ npm install -g package-name
+ ```
+
+
+
+ ```bash
+ sudo apt install nodejs npm
+ npm install -g package-name
+ ```
+
+
+
+#### Accordions for collapsible content
+
+Example of accordion groups:
+
+
+
+ - **Firewall blocking**: Ensure ports 80 and 443 are open
+ - **Proxy configuration**: Set HTTP_PROXY environment variable
+ - **DNS resolution**: Try using 8.8.8.8 as DNS server
+
+
+
+ ```javascript
+ const config = {
+ performance: { cache: true, timeout: 30000 },
+ security: { encryption: 'AES-256' }
+ };
+ ```
+
+
+
+### Cards and columns for emphasizing information
+
+Example of cards and card groups:
+
+
+Complete walkthrough from installation to your first API call in under 10 minutes.
+
+
+
+
+ Learn how to authenticate requests using API keys or JWT tokens.
+
+
+
+ Understand rate limits and best practices for high-volume usage.
+
+
+
+### API documentation components
+
+#### Parameter fields
+
+Example of parameter documentation:
+
+
+Unique identifier for the user. Must be a valid UUID v4 format.
+
+
+
+User's email address. Must be valid and unique within the system.
+
+
+
+Maximum number of results to return. Range: 1-100.
+
+
+
+Bearer token for API authentication. Format: `Bearer YOUR_API_KEY`
+
+
+#### Response fields
+
+Example of response field documentation:
+
+
+Unique identifier assigned to the newly created user.
+
+
+
+ISO 8601 formatted timestamp of when the user was created.
+
+
+
+List of permission strings assigned to this user.
+
+
+#### Expandable nested fields
+
+Example of nested field documentation:
+
+
+Complete user object with all associated data.
+
+
+
+ User profile information including personal details.
+
+
+
+ User's first name as entered during registration.
+
+
+
+ URL to user's profile picture. Returns null if no avatar is set.
+
+
+
+
+
+
+### Media and advanced components
+
+#### Frames for images
+
+Wrap all images in frames:
+
+
+
+
+
+
+
+
+
+#### Videos
+
+Use the HTML video element for self-hosted video content:
+
+
+
+Embed YouTube videos using iframe elements:
+
+
+
+#### Tooltips
+
+Example of tooltip usage:
+
+
+API
+
+
+#### Updates
+
+Use updates for changelogs:
+
+
+## New features
+- Added bulk user import feature
+- Improved error messages with actionable suggestions
+
+## Bug fixes
+- Fixed pagination issue with large datasets
+- Resolved authentication timeout problems
+
+
+## Required page structure
+
+Every documentation page must begin with YAML frontmatter:
+
+```yaml
+---
+title: "Clear, specific, keyword-rich title"
+description: "Concise description explaining page purpose and value"
+---
+```
+
+## Content quality standards
+
+### Code examples requirements
+
+- Always include complete, runnable examples that users can copy and execute
+- Show proper error handling and edge case management
+- Use realistic data instead of placeholder values
+- Include expected outputs and results for verification
+- Test all code examples thoroughly before publishing
+- Specify language and include filename when relevant
+- Add explanatory comments for complex logic
+- Never include real API keys or secrets in code examples
+
+### API documentation requirements
+
+- Document all parameters including optional ones with clear descriptions
+- Show both success and error response examples with realistic data
+- Include rate limiting information with specific limits
+- Provide authentication examples showing proper format
+- Explain all HTTP status codes and error handling
+- Cover complete request/response cycles
+
+### Accessibility requirements
+
+- Include descriptive alt text for all images and diagrams
+- Use specific, actionable link text instead of "click here"
+- Ensure proper heading hierarchy starting with H2
+- Provide keyboard navigation considerations
+- Use sufficient color contrast in examples and visuals
+- Structure content for easy scanning with headers and lists
+
+## Component selection logic
+
+- Use **Steps** for procedures and sequential instructions
+- Use **Tabs** for platform-specific content or alternative approaches
+- Use **CodeGroup** when showing the same concept in multiple programming languages
+- Use **Accordions** for progressive disclosure of information
+- Use **RequestExample/ResponseExample** specifically for API endpoint documentation
+- Use **ParamField** for API parameters, **ResponseField** for API responses
+- Use **Expandable** for nested object properties or hierarchical information
+
+## Sidebar information architecture
+
+- Organize navigation around user goals and use cases, not internal Requestly product concepts
+- Prefer top-level group names like `API Testing` or `Debugging & Interception` over feature names like `HTTP Interceptor`, `HTTP Rules`, or `Mock Server`
+- Nest features and capabilities inside the most relevant use case instead of exposing them as standalone top-level categories
+- Treat interception, traffic modification, and mocking as supporting capabilities that can serve multiple use cases
+- Use progressive disclosure in navigation: broad task first, then specific workflows, then advanced capabilities
+- Optimize sidebar labels for first-time users who may not know Requestly terminology
+- Follow familiar developer-doc patterns used by products like Postman or Stripe, where the first scan answers "what can I do?" before "which feature does this belong to?"
+- When editing `docs.json`, prefer structures such as:
+ - `API Testing` -> sending requests, environments, assertions, automation
+ - `Debugging & Interception` -> inspect traffic, capture sessions, troubleshoot requests
+ - `Modify Traffic` -> modify headers, redirect requests, rewrite bodies, delay responses
+ - `Mock APIs & Responses` -> quick mocks, mock servers, reusable mock workflows
diff --git a/README.md b/README.md
index 4b9848e..7786408 100644
--- a/README.md
+++ b/README.md
@@ -19,15 +19,14 @@
## 📖 About
-This repository contains the official documentation for [Requestly](https://requestly.com) - a powerful tool for API Mocking, Testing, and Debugging. The documentation covers:
+This repository contains the official documentation for [Requestly](https://requestly.com), organized around the main jobs users come to Requestly to do:
-- **Browser Extension** - HTTP interception and modification for Chrome, Firefox, Edge, and more
-- **Desktop App** - Advanced debugging for mobile apps, desktop software, and simulators
-- **API Client** - Modern API client for designing, testing, and managing APIs
-- **HTTP Rules** - Comprehensive guides for modifying requests and responses
-- **Mock Server** - API mocking and response simulation
-- **Team Collaboration** - Workspace management and team features
-- **Public APIs** - Programmatic access to Requestly features
+- **API Testing** - Send requests, manage environments, organize collections, and add assertions
+- **Debugging & Interception** - Inspect traffic from browsers, mobile apps, desktop apps, emulators, and runtimes
+- **Modify Traffic** - Rewrite headers, bodies, query params, redirects, and delays without changing application code
+- **Mock APIs & Responses** - Create quick mocks and reusable hosted mock endpoints
+- **Sessions & Collaboration** - Record bug reports, capture API sessions, and share workflows with your team
+- **Public APIs** - Automate Requestly workflows programmatically
## 🚀 Getting Started
@@ -62,16 +61,17 @@ The documentation will be available at `http://localhost:3000`
```
requestly-docs/
├── changelogs/ # Release notes and changelogs
-├── general/ # General documentation
-│ ├── getting-started/ # Getting started guides
-│ ├── api-client/ # API Client documentation
-│ ├── http-rules/ # HTTP Rules guides
-│ ├── mock-server/ # Mock Server documentation
-│ ├── sessions/ # Session recording docs
-│ └── team/ # Team & collaboration features
-├── guides/ # How-to guides and tutorials
-├── public-apis/ # Public API documentation
-├── troubleshoot/ # Troubleshooting guides
+├── general/ # Core product docs and onboarding
+│ ├── getting-started/ # Intro, setup, and quick-start flows
+│ ├── api-client/ # API testing workflows
+│ ├── http-rules/ # Traffic modification workflows
+│ ├── http-interceptor/# Traffic inspection and interception workflows
+│ ├── mock-server/ # Hosted mocks and response simulation
+│ ├── sessions/ # Bug reports, API sessions, and HAR workflows
+│ └── team/ # Collaboration and workspaces
+├── guides/ # Task-based guides and integration tutorials
+├── public-apis/ # Programmatic Requestly APIs
+├── troubleshoot/ # Setup and workflow recovery guides
├── images/ # Image assets
├── docs.json # Mintlify configuration
└── LICENSE # License file
diff --git a/docs.json b/docs.json
index 7ad5f68..f2c60eb 100644
--- a/docs.json
+++ b/docs.json
@@ -37,28 +37,18 @@
"group": "Getting Started",
"pages": [
"general/getting-started/introduction",
+ "general/getting-started/quick-start-guide",
"general/getting-started/downloads",
- {
- "group": "Quick Start Guide",
- "pages": [
- "general/getting-started/quick-start-guide",
- "general/getting-started/quick-start-guide/browser-extension-setup",
- "general/getting-started/quick-start-guide/desktop-app-setup"
- ]
- }
+ "general/getting-started/quick-start-guide/browser-extension-setup",
+ "general/getting-started/quick-start-guide/desktop-app-setup",
+ "general/api-client/quick-start",
+ "general/api-client/difference-between-desktop-app-and-browser-extension"
]
},
{
- "group": "API Client",
+ "group": "API Testing",
"pages": [
"general/api-client/overview",
- {
- "group": "Getting Started",
- "pages": [
- "general/api-client/quick-start",
- "general/api-client/difference-between-desktop-app-and-browser-extension"
- ]
- },
{
"group": "Sending Requests",
"pages": [
@@ -142,12 +132,89 @@
}
]
},
+ {
+ "group": "Collaboration & Workspaces",
+ "pages": [
+ "general/team/workspaces",
+ "general/team/local-workspace",
+ "general/team/multiple-workspaces",
+ {
+ "group": "Shared Workspace",
+ "pages": [
+ "general/team/how-to-get-started-with-shared-workspace",
+ "general/team/how-to-get-started-with-shared-workspace/managing-workspace",
+ "general/team/how-to-get-started-with-shared-workspace/user-roles"
+ ]
+ }
+ ]
+ },
+ {
+ "group": "Account & Administration",
+ "pages": [
+ "general/others/billing-subscriptions",
+ "general/others/blocklist",
+ "general/others/how-is-bowser-extension-different-from-a-desktop-app",
+ {
+ "group": "Single Sign-On",
+ "pages": [
+ "general/others/sso",
+ "general/others/sso/how-to-set-up-sso-with-microsoft-entra-id",
+ "general/others/sso/setup-sso-with-okta"
+ ]
+ }
+ ]
+ }
+ ]
+ },
+ {
+ "tab": "HTTP Interception",
+ "icon": "globe",
+ "groups": [
+ {
+ "group": "Debugging & Interception",
+ "pages": [
+ "general/http-interceptor/overview",
+ {
+ "group": "Capture Traffic",
+ "pages": [
+ "general/http-interceptor/browser-extension",
+ "general/http-interceptor/browser-extension/browser-interception",
+ "general/http-interceptor/desktop-app",
+ "general/http-interceptor/desktop-app/browser-interception",
+ "general/http-interceptor/desktop-app/desktop-app-interception",
+ "general/http-interceptor/desktop-app/network-table",
+ "general/http-interceptor/desktop-app/saving-logs-to-local-file"
+ ]
+ },
+ {
+ "group": "Intercept Different Devices & Runtimes",
+ "pages": [
+ "general/http-interceptor/desktop-app/android-devices",
+ "general/http-interceptor/desktop-app/android-simulator-interception",
+ "general/http-interceptor/desktop-app/ios-devices-interception",
+ "general/http-interceptor/desktop-app/ios-simulator-interception",
+ "general/http-interceptor/desktop-app/nodejs",
+ "general/http-interceptor/desktop-app/terminal"
+ ]
+ },
+ {
+ "group": "Record & Share Sessions",
+ "pages": [
+ "general/sessions/overview",
+ "general/sessions/record-api-sessions",
+ "general/sessions/record-bug-reports",
+ "general/sessions/import-view-har-file",
+ "general/sessions/access-control-of-session"
+ ]
+ }
+ ]
+ },
{
"group": "HTTP Rules",
"pages": [
"general/http-rules/overview",
{
- "group": "HTTP Rules",
+ "group": "Modify Requests & Responses",
"pages": [
"general/http-rules/rule-types",
"general/http-rules/rule-types/redirect-rule",
@@ -165,7 +232,7 @@
]
},
{
- "group": "Advanced Usage",
+ "group": "Advanced Traffic Rules",
"pages": [
"general/http-rules/advanced-usage",
"general/http-rules/advanced-usage/grouping",
@@ -182,17 +249,12 @@
]
},
{
- "group": "Sharing",
+ "group": "Share & Import Rules",
"pages": [
"general/http-rules/sharing",
"general/http-rules/sharing/share-in-workspace",
"general/http-rules/sharing/shared-list",
- "general/http-rules/sharing/download-rules"
- ]
- },
- {
- "group": "Import Rules",
- "pages": [
+ "general/http-rules/sharing/download-rules",
"general/imports/charles-proxy",
"general/imports/header-editor",
"general/imports/modheader",
@@ -202,143 +264,82 @@
]
},
{
- "group": "HTTP Interceptor",
+ "group": "Mock APIs & Responses",
"pages": [
- "general/http-interceptor/overview",
{
- "group": "Browser Extension",
+ "group": "Quick Mocking",
"pages": [
- "general/http-interceptor/browser-extension",
- "general/http-interceptor/browser-extension/browser-interception"
+ "general/api-mocking/api-mocking",
+ "general/api-mocking/create-cloud-based-mocks",
+ "general/api-mocking/create-local-api-mocks"
]
},
{
- "group": "Desktop App",
+ "group": "Mock Server",
"pages": [
- "general/http-interceptor/desktop-app",
- "general/http-interceptor/desktop-app/android-devices",
- "general/http-interceptor/desktop-app/android-simulator-interception",
- "general/http-interceptor/desktop-app/browser-interception",
- "general/http-interceptor/desktop-app/desktop-app-interception",
- "general/http-interceptor/desktop-app/ios-devices-interception",
- "general/http-interceptor/desktop-app/ios-simulator-interception",
- "general/http-interceptor/desktop-app/network-table",
- "general/http-interceptor/desktop-app/nodejs",
- "general/http-interceptor/desktop-app/saving-logs-to-local-file",
- "general/http-interceptor/desktop-app/terminal"
+ "general/mock-server/overview",
+ {
+ "group": "Create Mocks",
+ "pages": [
+ "general/mock-server/create",
+ "general/mock-server/create/create-mock-api",
+ "general/mock-server/create/create-new-mock-file",
+ "general/mock-server/create/mock-collection"
+ ]
+ },
+ "general/mock-server/test",
+ "general/mock-server/pre-configured-mocks",
+ "general/mock-server/templating-in-mocks",
+ "general/mock-server/import-and-export-mocks"
]
}
]
},
{
- "group": "Api Mocking",
+ "group": "Guides",
"pages": [
- "general/api-mocking/api-mocking",
- "general/api-mocking/create-cloud-based-mocks",
- "general/api-mocking/create-local-api-mocks"
- ]
- },
- {
- "group": "Mock Server",
- "pages": [
- "general/mock-server/overview",
{
- "group": "Create Mocks",
+ "group": "API Testing & Automation",
"pages": [
- "general/mock-server/create",
- "general/mock-server/create/create-mock-api",
- "general/mock-server/create/create-new-mock-file",
- "general/mock-server/create/mock-collection"
+ "guides/community-content/using-collection-runner-in-requestly",
+ "guides/community-content/variables-and-environments-in-requestly"
]
},
- "general/mock-server/test",
- "general/mock-server/pre-configured-mocks",
- "general/mock-server/templating-in-mocks",
- "general/mock-server/import-and-export-mocks"
- ]
- },
- {
- "group": "Sessions",
- "pages": [
- "general/sessions/overview",
- "general/sessions/record-api-sessions",
- "general/sessions/record-bug-reports",
- "general/sessions/import-view-har-file",
- "general/sessions/access-control-of-session"
- ]
- },
- {
- "group": "Team",
- "pages": [
- "general/team/workspaces",
- "general/team/local-workspace",
- "general/team/multiple-workspaces",
{
- "group": "Shared Workspace",
+ "group": "Traffic Modification & Mocking",
"pages": [
- "general/team/how-to-get-started-with-shared-workspace",
- "general/team/how-to-get-started-with-shared-workspace/managing-workspace",
- "general/team/how-to-get-started-with-shared-workspace/user-roles"
+ "guides/record-and-mock-flaky-apis-in-bulk",
+ "guides/how-to-modify-cookies-using-requestly",
+ "guides/modify-http-headers-in-web-automation-using-requestly",
+ "guides/modify-html-document-using-modify-api-response-rule",
+ "guides/how-to-use-shared-state-to-aggregate-data-and-use-across-requestly-rules",
+ "guides/modifying-response-asynchronously",
+ "guides/how-to-conditionally-fail-requests-based-on-request-counts",
+ "guides/intercepting-and-modifying-network-requests-in-web-automation-frameworks-like-selenium-and-playwright"
]
- }
- ]
- },
- {
- "group": "Others",
- "pages": [
- "general/others/billing-subscriptions",
- "general/others/blocklist",
- "general/others/how-is-bowser-extension-different-from-a-desktop-app",
+ },
{
- "group": "SSO",
+ "group": "Debugging & Interception",
"pages": [
- "general/others/sso",
- "general/others/sso/how-to-set-up-sso-with-microsoft-entra-id",
- "general/others/sso/setup-sso-with-okta"
+ "guides/how-to-avoid-intercepting-certain-domains-on-the-desktop-app",
+ "guides/how-to-use-requestly-extension-in-browserstack-live",
+ "guides/requestly-integration-browserstack-app-live",
+ "guides/disable-rule-application-status-widget",
+ "guides/disable-rules-syncing",
+ "guides/can-i-log-in-to-requestly-using-my-browserstack-account",
+ "guides/how-to-update-requestly-extension-manually"
+ ]
+ },
+ {
+ "group": "Other",
+ "pages": [
+ "guides/other/claim-your-requestly-github-student-pack-benefit"
]
}
]
- }
- ]
- },
- {
- "tab": "Guides",
- "icon": "lightbulb",
- "groups": [
- {
- "group": "Overview",
- "pages": [
- "guides/how-to-modify-cookies-using-requestly",
- "guides/modify-http-headers-in-web-automation-using-requestly",
- "guides/modify-html-document-using-modify-api-response-rule",
- "guides/how-to-use-shared-state-to-aggregate-data-and-use-across-requestly-rules",
- "guides/intercepting-and-modifying-network-requests-in-web-automation-frameworks-like-selenium-and-playwright",
- "guides/disable-rule-application-status-widget",
- "guides/disable-rules-syncing",
- "guides/modifying-response-asynchronously",
- "guides/how-to-avoid-intercepting-certain-domains-on-the-desktop-app",
- "guides/how-to-conditionally-fail-requests-based-on-request-counts",
- "guides/how-to-use-requestly-extension-in-browserstack-live",
- "guides/requestly-integration-browserstack-app-live",
- "guides/record-and-mock-flaky-apis-in-bulk",
- "guides/can-i-log-in-to-requestly-using-my-browserstack-account",
- "guides/how-to-update-requestly-extension-manually"
- ]
},
{
- "group": "Other",
- "pages": [
- "guides/other/claim-your-requestly-github-student-pack-benefit"
- ]
- }
- ]
- },
- {
- "tab": "Public APIs",
- "icon": "code",
- "groups": [
- {
- "group": "Overview",
+ "group": "Public APIs",
"pages": [
"public-apis/overview",
"public-apis/create-group",
@@ -350,39 +351,38 @@
"public-apis/delete-group",
"public-apis/delete-rule"
]
- }
- ]
- },
- {
- "tab": "Troubleshoot",
- "icon": "wrench",
- "groups": [
- {
- "group": "HTTP Interceptor",
- "pages": [
- "troubleshoot/http-interceptor/unable-to-intercept-web-traffic-on-browser-mobile-or-emulator",
- "troubleshoot/http-interceptor/intercepting-requests-from-localhost",
- "troubleshoot/http-interceptor/system-wide-proxy-not-working-macos",
- "troubleshoot/http-interceptor/troubleshooting-proxy-not-shown-windows",
- "troubleshoot/http-interceptor/troubleshooting-untrusted-ssl-certificate",
- "troubleshoot/http-interceptor/install-certificate-windows",
- "troubleshoot/http-interceptor/troubleshooting-safari",
- "troubleshoot/http-interceptor/disable-system-wide-proxy-macos"
- ]
- },
- {
- "group": "HTTP Rules",
- "pages": [
- "troubleshoot/http-rules/rules-not-working",
- "troubleshoot/http-rules/error-on-saving-rule",
- "troubleshoot/http-rules/rule-changes-not-reflecting-in-chrome-devtools"
- ]
},
{
- "group": "Miscellaneous",
+ "group": "Troubleshoot",
"pages": [
- "troubleshoot/miscellaneous/troubleshooting-login-issues",
- "troubleshoot/miscellaneous/how-to-check-your-requestly-version-in-the-browser"
+ {
+ "group": "Interception Setup",
+ "pages": [
+ "troubleshoot/http-interceptor/unable-to-intercept-web-traffic-on-browser-mobile-or-emulator",
+ "troubleshoot/http-interceptor/intercepting-requests-from-localhost",
+ "troubleshoot/http-interceptor/troubleshooting-untrusted-ssl-certificate",
+ "troubleshoot/http-interceptor/install-certificate-windows",
+ "troubleshoot/http-interceptor/system-wide-proxy-not-working-macos",
+ "troubleshoot/http-interceptor/troubleshooting-proxy-not-shown-windows",
+ "troubleshoot/http-interceptor/troubleshooting-safari",
+ "troubleshoot/http-interceptor/disable-system-wide-proxy-macos"
+ ]
+ },
+ {
+ "group": "Rules & Traffic Modification",
+ "pages": [
+ "troubleshoot/http-rules/rules-not-working",
+ "troubleshoot/http-rules/error-on-saving-rule",
+ "troubleshoot/http-rules/rule-changes-not-reflecting-in-chrome-devtools"
+ ]
+ },
+ {
+ "group": "Account & Miscellaneous",
+ "pages": [
+ "troubleshoot/miscellaneous/troubleshooting-login-issues",
+ "troubleshoot/miscellaneous/how-to-check-your-requestly-version-in-the-browser"
+ ]
+ }
]
}
]
@@ -695,7 +695,7 @@
},
{
"source": "/desktop-app/setup/connect-existing-browser-profile",
- "destination": "http://localhost:3000/general/http-interceptor/desktop-app/browser-interception#connect-existing-browser-profile"
+ "destination": "/general/http-interceptor/desktop-app/browser-interception#connect-existing-browser-profile"
},
{
"source": "/desktop-app/setup/android",
diff --git a/general/api-client/design-apis.mdx b/general/api-client/design-apis.mdx
index 460459b..c5da295 100644
--- a/general/api-client/design-apis.mdx
+++ b/general/api-client/design-apis.mdx
@@ -17,7 +17,7 @@ The **API Builder** in Requestly helps you design APIs, manage them using collec
* To start creating APIs, click the `+ New` button at the top left of the API Builder. This provides three options:
- * **API Request**: [Create a new API request](/general/api-client/make-an-api-request).
+ * **API Request**: [Create a new API request](/general/api-client/send-api-request/overview).
* **API Collection**: Organise multiple requests under [a collection](/general/api-client/api-collections).
diff --git a/general/api-client/overview.mdx b/general/api-client/overview.mdx
index 73e5807..a50d285 100644
--- a/general/api-client/overview.mdx
+++ b/general/api-client/overview.mdx
@@ -3,183 +3,93 @@ title: API Client Overview
label: Overview
slug: overview
description: >-
- Build, test, and debug APIs with Requestly's powerful API Client. A modern, intuitive platform for API development, testing, and collaboration.
+ Learn when to use Requestly API Client, how to get started fast, and which workflows to explore next.
seoDescription: >-
- Learn about Requestly - a comprehensive tool for designing, testing, and managing APIs with support for collections, environments, scripts, and team collaboration.
+ Learn how to use Requestly API Client for API testing, environments, collections, scripts, and assertions.
visibility: PUBLIC
---
-***
+Requestly API Client is the fastest place to start when your goal is to send requests, inspect responses, organize APIs, and automate API testing workflows.
-## What is Requestly?
+## When To Use API Client
-Requestly is a modern, browser-based and desktop tool for designing, testing, and debugging APIs. Whether you're a frontend developer testing endpoints, a backend engineer validating API contracts, or a QA professional running test suites, the API Client streamlines your entire API workflow.
+Use API Client when you want to:
+
+- send REST or GraphQL requests manually
+- manage collections, folders, and reusable environments
+- add authorization, scripts, and assertions
+- run repeatable request flows and share them with your team
+
+If your goal is to inspect live traffic from an app or browser, start with [HTTP Interceptor](/general/http-interceptor/overview) instead. If you need to rewrite traffic in-place, use [HTTP Rules](/general/http-rules/overview).
+
+## What You Can Do Here
- Test any REST API or GraphQL endpoint with full support for all HTTP methods
+ Test REST and GraphQL APIs with full request and response controls.
- Group related APIs into collections for better project structure
+ Group related APIs into collections, folders, and reusable workflows.
- Use environment and collection variables to switch contexts seamlessly
+ Switch between environments and reuse dynamic values safely.
- Write pre-request and post-response scripts in JavaScript
+ Add scripts, assertions, and automation logic in JavaScript.
+## What You Need Before You Start
-***
-
-## Why Choose Requestly?
-
-
-
- Works directly in your browser or desktop app with no complex setup required. Start testing APIs in seconds.
-
-
-
- Switch between development, staging, and production environments with a single click using environment variables.
-
-
-
- Never lose a request - access your complete request history and replay any previous API call instantly.
-
-
-
- Share collections, environments, and requests with your team through workspaces for seamless collaboration.
-
-
-
- Built-in support for API Key, Bearer Token and Basic Auth authentication methods.
-
-
-
-***
-
-## Core Features
+- a browser or desktop access to Requestly
+- an endpoint to test, such as `https://app.requestly.io/echo`
+- optional credentials or tokens if your API requires authorization
-### **Build & Test APIs**
+## First Success Path
-Create and send HTTP requests with an intuitive interface. Configure methods, headers, query parameters, and request bodies with ease.
-
-
-
- Learn how to send your first API request and view responses
-
-
- Test GraphQL APIs with query and mutation support
-
-
-
-### **Organize Your Workflow**
+
+
+ Launch API Client from Requestly and create a new request.
+
+
+ Start with the [API Client quick start](/general/api-client/quick-start) to send a request and inspect the response.
+
+
+ Move your requests into [collections](/general/api-client/api-collections) and set up [environments](/general/api-client/environments-and-variables) so you can reuse them across projects.
+
+
+ Add [authorization](/general/api-client/send-api-request/authorization), [scripts](/general/api-client/scripts), and [tests](/general/api-client/tests) to make the workflow repeatable.
+
+
-Keep your API projects organized with collections and smart grouping features.
+## Explore By Workflow
-
- Group related requests into collections and sub-folders
+
+ Follow the guided beginner walkthrough from first request to environments.
-
- Execute multiple requests sequentially for testing workflows
+
+ Learn request configuration, headers, body handling, authorization, and history.
-
-
-### **Dynamic Configuration**
-
-Use variables and environments to make your API testing flexible and reusable across different contexts.
-
-
-
- Master environment, collection, and global variables
+
+ Switch between dev, staging, and production without rewriting requests.
-
- Switch between dev, staging, and production
-
-
- Understand how variable scoping works
-
-
-
-### **Automate & Extend**
-
-Add custom logic to your API requests with scripts and automated testing.
-
-
-
- Run JavaScript before and after requests
+
+ Add scripts, tests, and collection runs for repeatable API validation.
-
- Write automated tests for your API responses
+
+ Bring work in from cURL, Postman, or OpenAPI and share collections back out.
-
- Export requests as code in multiple languages
+
+ Execute multi-request workflows against environments and test data.
-### **Secure Your APIs**
-
-Configure authentication for protected endpoints with multiple auth methods.
-
-
- Set up API Key, Bearer Token, Basic Auth, and more
-
-
-### **Import & Export**
-
-Migrate from other tools or share your work with team members.
+## Related Capabilities
-
- Convert cURL commands to requests instantly
-
-
- Migrate your Postman collections seamlessly
-
-
- Import OpenAPI/Swagger specifications
-
-
- Export and share your API collections
-
-
-
-***
-
-## Getting Started
-
-Ready to start testing APIs? Follow these quick steps:
-
-
-
- Use the [Browser Extension](/general/http-interceptor/browser-extension) or [Desktop App](/general/http-interceptor/desktop-app). See the [comparison guide](/general/api-client/difference-between-desktop-app-and-browser-extension) to help you decide.
-
-
-
- Navigate to API Client → Click **+ New** → Select **Request** → Enter a URL and click **Send**. [View detailed guide →](/general/api-client/send-api-request)
-
-
-
- Group related APIs into collections for better project management. [Learn more →](/general/api-client/api-collections)
-
-
-
- Set up environment variables to manage different API environments. [Configure environments →](/general/api-client/environments-and-variables)
-
-
-
-***
-
-## Next Steps
-
-
-
- New to API Client? Start here with our beginner-friendly guide
-
-
- Learn how to send API requests and view responses
+
+ Use HTTP Rules when you need to rewrite live requests and responses during testing.
-
- Organize your APIs into collections for better project management
+
+ Use HTTP Interceptor when you need to inspect what your app is sending over the network.
diff --git a/general/api-mocking/create-cloud-based-mocks.mdx b/general/api-mocking/create-cloud-based-mocks.mdx
index bbbc059..f5fdd9c 100644
--- a/general/api-mocking/create-cloud-based-mocks.mdx
+++ b/general/api-mocking/create-cloud-based-mocks.mdx
@@ -5,16 +5,16 @@ slug: create-cloud-based-mocks
description: Learn how to create modify and manage mock files in requestly
visibility: PUBLIC
---
-Cloud-based mocks let you simulate API responses by hosting mock data online instead of running a local server. With Requestly’s File Server, you can upload mock files (like JSON or HTML) and redirect real API requests to these files. It’s a fast, shareable, and reliable way to mock backend APIs—perfect for frontend development or testing in isolation.
+Cloud-based mocks let you simulate API responses by hosting mock data online instead of running a local server. With Requestly’s Mock Server, you can upload mock files like JSON or HTML and redirect real API requests to these files. It’s a fast, shareable, and reliable way to mock backend APIs for frontend development and testing in isolation.
## How to Create a Cloud-based Mock
-To create a cloud mock, you’ll first create a file on the File Server and then set up a Redirect Rule to serve it in place of a real API.
+To create a cloud mock, you’ll first create a file in Mock Server and then set up a Redirect Rule to serve it in place of a real API.
-### Step 1: Create a File on Requestly’s File Server
+### Step 1: Create a File in Requestly Mock Server
-
+
From the Requestly Dashboard, go to the **Files** tab in the sidebar.
@@ -47,7 +47,7 @@ To create a cloud mock, you’ll first create a file on the File Server and then
-### Step 2: Redirect API Requests to the File Server
+### Step 2: Redirect API Requests to Mock Server
@@ -75,7 +75,7 @@ To create a cloud mock, you’ll first create a file on the File Server and then
- Paste the File Server URL copied earlier. You can also select the file directly from your File Server.
+ Paste the Mock Server URL copied earlier. You can also select the file directly from Mock Server.
diff --git a/general/getting-started/introduction.mdx b/general/getting-started/introduction.mdx
index adb89f9..51a0455 100644
--- a/general/getting-started/introduction.mdx
+++ b/general/getting-started/introduction.mdx
@@ -2,133 +2,91 @@
title: "Introduction"
label: "Introduction"
slug: "introduction"
-description: "Welcome to Requestly’s Documentation!"
+description: "Start here to understand Requestly, choose the right workflow, and get to your first success quickly."
visibility: "PUBLIC"
---
-
----
-
-Requestly is an open-source tool for API Mocking, Testing, and Debugging. It serves as a valuable companion for developers, offering the following features:
-
-- Send API requests using the API Client
-- Create, manage, and collaborate on API contracts
-- Override APIs by modifying headers, request bodies, response bodies, status codes, and adding delays
-- Mock API responses
-- Record Bug Reports
-
-This documentation provides official information on incorporating Requestly into your development workflows.
-
-Below is an introduction to each section of this documentation, allowing you to quickly navigate to the solution you need.
-
-## Getting Started
-
-If you are new to Requestly, We recommend you start with the [getting started](/general/getting-started/quick-start-guide) section.
-
-## API Client
-
-### Send API Request
-
-Use Requestly to send requests to the APIs you're working with. Learn more about [Send API requests and get response data](/general/api-client/make-an-api-request) in Requestly.
-
-### Design APIs
-
-Requestly supports designing APIs using its API Builder embedded into [API Client](/general/api-client/overview). Designing APIs in Requestly helps you streamline the rest of the development flow like testing, mocking, and debugging your APIs.
-
-Support of [collections](/general/api-client/api-collections), [environments](/general/api-client/environments-and-variables), and [scripts](/general/api-client/scripts) lets you design your API contracts quickly. Your API definition can serve as the single source of truth for your projects. Sharing APIs within or across teams is fast and easy.
-
-Start [designing your APIs in Requestly using API Builder](/general/api-client/make-an-api-request).
-
-### Develop APIs
-
-Use Requestly to help you during API development, learn how to use Requestly to speed up API Development.
-
-### Using Variables
-
-Use variables to control the variable parts of API Requests, such as the root URL, tokens, etc., that vary across environments. Learn more under [environment variables](/general/api-client/environments-and-variables). Requestly also supports collection-level variables for use within a collection.
-
-## HTTP Rules
-
-### Override APIs / Network Calls
-
-Requestly offers powerful HTTP Rules that enable you to modify network requests and responses effortlessly. You can override headers, edit the request body, customize the response body, or even change the response status code quickly. Additionally, you can modify query parameters to add, update, or delete parameters in a URL, and modify user-agent strings to simulate different devices or browsers. You can also cancel requests before they are executed.
-
-Explore [Modify Headers](/general/http-rules/rule-types/modify-headers), [Modify Query Parameters](/general/http-rules/rule-types/modify-query-params), [Modify User-Agent](/general/http-rules/rule-types/modify-user-agents), [Modify Request Body](/general/http-rules/rule-types/modify-request-body), [Modify API Response](/general/http-rules/rule-types/modify-response-body), and [Cancel Request](/general/http-rules/rule-types/cancel-rule) for step-by-step instructions and examples.
-
-### Redirect Network Calls/APIs
-
-Requestly provides two ways to redirect a network request, whether it is a script file, image, API, or any other resource. The [Redirect Rule](/general/http-rules/rule-types/redirect-rule) matches URL conditions and redirects all matching requests to a predefined URL. The [Replace Rule](/general/http-rules/rule-types/replace-strings) is more versatile, allowing you to match a URL, replace a part of it to create a new URL and redirect the request to this newly constructed URL.
-
-### Add Network Delay
-
-You can simulate network delays using the [Delay Rule](/general/http-rules/rule-types/delay-request), which allows you to add a delay (in milliseconds) to matching URLs. This is particularly helpful for testing your application's behavior under slow network conditions or during a slow process.
-
-### Insert Scripts
-
-The [Insert Scripts Rule](/general/http-rules/rule-types/modify-dominject-scripts) in Requestly enables you to make dynamic, on-the-fly changes to a webpage’s content or behavior without needing to access or modify the source code.
-
-## API Mocking
-
-API Mocking enables you to simulate APIs for testing and development without depending on live backend systems. Requestly supports two types of API Mocking: [Local Mocks](/general/http-rules/rule-types/modify-response-body), which can be created individually or in bulk by recording a live session for offline or quick testing, and [Cloud-Based Mocks](/general/mock-server/overview), which are hosted on Requestly’s platform for easy sharing and collaboration.
-
-## Team Collaboration
-
-Requestly makes teamwork seamless and efficient with [Team Workspaces](/general/others/workspaces). You can [add team members](/general/others/workspace/how-to-get-started-with-shared-workspace#adding-new-members), [assign specific roles](/general/others/workspace/user-roles), and manage [permissions](/general/others/workspace/user-roles#permissions-overview) through Role-Based Access Control (RBAC). This ensures that only authorized users can access or modify sensitive resources. Workspaces allow you to share HTTP Rules, saved sessions, API collections, environment variables, and mocks while maintaining security and control. With well-defined roles and permissions, Requestly helps you organize resources effectively and enables effortless collaboration without compromising access control.
-
-## Sessions
-
-Requestly’s **Sessions** feature provides powerful tools for capturing, analyzing, and sharing network activity. You can
-record API sessions
-
-, replay them for testing, and even use them for bulk mocking. It also allows you to [record bug reports](/general/session-book/record-session), capturing screen activity, console logs, network logs, and environment details to create replicable bug reports for developers.
-
-Additionally, you can
-import and view HAR files
-
-directly within Requestly for seamless analysis. To ensure security, sessions come with
-access control options
-
-, allowing you to manage who can view or use the recorded sessions.
-
-
- We do not record Request Headers because they often contain authentication and authorization information.
-
-
-## Requestly Public API
-
-Requestly's [Public API](/public-apis/overview) enables seamless integration into your CI/CD pipelines, allowing you to programmatically manage HTTP rules for automated testing and deployments. With the API, you can add, update, delete, and retrieve rules, simplifying workflows like creating staging environments or updating configurations dynamically.
-
-## Imports
-
-Requestly's Imports feature lets you easily migrate configurations from tools like [Postman](/general/api-client/migrate-from-postman), [Charles Proxy](/general/http-rules/others/charles-proxy-importer),
-Modheader
-
-, and
-Resource Override
-
-, unifying your workflows within a single platform.
-
-## Security & Privacy
-
-At Requestly, we prioritize [security and privacy](/general/getting-started/security-privacy) across all aspects of our platform. Being
-open source
-
-, our codebase is transparent and auditable. Our robust
-infrastructure
-
-ensures reliable performance and data security, further backed by
-SOC 2 compliance
-
-for industry-standard safeguards. Learn more about the security and privacy measures implemented for the
-API Client
-
-,
-HTTP Rules
-
-,
-HTTP Interceptor
-
-, and [Session Book](/security-privacy/sessions) in our detailed documentation.
-
-## Billing
-
-Requestly's [Billing section](/general/others/billing-subscriptions) simplifies license and subscription management for teams. Through the Billing Team Dashboard, admins can assign or revoke licenses and manage roles like Billing Manager, Admin, and Member to streamline access and collaboration.
\ No newline at end of file
+Requestly helps you test APIs, intercept traffic, modify requests and responses, mock backend behavior, and share debugging context with your team.
+
+If you are new to Requestly, start by choosing the workflow that matches what you want to do first.
+
+## Choose Your Path
+
+
+
+ Send your first request, organize collections, add environments, and validate responses.
+
+
+ Use the Browser Extension when you want to inspect and modify traffic in the browser.
+
+
+ Use the Desktop App when you need proxy-based interception for mobile apps, emulators, terminal tools, or system traffic.
+
+
+ Rewrite headers, bodies, query params, and responses without changing your application code.
+
+
+ Build reusable mock APIs and hosted responses for testing, demos, and collaboration.
+
+
+ Record bug reports, capture API sessions, import HAR files, and share findings with your team.
+
+
+
+## Understand The Product Areas
+
+### API Testing
+
+Use the [API Client](/general/api-client/overview) to send requests, organize collections, manage environments, write assertions, and automate test flows.
+
+### Debugging & Interception
+
+Use the [HTTP Interceptor](/general/http-interceptor/overview) when you need to inspect live traffic from a browser, desktop app, mobile device, emulator, terminal, or Node.js runtime.
+
+### Modify Traffic
+
+Use [HTTP Rules](/general/http-rules/overview) to modify headers, redirect requests, rewrite bodies, delay responses, inject scripts, or map requests to local and remote resources.
+
+### Mock APIs & Responses
+
+Use [API Mocking](/general/api-mocking/api-mocking) and [Mock Server](/general/mock-server/overview) to simulate backend behavior for development, testing, demos, and failure scenarios.
+
+### Collaboration & Sessions
+
+Use [Sessions](/general/sessions/overview) and [Workspaces](/general/team/workspaces) to capture debugging context, share reproducible artifacts, and collaborate across teams.
+
+## Recommended First Steps
+
+
+
+ If you only need browser-based traffic tools, start with the Browser Extension. If you need to intercept mobile apps, emulators, localhost traffic, or system-wide traffic, use the Desktop App.
+
+
+ Use the [platform comparison guide](/general/api-client/difference-between-desktop-app-and-browser-extension) if you are not sure which setup to choose.
+
+
+
+ Follow either the [Browser Extension setup](/general/getting-started/quick-start-guide/browser-extension-setup) or [Desktop App setup](/general/getting-started/quick-start-guide/desktop-app-setup) guide.
+
+
+ Pick one clear first task:
+
+ - [Send your first API request](/general/api-client/quick-start)
+ - [Inspect live traffic](/general/http-interceptor/overview)
+ - [Create your first traffic rule](/general/http-rules/rule-types)
+ - [Create your first mock](/general/mock-server/create/create-mock-api)
+
+
+
+## Next Steps
+
+
+
+ Follow the guided onboarding flow for the most common Requestly workflows.
+
+
+ Get help with certificate, localhost, proxy, and device interception issues.
+
+
+ Automate Requestly workflows programmatically.
+
+
\ No newline at end of file
diff --git a/general/getting-started/quick-start-guide.mdx b/general/getting-started/quick-start-guide.mdx
index c633e1c..d670614 100644
--- a/general/getting-started/quick-start-guide.mdx
+++ b/general/getting-started/quick-start-guide.mdx
@@ -3,46 +3,91 @@ title: Quick Start
label: Quick Start
slug: quick-start-guide
description: >-
- Discover Requestly’s powerful tools for API development, traffic debugging,
- and collaboration — from browser extensions to desktop apps and HTTP rules.
+ Choose the right Requestly workflow, complete setup, and get to your first successful task quickly.
visibility: PUBLIC
---
-***
+Requestly can support several workflows, but most new users only need one path to start. Use this page to pick the right setup and reach your first success faster.
-## Learn More About Requestly Features
-
-Whether you're planning APIs, mocking endpoints, or debugging network traffic, Requestly simplifies every stage of API development.
+## Pick Your Starting Workflow
-
- Learn how to navigate and use Requestly’s Browser Extension. Intercept & modify traffic directly inside your browser, available for Chrome, Firefox, Edge, Brave, Arc, Vivaldi, and Opera.
+
+ Best for sending requests, working with collections, managing environments, and writing assertions.
-
-
- Go beyond the browser with Requestly’s Desktop App. Intercept traffic from mobile apps, desktop software, and simulators. Mock local files, analyse HAR files, and record sessions — all from a single interface.
+
+ Best for intercepting and modifying requests directly in supported browsers.
-
-
- Modern web-based API client that runs in your browser and standalone desktop app. Send API requests, define contracts, organize collections, and test endpoints — all in one place.
+
+ Best for mobile apps, emulators, localhost traffic, command-line tools, and system-wide debugging.
-
-
- Create rules to modify requests/responses in real-time. Redirect URLs, replace content, inject scripts, cancel requests, and more all in your browser without touching any code.
+
+ Best for modifying headers, redirecting URLs, rewriting responses, and simulating backend behavior.
+
-
- Host your JSON, JS, or CSS files and get public URLs to use in testing and development. Ideal for mocking API responses or replacing scripts/styles into pages.
-
+## Which Setup Should You Choose?
-
- Inspect live network traffic from your browser, mobile device, or desktop app. Capture requests/responses with full headers and body content.
-
+
+
+ Choose the Browser Extension when:
-
- Record sessions of your activity including network logs, console logs, local storage, screen recording, and environment details. Useful for sharing bug reports bug reports.
-
+ - you only need browser-based workflows
+ - you want quick setup with no system proxy configuration
+ - you plan to inspect traffic, create rules, or use the API Client in the browser
+
+
+ Install the extension, understand the interface, and learn what it can do.
+
+
+
+ Choose the Desktop App when:
+
+ - you need to intercept mobile devices, emulators, or desktop apps
+ - you need system-wide or proxy-based interception
+ - you want richer network capture, HAR workflows, or advanced debugging
-
- Create shared collections, sync rules, and collaborate with your team. Perfect for managing test environments and large projects.
+
+ Install the desktop app and connect the right runtime for your workflow.
+
+
+
+
+
+ Still deciding? Read the [Browser Extension vs Desktop App comparison](/general/api-client/difference-between-desktop-app-and-browser-extension).
+
+
+## Reach Your First Success
+
+
+
+ Finish either the [Browser Extension setup](/general/getting-started/quick-start-guide/browser-extension-setup) or [Desktop App setup](/general/getting-started/quick-start-guide/desktop-app-setup).
+
+
+ Start with one clear outcome instead of exploring every feature at once.
+
+ - [Send your first API request](/general/api-client/quick-start)
+ - [Inspect traffic with HTTP Interceptor](/general/http-interceptor/overview)
+ - [Create your first HTTP Rule](/general/http-rules/rule-types)
+ - [Create your first mock](/general/mock-server/create/create-mock-api)
+
+
+ After your first successful task, expand into environments, assertions, automation, sessions, and collaboration workflows.
+
+
+
+## Common Journeys
+
+
+
+ Start with API Client if your immediate goal is testing an endpoint.
+
+
+ Start with HTTP Rules if you need to change traffic without updating application code.
+
+
+ Start with HTTP Interceptor if you need to see live network traffic and trace issues.
+
+
+ Start with Sessions if you need reproducible bug reports or sharable network captures.
diff --git a/general/getting-started/quick-start-guide/browser-extension-setup.mdx b/general/getting-started/quick-start-guide/browser-extension-setup.mdx
index 6afaf91..5273bba 100644
--- a/general/getting-started/quick-start-guide/browser-extension-setup.mdx
+++ b/general/getting-started/quick-start-guide/browser-extension-setup.mdx
@@ -54,10 +54,10 @@ The Web App can be accessed using the `Open App` button in the Extension Popup
2. **Network Inspector**: Similar to the browser’s dev tools, but with additional features.
3. **HTTP Rules**: Allows you to override network requests by modifying parts of the request or redirecting them—our most popular feature.
4. **Sessions**: Contains saved sessions from the Extension Popup discussed earlier.
-5. **File Server**: Allows you to host custom files (JSON, JS, CSS) in the cloud and generate shareable endpoints.
+5. **Mock Server**: Allows you to host custom files and mock endpoints in the cloud so you can test APIs and resource overrides with shareable URLs.
6. **API Client**: Offers an intuitive interface to create, manage, and call APIs.
-Each section is explained in detail in its respective documentation. Visit Network Inspector, HTTP Rules, Sessions, File Server, and API Client for a deeper dive.
+Each section is explained in detail in its respective documentation. Visit Network Inspector, HTTP Rules, Sessions, Mock Server, and API Client for a deeper dive.
+
+ Start with API Testing if you want a quick first success.
+
+
+ Learn how interception works inside the browser extension.
+
+
+ Modify headers, redirect URLs, or rewrite responses without changing application code.
+
+
+ Check common extension and rules issues if traffic changes are not applying.
+
+
\ No newline at end of file
diff --git a/general/getting-started/quick-start-guide/desktop-app-setup.mdx b/general/getting-started/quick-start-guide/desktop-app-setup.mdx
index 678cfc2..e44e3c5 100644
--- a/general/getting-started/quick-start-guide/desktop-app-setup.mdx
+++ b/general/getting-started/quick-start-guide/desktop-app-setup.mdx
@@ -43,3 +43,31 @@ The Desktop App interface closely mirrors the Web App interface, maintaining a c
The Desktop App’s additional capabilities make it ideal for scenarios requiring non-browser traffic interception and advanced mocking.
+
+## When To Use The Desktop App
+
+Use the Desktop App when you want to:
+
+- intercept traffic from mobile apps, emulators, desktop apps, terminal tools, or Node.js
+- capture system-wide traffic through a local proxy
+- work with localhost traffic and advanced debugging scenarios
+- record API sessions, import HAR files, or create mocks from captured traffic
+
+If you only need browser-based interception and a lighter setup, start with the [Browser Extension setup](/general/getting-started/quick-start-guide/browser-extension-setup).
+
+## Recommended Next Steps
+
+
+
+ Learn how Requestly interception works across browsers, devices, and runtimes.
+
+
+ Record requests and responses you can analyze, replay, or share.
+
+
+ Use captured traffic to modify, replay, or mock backend behavior.
+
+
+ Follow the interception troubleshooting path if setup is complete but traffic is missing.
+
+
diff --git a/general/http-interceptor/overview.mdx b/general/http-interceptor/overview.mdx
index 905c530..7a4e3d6 100644
--- a/general/http-interceptor/overview.mdx
+++ b/general/http-interceptor/overview.mdx
@@ -3,86 +3,85 @@ title: Overview
label: Overview
slug: overview
description: >-
- Learn how to use Requestly’s HTTP Interceptor to debug, analyze, and modify
- HTTP requests in real-time. Configure it for browsers, mobile, Node.js, and
- systemwide setups.
+ Learn when to use HTTP Interceptor, choose the right interception setup, and debug traffic across browsers, devices, and runtimes.
seoDescription: >-
- Debug HTTP requests in real-time with Requestly's HTTP Interceptor. Configure
- it for browsers, mobile, Node.js, and system-wide setups.
+ Debug HTTP traffic in real time with Requestly HTTP Interceptor for browsers, mobile devices, emulators, Node.js, terminal tools, and system-wide setups.
visibility: PUBLIC
---
-***
+HTTP Interceptor helps you inspect and debug real network traffic. Use it when you need to see what your browser, app, device, or runtime is actually sending and receiving.
-Whether you’re a developer, QA engineer, or anyone working with HTTP requests and APIs, Requestly can help you intercept and analyze network traffic in real-time. This makes debugging issues or testing changes easier without touching the code.
+## When To Use HTTP Interceptor
-## How does Requestly Interceptor work?
+Use HTTP Interceptor when you want to:
-Requestly HTTP interceptor is a web proxy that runs on your computer. By routing network requests through Requestly, you can intercept all the network traffic made by the browser or your application.
+- inspect requests and responses in real time
+- debug browser, mobile, emulator, terminal, or Node.js traffic
+- verify whether an issue is in the client, proxy, or backend
+- capture traffic for sessions, HAR analysis, or later mocking
-Reading and modifying any web request and response opens up a world of possibilities for debugging and analyzing your application. You can:
+If you already know exactly how you want to change traffic, go to [HTTP Rules](/general/http-rules/overview). If you want to test APIs manually, start with [API Client](/general/api-client/overview).
-* **Pinpoint Issues**: Identify network errors, slow responses, or missing resources.
+## Choose Your Interception Setup
-* **Test Edge Cases**: Simulate server errors or unexpected payloads.
-
-* **Inject Mock Data**: Replace live responses with custom data.
-
-* **Optimize APIs**: Refine requests to enhance performance.
-
-## Ways to intercept HTTP traffic
-
-Requestly offers two flexible ways to intercept HTTP traffic depending on your workflow and use case:
-
-### 1. **Browser extension**
-
-The **Requestly browser extension** lets you intercept and modify HTTP traffic directly inside your browser—perfect for front-end development and quick debugging.
-
-* **Best for**: Intercepting and modifying traffic in the browser
-
-* **Works across**: Web pages, browser-based applications
-
-Learn how to set up interceptor in browser extension.
-
-### 2. **Desktop app**
-
-The **Requestly Desktop App** runs a local proxy server that intercepts HTTP(S) traffic from any source, not just the browser. It’s designed for more advanced and system-wide debugging needs.
-
-* **Best for**: Advanced use cases, mobile and backend debugging
-
-* **Works across:** Browsers, mobile devices, emulators, terminal, Node.js, and system-wide applications
-
-**Platform-specific setup guides:**
-
-* [Browser Interception](/general/http-interceptor/desktop-app/browser-interception) - Configure Requestly with popular web browsers like Chrome, Firefox, Edge, etc
-
-* [Android devices](/general/http-interceptor/desktop-app/android-devices) - Intercept Traffic from your Android smartphones and tablets[.](/general/http-interceptor/browser-interception)
-
-* [Android emulator](/general/http-interceptor/desktop-app/android-simulator-interception) - Configure Android emulators in Android Studio.
-
-* [iOS Devices](/general/http-interceptor/desktop-app/ios-devices-interception) - Set up your iPhones and iPads to intercept their traffic
-
-* [iOS Emulator](/general/http-interceptor/desktop-app/ios-simulator-interception) - Use Requestly with iOS simulators in Xcode.
-
-* [Node.js](/general/http-interceptor/desktop-app/nodejs) - Integrate Requestly with Node.js applications to debug server-side network requests and responses during development or testing
-
-* [Terminal](/general/http-interceptor/desktop-app/terminal) - Use Requestly with command-line tools or scripts to intercept and manipulate HTTP requests for automation and debugging.
-
-* [Systemwide proxy](/general/http-interceptor/desktop-app/desktop-app-interception) - Configure Requestly as a systemwide proxy to capture and manipulate traffic across all applications and devices connected to your network.
-
-Once interception is set up, you can explore and debug traffic in the [**network table**](/general/http-interceptor/network-table), [export HAR files](/general/sessions/import-view-har-file), [save sessions](/general/sessions/record-api-sessions), and [create rules](/general/http-rules/rule-types) to simulate responses or rewrite requests in real-time.
+
+
+ Best for browser-only workflows and the fastest setup.
+
+
+ Best for mobile apps, emulators, localhost, terminal tools, Node.js, and system-wide traffic.
+
+
-***
+## First Success Path
+
+
+
+ Use the Browser Extension for browser-based traffic. Use the Desktop App when you need proxy-based interception outside the browser.
+
+
+ Follow one setup path and make sure the browser, device, or runtime is correctly connected to Requestly.
+
+
+ Open the [network table](/general/http-interceptor/desktop-app/network-table) or browser interception view and verify requests appear before moving on to rules or mocks.
+
+
+
+## Explore By Runtime
+
+
+
+ Connect Chrome, Firefox, Edge, and similar browsers through the Desktop App.
+
+
+ Intercept traffic from Android phones and tablets.
+
+
+ Capture traffic from Android Studio emulators.
+
+
+ Set up iPhones, iPads, and iOS simulators.
+
+
+ Debug server-side requests from Node.js applications.
+
+
+ Inspect cURL, scripts, and other command-line network activity.
+
+
-## What's Next?
+## After Traffic Starts Flowing
-
-
- Start intercepting traffic in your browser
+
+
+ Modify intercepted traffic once you know what needs to change.
+
+
+ Save traffic and debugging context for sharing, replaying, or mock creation.
-
- Set up system-wide interception with the desktop app
+
+ Analyze previously captured network data inside Requestly.
-
- Learn how to modify intercepted requests and responses
+
+ Use the troubleshooting path for certificate, localhost, proxy, or device issues.
diff --git a/general/http-rules/overview.mdx b/general/http-rules/overview.mdx
index 4b0cbc4..1dd7442 100644
--- a/general/http-rules/overview.mdx
+++ b/general/http-rules/overview.mdx
@@ -3,132 +3,81 @@ title: Overview
label: Overview
slug: overview
description: >-
- Learn how to customize HTTP requests, test traffic, and collaborate in
- workspaces with Requestly's powerful HTTP rules and advanced features.
+ Learn when to use HTTP Rules, how to create your first rule, and which traffic modification workflows to explore next.
seoTitle: Overview
seoDescription: >-
- Learn how to customize HTTP requests, test traffic, and collaborate in
- workspaces with Requestly's powerful HTTP rules and advanced features.
+ Learn how to use Requestly HTTP Rules to modify headers, redirect URLs, rewrite bodies, delay responses, and share rules.
visibility: PUBLIC
---
-***
+HTTP Rules are the fastest way to change traffic without changing your app. Use them to modify headers, rewrite request or response bodies, redirect calls, inject scripts, delay traffic, or map requests to local and remote resources.
-Requestly's HTTP Rules offer a powerful suite of tools to customize, test, and manage HTTP(S) traffic. Whether you're a developer, tester, or QA professional, these rules provide an easy way to manipulate requests and responses. Below, you'll find an introduction to each HTTP Rule with links to detailed guides.
+## When To Use HTTP Rules
-## HTTP Rules
+Use HTTP Rules when you want to:
-### Modify Request Body
+- modify headers, query params, bodies, or user agents
+- redirect requests between environments
+- simulate errors, delays, and edge cases
+- inject scripts or override resources during frontend testing
+- create repeatable traffic changes for demos, debugging, and QA
-Adjust outgoing API request payloads to meet testing and development requirements. Add static or dynamic data to refine request structures. See details in the [Modify Request Body guide](/general/http-rules/rule-types/modify-request-body).
+If your goal is to inspect live traffic first, use [HTTP Interceptor](/general/http-interceptor/overview). If you need hosted mock endpoints, use [Mock Server](/general/mock-server/overview).
-### Modify API Response
+## Start With These Rule Types
-Simulate API responses to test scenarios and edge cases. Use static data or dynamic transformations to validate application behavior. Learn more in the [Modify API Response guide](/general/http-rules/rule-types/modify-response-body).
-
-### Modify Headers
-
-Add, remove, or modify HTTP headers for debugging and control. Get started with the [Modify Headers guide](/general/http-rules/rule-types/modify-headers).
-
-### Cancel Request Rule
-
-Block specific network calls or simulate failure scenarios. Explore capabilities in the [Cancel Request Rule guide](/general/http-rules/rule-types/cancel-rule).
-
-### Modify Query Params
-
-Add, remove, or modify query parameters to refine API requests. Learn more in the [Modify Query Params guide](/general/http-rules/rule-types/modify-query-params).
-
-### Modify User Agents
-
-Test different browser and device environments by customizing User-Agent headers. Check out the [Modify User Agents guide](/general/http-rules/rule-types/modify-user-agents).
-
-### Redirect Request
-
-Redirect requests to different URLs to switch environments or resources during development. The Redirect Request guide provides details.
-
-### Replace String Rule
-
-Modify URLs or paths by replacing specific substrings. Learn more in the [Replace String Rule guide](/general/http-rules/rule-types/replace-strings).
-
-### Insert Script
-
-Inject JavaScript or CSS into web pages for advanced customization. Get started with the [Insert Script guide](/general/http-rules/rule-types/insert-scripts).
-
-### Delay Network Requests
-
-Simulate real-world network latencies by introducing delays. Configure delays using the [Delay Network Requests guide](/general/http-rules/rule-types/delay-network-requests).
-
-### Map Local
-
-Serve files from your local environment to test offline changes. Start mapping files in the [Map Local guide](/general/http-rules/rule-types/map-local).
-
-### Map Remote
-
-Redirect requests to different servers or environments for advanced testing. Learn how in the [Map Remote guide](/general/http-rules/rule-types/map-remote).
-
-***
-
-## Advanced Options
-
-### Rules Grouping
-
-Organize related rules into groups for better clarity and management. Learn more in the [Rules Grouping guide](/general/http-rules/advanced-usage/grouping).
-
-### Rules Pinning
-
-Pinning rules in Requestly lets you quickly access and manage your rules from the Chrome toolbar, streamlining your workflow. Easily toggle rules on or off without opening the app. Learn more in the Pinning Rules guide
-
-### Source Conditions
-
-Source conditions in Requestly allow you to define criteria for matching network requests, enabling precise rule application. These criteria include URL, host, or path matching, supporting advanced filters like resource type and HTTP methods. Learn more in the [Source Conditions guide](/general/http-rules/advanced-usage/source-conditions).
-
-### GraphQL Support
-
-Modify GraphQL requests and responses for flexible API interactions. Check out the [GraphQL Support guide](/general/http-rules/advanced-usage/graphql-modify-request-response).
-
-### Test this Rule
-
-**Test This Rule** feature in the HTTP Rules section lets you validate rule configurations in real-time by applying them to a specific webpage or endpoint. Learn more in the [Test This Rule guide](/general/http-rules/advanced-usage/test-rules).
-
-### Shared State
-
-Enable advanced workflows by sharing data between rules. Learn more in the [Shared State guide](/general/http-rules/advanced-usage/shared-state).
-
-### Pause/Resume Requestly
-
-Pause and Resume in Requestly lets you temporarily disable its functionality to test your website's original behavior without interference. Learn more in the [Pause and Resume guide](/general/http-rules/advanced-usage/pauseresume-requestly).
-
-### Rules Status Syncing
-
-Rules status syncing ensures consistent rule statuses across shared workspaces, automatically applying changes made by any member. Ideal for teams with non-technical roles, it guarantees universal configurations. Learn more in the [Rules Status Syncing guide](/general/http-rules/advanced-usage/rules-status-syncing).
-
-***
-
-## Rule Sharing
-
-### Share in Workspace
-
-Share in Workspace feature allows you to easily share HTTP rules within workspaces, promoting real-time collaboration and consistency among team members. Learn more in the [Share in Workspace guide](/general/http-rules/sharing/share-in-workspace).
-
-### SharedList
-
-Distribute rule collections for use across teams or environments. Learn more in the [SharedList guide](/general/http-rules/sharing/shared-list).
-
-### Download
-
-Export rules for offline use or transfer between systems. Find out how in the [Download guide](/general/http-rules/sharing/download-rules).
+
+
+ Add, remove, or overwrite headers for debugging and API testing.
+
+
+ Switch requests between environments or alternate resources instantly.
+
+
+ Simulate backend changes, mock responses, and reproduce edge cases.
+
+
+ Reproduce slow networks and performance-related issues.
+
+
-***
+## First Success Path
+
+
+
+ Start with a single change such as [Modify Headers](/general/http-rules/rule-types/modify-headers) or [Redirect Rule](/general/http-rules/rule-types/redirect-rule).
+
+
+ Use URL and source conditions to target only the traffic you want to change.
+
+
+ Use [Test This Rule](/general/http-rules/advanced-usage/test-rules), app behavior, or your API workflow to confirm the traffic changed as expected.
+
+
+
+## Explore By Workflow
+
+
+
+ Browse the full catalog of traffic modification capabilities.
+
+
+ Learn grouping, source conditions, testing, shared state, and filters.
+
+
+ Share, sync, and distribute rules with your team or workspace.
+
+
+ Migrate rule configurations from other tools and extensions.
+
+
-## What's Next?
+## Related Capabilities
-
-
- Explore all available rule types and create your first modification
-
-
- Start by learning how to modify HTTP headers
+
+
+ Use HTTP Interceptor when you need to see requests and responses before deciding what to modify.
-
- Collaborate by sharing rules with your team members
+
+ Use Mock Server when you need reusable mock endpoints instead of in-place traffic overrides.
diff --git a/general/mock-server/create.mdx b/general/mock-server/create.mdx
index 06991d7..aa24180 100644
--- a/general/mock-server/create.mdx
+++ b/general/mock-server/create.mdx
@@ -2,10 +2,10 @@
title: Create
label: Create
slug: create
-description: 'Learn how to use File Server in requestly '
+description: 'Learn how to create and organize files and endpoints in Mock Server.'
visibility: PUBLIC
---
-File Server lets you upload JSON, CSS, and JS files and use them in your application to test features, serve APIs, or override assets, without touching production code.
+Mock Server lets you upload JSON, CSS, and JS files and use them in your application to test features, serve APIs, or override assets without touching production code.
@@ -17,6 +17,6 @@ File Server lets you upload JSON, CSS, and JS files and use them in your applica
- Group related files into Collections to keep your File Server organized. The folder structure you create inside a collection is reflected in the file URLs
+ Group related files into collections to keep Mock Server organized. The folder structure you create inside a collection is reflected in the file URLs.
diff --git a/general/mock-server/import-and-export-mocks.mdx b/general/mock-server/import-and-export-mocks.mdx
index 0d43714..41c51d9 100644
--- a/general/mock-server/import-and-export-mocks.mdx
+++ b/general/mock-server/import-and-export-mocks.mdx
@@ -4,19 +4,19 @@ label: Import and Export Files
slug: import-and-export-mocks
visibility: PUBLIC
---
-Requestly makes it easy to import and export File Server files as JSON. This helps you share, back up, or reuse mocks across different projects with just a few clicks.
+Requestly makes it easy to import and export Mock Server files as JSON. This helps you share, back up, or reuse mocks across different projects with just a few clicks.
### Steps to Import Files:
- Go to [File Server](https://app.requestly.io/mock-server/apis). Under the JSON Files section, click on the Import button.
+ Go to [Mock Server](https://app.requestly.io/mock-server/apis). Under the JSON Files section, click on the Import button.
- Select the JSON file containing the files you want to import. Review the list, then click **Import** to add them to your File Server.
+ Select the JSON file containing the files you want to import. Review the list, then click **Import** to add them to Mock Server.
@@ -24,7 +24,7 @@ Requestly makes it easy to import and export File Server files as JSON. This hel
- Use the checkboxes to select the files you want to export from the File Server.
+ Use the checkboxes to select the files you want to export from Mock Server.
diff --git a/general/mock-server/overview.mdx b/general/mock-server/overview.mdx
index 65d48ba..145c5b9 100644
--- a/general/mock-server/overview.mdx
+++ b/general/mock-server/overview.mdx
@@ -2,32 +2,57 @@
title: Overview
label: Overview
slug: overview
+description: "Learn when to use Mock Server, how it differs from in-place traffic modification, and how to create your first hosted mock."
visibility: PUBLIC
---
-Requestly’s **File Server** lets you upload and serve files (like JSON, JS, CSS, images, etc.) over a secure URL—perfect for local development and testing.
+Requestly Mock Server lets you host reusable mock endpoints and static assets for testing, demos, and development workflows.
-**Use Cases of File Server**
+You may still see older references to "File Server" in parts of the product. In the docs, this capability is documented as **Mock Server** because its main value is helping you simulate APIs and serve mock resources.
-* Host a JSON file and use it as an API endpoint
+## When To Use Mock Server
-* Redirect live CSS files to your styles hosted on the File Server
+Use Mock Server when you want to:
-* Replace production JavaScript with development versions to test new features safely
+- create hosted mock APIs for frontend or QA work
+- serve JSON, JavaScript, CSS, images, or other test assets over a public URL
+- share reusable mocks with teammates
+- combine hosted mocks with [HTTP Rules](/general/http-rules/overview) to redirect live requests to mock endpoints
-You can use files hosted on the File Server with the [**Redirect Rule**](/general/http-rules/rule-types/redirect-rule) to map live network requests to your hosted files, making it easy to simulate APIs or override resources without changing the actual code.
+If you only need to change traffic inside your current browser or app session, [HTTP Rules](/general/http-rules/overview) may be faster. If you need a quick local response override, [API Mocking](/general/api-mocking/api-mocking) may be a better fit.
-***
+## First Success Path
-## What's Next?
+
+
+ Start with [Create Mock API](/general/mock-server/create/create-mock-api) to define an endpoint and response.
+
+
+ Verify the response using [Test Mock APIs](/general/mock-server/test) or your preferred client.
+
+
+ Use the mock directly, or pair it with [Redirect Rule](/general/http-rules/rule-types/redirect-rule) to switch traffic to your hosted mock.
+
+
-
+## Explore By Workflow
+
+
- Learn how to create and configure mock APIs
+ Build and publish your first mock endpoint.
- Test your mocks before integrating them
+ Validate responses before connecting apps or teammates.
- Add dynamic responses with templating
+ Add dynamic values and richer mock behavior.
+
+
+ Move mocks between workflows and share them more easily.
+
+
+ Start with local or cloud-based quick mocks when you do not need a full hosted mock server.
+
+
+ Route live requests to your mock endpoint without changing application code.
diff --git a/general/mock-server/test.mdx b/general/mock-server/test.mdx
index 54b5ce3..c0ee297 100644
--- a/general/mock-server/test.mdx
+++ b/general/mock-server/test.mdx
@@ -1,10 +1,10 @@
---
-title: Test File Server
-label: Test File Server
+title: Test Mock Server
+label: Test Mock Server
slug: test
visibility: PUBLIC
---
-After saving a file to the File Server, you can test it directly in Requestly’s API Client to verify that the response matches your expectations.
+After saving a file or mock in Mock Server, you can test it directly in Requestly’s API Client to verify that the response matches your expectations.
diff --git a/general/sessions/access-control-of-session.mdx b/general/sessions/access-control-of-session.mdx
index e1197b5..0f9912a 100644
--- a/general/sessions/access-control-of-session.mdx
+++ b/general/sessions/access-control-of-session.mdx
@@ -3,17 +3,17 @@ title: Access Control of Session
label: Access Control of Session
slug: access-control-of-session
description: >-
- Learn how to manage access control for Session Book in Requestly, with options
+ Learn how to manage access control for Sessions in Requestly, with options
for private, shared, and specific access, ensuring secure collaboration
seoTitle: Access Control of Session
seoDescription: >-
- Learn how to manage access control for Session Book in Requestly, with options
+ Learn how to manage access control for Sessions in Requestly, with options
for private, shared, and specific access, ensuring secure collaboration
visibility: PUBLIC
---
***
-Once you get familiar with SessionBook, you can dive into managing access control for session recordings. Requestly offers flexible **Access Control**, allowing you to decide who can view, delete, and share recorded sessions. These options ensure that your recordings are shared securely with the right people, giving you full control over who has access based on your team's needs.
+Once you get familiar with Sessions, you can dive into managing access control for session recordings. Requestly offers flexible **Access Control**, allowing you to decide who can view, delete, and share recorded sessions. These options ensure that your recordings are shared securely with the right people, giving you full control over who has access based on your team's needs.
## **Sharing Options for Recordings**
diff --git a/general/sessions/overview.mdx b/general/sessions/overview.mdx
index f1f9e61..2277b5f 100644
--- a/general/sessions/overview.mdx
+++ b/general/sessions/overview.mdx
@@ -3,47 +3,76 @@ title: Overview
label: Overview
slug: overview
description: >-
- Learn how to use Session Book to record debug sessions, capture videos and
- logs, and securely share them with your team. Streamline collaboration and
- resolve issues faster
+ Learn when to use Sessions, how to record bug reports or API sessions, and how to share debugging context with your team.
seoDescription: >-
- Record, share, & debug faster with Session Book. Capture videos & logs of
- debug sessions, then securely share with your team.
+ Record bug reports, capture API sessions, import HAR files, and share debugging context with Requestly Sessions.
visibility: PUBLIC
---
-***
+Sessions help you capture the evidence around a problem so it is easier to debug, replay, share, or turn into a mock later.
-Sessions provide a structured way to record, analyze, and debug user interactions and network activity. Session Book helps QA teams and customer support professionals document issues during testing and support. On the other hand, capturing API sessions is essential for developers to effectively debug, resolve issues & create bulk mocks.
+## When To Use Sessions
-Requestly supports session creation through two primary methods:
+Use Sessions when you want to:
-* Browser Extension’s **Session Book** for **recording bug reports****.**
+- record browser activity, console logs, network logs, and environment context for bug reports
+- capture API traffic from the Desktop App for replay, analysis, or bulk mocking
+- import HAR files for investigation
+- share reproducible debugging context with teammates
-* Desktop App for **capturing API sessions**.
+You may still encounter older references to **Session Book** in the product or legacy links. In the docs, this workflow is documented under **Sessions**.
-***
+## Choose The Right Session Workflow
-### Record Bug Reports with Session Book
+
+
+ Use this path when you want browser-focused debugging context such as screen activity, console logs, network logs, and environment details.
-The Session Book in Requestly streamlines bug reporting by enabling developers to record user interactions, network logs, console logs, environment details, and changes in local storage. While it supports manual recording, you can configure it for automatic recording of user activity. This ensures developers have the context needed to reproduce and resolve issues effectively. Sessions can be shared securely, offering flexible options such as private access, link sharing, or restricted visibility.
+
+ Capture reproducible bug reports directly from the browser workflow.
+
+
+
+ Use this path when you want to record API traffic from the Desktop App, inspect requests and responses, or create mocks from captured traffic.
-***
+
+ Record and analyze network traffic from interception workflows.
+
+
+
-### Create API Sessions in Requestly
+## First Success Path
-Requestly’s Desktop App allows developers to capture and analyze API sessions through methods like the HTTP Interceptor, HAR file import, and .rqly file import. These sessions can be shared with teams by exporting and importing HAR files, making it easy to collaborate, debug issues, and streamline workflows.
-***
+
+
+ Start with browser bug reports if you need user-facing reproduction context. Start with API sessions if the problem is primarily network behavior.
+
+
+ Use [Record Bug Reports](/general/sessions/record-bug-reports) or [Record API Sessions](/general/sessions/record-api-sessions) depending on the workflow.
+
+
+ Share the session, import/export HAR files, or use captured traffic to support mocking and debugging flows.
+
+
-## What's Next?
+## Explore Sessions
-
+
- Start recording user sessions to capture bugs effectively
+ Capture browser activity and rich debugging context for issue reproduction.
- Record and replay API interactions for debugging
+ Record and analyze traffic captured from Requestly interception workflows.
- Analyze existing HAR files in Requestly
+ Open and analyze existing HAR files in Requestly.
+
+
+ Control who can view and use shared sessions.
+
+
+ Start with HTTP Interceptor if you need to capture traffic before recording a reusable session.
+
+
+ Use captured sessions to create repeatable mocking workflows.
\ No newline at end of file
diff --git a/general/sessions/record-api-sessions.mdx b/general/sessions/record-api-sessions.mdx
index 6ef6867..833f2d7 100644
--- a/general/sessions/record-api-sessions.mdx
+++ b/general/sessions/record-api-sessions.mdx
@@ -80,7 +80,7 @@ Follow these steps:
### Import a .rqly File
-Requestly also supports importing its proprietary `.rqly` file format. This is useful for loading sessions captured from the Session Book.
+Requestly also supports importing its proprietary `.rqly` file format. This is useful for loading sessions captured from browser-based Sessions workflows.
Here's how:
@@ -174,7 +174,7 @@ For more detailed instructions, check out our **Import/View HAR file page**.
+You can keep your session data for later use or **share it** with others. Use the **Export HAR** option to download session data, which can be shared or re-imported into Requestly. To learn more, visit the **Import/View HAR file page**.
### Creating Rules from Captured Sessions
diff --git a/general/sessions/record-bug-reports.mdx b/general/sessions/record-bug-reports.mdx
index 84e13c5..c02fc67 100644
--- a/general/sessions/record-bug-reports.mdx
+++ b/general/sessions/record-bug-reports.mdx
@@ -6,14 +6,14 @@ description: >-
Learn how to record screen, console logs, network lots, etc then securely
share them to speed up issue resolution.
seoDescription: >-
- Learn how to record and share debug sessions with Session Book. Capture screen
+ Learn how to record and share debug sessions with Requestly Sessions. Capture screen
recording, console logs, network lots, etc then securely share them to speed
up issue resolution.
visibility: PUBLIC
---
***
-**Session Book** helps you capture and share detailed bug reports by recording browsing sessions along with mouse movements, clicks, network logs, console logs, environment details, and LocalStorage changes. It provides all the information developers need to reproduce and debug issues, a replacement of reproduction steps.
+Requestly **Sessions** helps you capture and share detailed bug reports by recording browsing sessions along with mouse movements, clicks, network logs, console logs, environment details, and LocalStorage changes. It provides the information developers need to reproduce and debug issues without relying only on written reproduction steps.
Let’s see how to record a bug report, save it, and share it with your team.
@@ -23,7 +23,7 @@ Let’s see how to record a bug report, save it, and share it with your team.
## Configure Session Recording
-To begin using **Session Book**, the first thing you'll need to do is **set up your pages**. This ensures that the right pages are ready for recording.
+To begin using **Sessions**, the first thing you'll need to do is **set up your pages**. This ensures that the right pages are ready for recording.
@@ -171,7 +171,7 @@ Once a recording is saved, you can share it with your team using different acces
* **Only with Specific People**
-For more detailed steps on how to share and manage access, visit the Access Control section.
+For more detailed steps on how to share and manage access, visit the Access Control section.
diff --git a/troubleshoot/http-interceptor/unable-to-intercept-web-traffic-on-browser-mobile-or-emulator.mdx b/troubleshoot/http-interceptor/unable-to-intercept-web-traffic-on-browser-mobile-or-emulator.mdx
index e46fd4e..e1f00e2 100644
--- a/troubleshoot/http-interceptor/unable-to-intercept-web-traffic-on-browser-mobile-or-emulator.mdx
+++ b/troubleshoot/http-interceptor/unable-to-intercept-web-traffic-on-browser-mobile-or-emulator.mdx
@@ -5,90 +5,97 @@ slug: unable-to-intercept-web-traffic-on-browser-mobile-or-emulator
description: Troubleshooting guide to resolve common interceptor issues
visibility: PUBLIC
---
-If you're unable to intercept web traffic using the Requestly Desktop App, use the following guide to identify and resolve common issues based on your interception environment.
+Use this page as a decision tree when setup looks complete but traffic is still missing from Requestly.
-## Identify Your Interception Environment
+## Start With The Fastest Checks
-Determine where you're attempting to intercept traffic from:
+Before diving into platform-specific troubleshooting, confirm these basics:
-* Desktop browsers
+- Requestly is running and the correct browser, device, or runtime is connected
+- you completed the relevant [HTTP Interceptor setup guide](/general/http-interceptor/overview)
+- the traffic you expect is actually leaving the app or browser
+- you are looking in the correct Requestly interception view
-* System-wide traffic (entire machine)
+## Choose The Symptom That Matches Your Issue
-* iOS or Android devices
+
+
+ HTTPS traffic usually fails when the certificate is missing or not trusted.
+
+
+ Localhost and `127.0.0.1` need additional setup.
+
+
+ Revisit the matching browser or runtime setup path first.
+
+
+ Verify proxy, network, and certificate setup for the device or emulator.
+
+
-* Emulators (iOS or Android)
+## Browser And System-Wide Troubleshooting
-Each environment may require different troubleshooting steps.
+### Only HTTP Traffic Is Intercepted
-## Browsers and System-Wide Traffic
+HTTPS traffic usually means the SSL certificate is not installed or trusted correctly.
-### Issue: Only HTTP traffic is intercepted
+- Follow [Troubleshooting Untrusted SSL Certificate](/troubleshoot/http-interceptor/troubleshooting-untrusted-ssl-certificate)
+- Restart the browser or app after updating certificate trust
-If HTTPS traffic is not being intercepted, this is likely due to the SSL certificate not being installed or trusted on your system.
+### Localhost Traffic Is Missing
-Refer to the following guide:\
-[Troubleshooting Untrusted SSL Certificate](/troubleshoot/troubleshooting-untrusted-ssl-certificate)
+Intercepting `localhost` or `127.0.0.1` requires extra configuration.
-### Issue: Localhost traffic is not intercepted
+- Follow [Intercepting Requests from Localhost](/troubleshoot/http-interceptor/intercepting-requests-from-localhost)
-Intercepting traffic to `localhost` or `127.0.0.1` requires specific configuration.
+### Safari-Specific Problems
-Refer to:\
-[Intercepting Requests from Localhost](/troubleshoot/intercepting-requests-from-localhost)
+Safari can require certificate regeneration and a full app restart.
-## Mobile Devices and Emulators
+- Follow [Troubleshooting Safari](/troubleshoot/http-interceptor/troubleshooting-safari)
-### Issue: Emulator not detected by the desktop app
+## Mobile Devices And Emulators
-In rare cases, emulator may not appear in the list of connected devices. Restarting the Requestly desktop app generally resolves this issue.
+### Device Is Connected But Traffic Is Missing
-### Issue: Device is Connected, but Traffic is Not Being Intercepted
+Check all of the following:
-Please verify the following:
+- the device and desktop app are on the same network
+- the proxy settings match the Requestly desktop app
+- the SSL certificate is installed and trusted
+- the correct setup guide was followed for the device or simulator
-* The desktop app and mobile device are on the **same network**.
+Use these setup references:
-* All setup steps for the platform have been completed correctly.
+- [Android devices](/general/http-interceptor/desktop-app/android-devices)
+- [Android emulator](/general/http-interceptor/desktop-app/android-simulator-interception)
+- [iOS devices](/general/http-interceptor/desktop-app/ios-devices-interception)
+- [iOS simulator](/general/http-interceptor/desktop-app/ios-simulator-interception)
-* SSL certificate is trusted and localhost configuration is correct.
+### Emulator Is Not Detected
-Refer to: Desktop App [Setup Guide](/general/http-interceptor/desktop-app) for your device
+Restart the Requestly Desktop App and reconnect the emulator. If the emulator still does not appear, re-run the matching platform setup steps.
-### Issue: Only some mobile apps are intercepted
+### Only Some Mobile Apps Are Intercepted
-This typically occurs due to SSL pinning, especially on Android devices. SSL pinning prevents proxy-based tools from intercepting secure connections and is a technical limitation.
+This is commonly caused by SSL pinning. Proxy-based tools cannot intercept pinned secure traffic unless the app supports it.
-For further details, refer to:
+- Review the SSL pinning section in [Android devices](/general/http-interceptor/desktop-app/android-devices#ssl-pinning-if-required)
-[SSL Pinning android](/general/http-interceptor/desktop-app/android-devices#ssl-pinning-if-required)
+## Other Common Causes
-## General Troubleshooting
+### Blocked Domains
-### Blocked domains
+Make sure you did not exclude the target domain from interception.
-Ensure you have not manually excluded domains from being intercepted.\
-Refer to:\
-[How to Avoid Intercepting Certain Domains](/guides/how-to-avoid-intercepting-certain-domains-on-the-desktop-app)
-
-### Safari-specific issues
-
-If you are intercepting traffic from Safari and facing issues, regenerating the certificate can help.\
-Make sure to restart the app after regenerating the certificate.
-
-Refer to:\
-[Troubleshooting Safari](/troubleshoot/troubleshooting-safari)
+- See [How to Avoid Intercepting Certain Domains](/guides/how-to-avoid-intercepting-certain-domains-on-the-desktop-app)
## Still Need Help?
-If you're still unable to intercept traffic, contact support with the following details:
-
-* Platform you're trying to intercept from (browser, system-wide, mobile, or emulator)
-
-* Network configuration
-
-* Console or network errors (if any)
-
-* Operating system and Requestly version
+If the issue persists, collect these details before contacting support:
-This information will help our team assist you more effectively.
+- where you are intercepting from: browser, system-wide, mobile device, emulator, terminal, or Node.js
+- operating system and Requestly version
+- whether HTTP works while HTTPS fails
+- whether localhost traffic is involved
+- any visible proxy, certificate, or console errors
diff --git a/troubleshoot/http-rules/rules-not-working.mdx b/troubleshoot/http-rules/rules-not-working.mdx
index be0b4df..511f711 100644
--- a/troubleshoot/http-rules/rules-not-working.mdx
+++ b/troubleshoot/http-rules/rules-not-working.mdx
@@ -6,6 +6,17 @@ description: "Having trouble with your rules? Follow this step-by-step checklist
visibility: "PUBLIC"
---
+If your Requestly rules are not applying, use this checklist in order. Most issues come from extension permissions, paused Requestly state, inactive groups, or rule-type limitations.
+
+## Start Here
+
+Check these basics first:
+
+- the Requestly extension is installed and enabled
+- site access is allowed for the page you are testing
+- Requestly is running and not paused
+- the relevant rule group is turned on
+- you refreshed the page or retriggered the request after saving the rule
## 1. Confirm Extension Permissions
@@ -100,6 +111,18 @@ Groups allow you to organize rules into logical groups and enable/disable them i
+## 5. Recheck The Rule Match
+
+Before assuming the rule is broken, confirm that it actually matches the request:
+
+- the URL condition matches the request you are testing
+- the rule type supports the traffic you are trying to change
+- the target page is not a browser-internal page such as `chrome://`
+
+
+ Use [Test This Rule](/general/http-rules/advanced-usage/test-rules) to verify whether the rule conditions match the request you expect.
+
+
## **Common Issues by Rule Type**
> Some rule types in Requestly have specific behaviors or limitations. Here's what you need to know for each one:
@@ -132,6 +155,23 @@ When you choose the **URL** method, only the external script is loaded. Any inli
**Doesn’t run on internal browser pages**\
Scripts won’t run on pages like `chrome://`, [`file://`](file://), or other system-level pages. For testing, use a local server or the **Desktop App**.
+## Next Best Debugging Steps
+
+
+
+ Revisit when to use each rule type and the recommended first workflows.
+
+
+ Use HTTP Interceptor if you need to confirm what request is actually leaving the app.
+
+
+ Start with a simple rule type to validate your setup.
+
+
+ Switch to the Desktop App for advanced traffic scenarios and larger delay limits.
+
+
+
## Still Stuck?
If you’ve walked through all the above and the issue persists, reach out to the team at [contact@requestly.io](mailto:contact@requestly.io) **.**
\ No newline at end of file
From 00dcf28708bba3347a39ea452f417ada2fb6775a Mon Sep 17 00:00:00 2001
From: kanishkrawatt
Date: Thu, 2 Apr 2026 17:49:57 +0530
Subject: [PATCH 3/8] removed open app
---
docs.json | 6 ------
1 file changed, 6 deletions(-)
diff --git a/docs.json b/docs.json
index f2c60eb..07d0ff0 100644
--- a/docs.json
+++ b/docs.json
@@ -15,12 +15,6 @@
},
"favicon": "/images/favicon.webp",
"navbar": {
- "links": [
- {
- "label": "Open App",
- "href": "https://app.requestly.io/api-client?utm_source=docs&utm_medium=navbar&utm_campaign=get_started"
- }
- ],
"primary": {
"type": "button",
"label": "Download",
From b123548fe4c2ff6d8e28fb4b492eab8bd76b63f5 Mon Sep 17 00:00:00 2001
From: kanishkrawatt
Date: Thu, 2 Apr 2026 19:04:55 +0530
Subject: [PATCH 4/8] minor update
---
docs.json | 111 ++++++++---------
general/api-client/design-apis.mdx | 2 +-
...ween-desktop-app-and-browser-extension.mdx | 78 ++++++------
.../import-export/import-from-wsdl.mdx | 2 +-
general/api-client/overview.mdx | 112 ++++++++++++++----
general/api-client/quick-start.mdx | 9 +-
.../api-client/send-api-request/overview.mdx | 75 ------------
...w-to-get-started-with-shared-workspace.mdx | 70 +++++------
.../managing-workspace.mdx | 28 ++---
.../user-roles.mdx | 24 ++--
general/team/local-workspace.mdx | 56 ++++-----
general/team/multiple-workspaces.mdx | 66 +++++------
general/team/workspaces.mdx | 18 +--
13 files changed, 321 insertions(+), 330 deletions(-)
delete mode 100644 general/api-client/send-api-request/overview.mdx
diff --git a/docs.json b/docs.json
index 629f477..3e93833 100644
--- a/docs.json
+++ b/docs.json
@@ -29,24 +29,11 @@
"groups": [
{
"group": "Getting Started",
- "pages": [
- "general/getting-started/introduction",
- "general/getting-started/quick-start-guide",
- "general/getting-started/downloads",
- "general/getting-started/quick-start-guide/browser-extension-setup",
- "general/getting-started/quick-start-guide/desktop-app-setup",
- "general/api-client/quick-start",
- "general/api-client/difference-between-desktop-app-and-browser-extension"
- ]
- },
- {
- "group": "API Testing",
"pages": [
"general/api-client/overview",
{
"group": "Sending Requests",
"pages": [
- "general/api-client/send-api-request/overview",
{
"group": "Create Requests",
"pages": [
@@ -68,19 +55,19 @@
"pages": [
"general/api-client/design-apis",
"general/api-client/api-collections",
- "general/api-client/examples",
- {
- "group": "Import & Export APIs",
- "pages": [
- "general/api-client/import-export",
- "general/api-client/import-export/import-from-curl",
- "general/api-client/import-export/import-from-wsdl",
- "general/api-client/import-export/import-from-postman",
- "general/api-client/import-export/import-openapi-spec",
- "general/api-client/import-export/import-export-api-collections",
- "general/api-client/import-export/import-export-api-environment"
- ]
- }
+ "general/api-client/examples"
+ ]
+ },
+ {
+ "group": "Import & Export",
+ "pages": [
+ "general/api-client/import-export",
+ "general/api-client/import-export/import-from-curl",
+ "general/api-client/import-export/import-from-postman",
+ "general/api-client/import-export/import-from-wsdl",
+ "general/api-client/import-export/import-openapi-spec",
+ "general/api-client/import-export/import-export-api-collections",
+ "general/api-client/import-export/import-export-api-environment"
]
},
{
@@ -97,45 +84,45 @@
]
},
{
- "group": "Scripts & Tests",
+ "group": "API Testing",
"pages": [
"general/api-client/scripts",
- "general/api-client/ai-test-generator",
- "general/api-client/import-packages-into-your-scripts",
"general/api-client/tests",
- {
- "group": "API Reference (rq)",
- "pages": [
- "general/api-client/rq-api-reference/rq-request",
- "general/api-client/rq-api-reference/rq-response",
- "general/api-client/rq-api-reference/rq-environment",
- "general/api-client/rq-api-reference/rq-collection-variables",
- "general/api-client/rq-api-reference/rq-globals",
- "general/api-client/rq-api-reference/rq-test",
- "general/api-client/rq-api-reference/rq-expect",
- "general/api-client/rq-api-reference/rq-iteration-data",
- "general/api-client/rq-api-reference/rq-info"
- ]
- },
- {
- "group": "Collection Runner",
- "pages": [
- "general/api-client/collection-runner",
- "general/api-client/collection-runner-data-file"
- ]
- }
+ "general/api-client/ai-test-generator",
+ "general/api-client/import-packages-into-your-scripts"
+ ]
+ },
+ {
+ "group": "Automation",
+ "pages": [
+ "general/api-client/collection-runner",
+ "general/api-client/collection-runner-data-file"
+ ]
+ },
+ {
+ "group": "API Reference",
+ "pages": [
+ "general/api-client/rq-api-reference/rq-request",
+ "general/api-client/rq-api-reference/rq-response",
+ "general/api-client/rq-api-reference/rq-environment",
+ "general/api-client/rq-api-reference/rq-collection-variables",
+ "general/api-client/rq-api-reference/rq-globals",
+ "general/api-client/rq-api-reference/rq-test",
+ "general/api-client/rq-api-reference/rq-expect",
+ "general/api-client/rq-api-reference/rq-iteration-data",
+ "general/api-client/rq-api-reference/rq-info"
]
}
]
},
{
- "group": "Collaboration & Workspaces",
+ "group": "Collaboration & Projects",
"pages": [
"general/team/workspaces",
"general/team/local-workspace",
"general/team/multiple-workspaces",
{
- "group": "Shared Workspace",
+ "group": "Shared projects",
"pages": [
"general/team/how-to-get-started-with-shared-workspace",
"general/team/how-to-get-started-with-shared-workspace/managing-workspace",
@@ -166,6 +153,18 @@
"tab": "HTTP Interception",
"icon": "globe",
"groups": [
+ {
+ "group": "Getting Started",
+ "pages": [
+ "general/getting-started/introduction",
+ "general/getting-started/quick-start-guide",
+ "general/getting-started/downloads",
+ "general/getting-started/quick-start-guide/browser-extension-setup",
+ "general/getting-started/quick-start-guide/desktop-app-setup",
+ "general/api-client/quick-start",
+ "general/api-client/difference-between-desktop-app-and-browser-extension"
+ ]
+ },
{
"group": "Debugging & Interception",
"pages": [
@@ -544,7 +543,7 @@
"redirects": [
{
"source": "/general/api-client/make-an-api-request",
- "destination": "/general/api-client/send-api-request"
+ "destination": "/general/api-client/overview"
},
{
"source": "/general/api-client/migrate-from-postman",
@@ -994,9 +993,13 @@
"source": "/general/api-client/authorization",
"destination": "/general/api-client/send-api-request/authorization"
},
+ {
+ "source": "/general/api-client/send-api-request/overview",
+ "destination": "/general/api-client/overview"
+ },
{
"source": "/general/api-client/send-api-request",
- "destination": "/general/api-client/send-api-request/overview"
+ "destination": "/general/api-client/overview"
},
{
"source": "/general/api-client/create-requests",
diff --git a/general/api-client/design-apis.mdx b/general/api-client/design-apis.mdx
index c5da295..2ddc907 100644
--- a/general/api-client/design-apis.mdx
+++ b/general/api-client/design-apis.mdx
@@ -17,7 +17,7 @@ The **API Builder** in Requestly helps you design APIs, manage them using collec
* To start creating APIs, click the `+ New` button at the top left of the API Builder. This provides three options:
- * **API Request**: [Create a new API request](/general/api-client/send-api-request/overview).
+ * **API Request**: [Create a new API request](/general/api-client/overview).
* **API Collection**: Organise multiple requests under [a collection](/general/api-client/api-collections).
diff --git a/general/api-client/difference-between-desktop-app-and-browser-extension.mdx b/general/api-client/difference-between-desktop-app-and-browser-extension.mdx
index 491b5da..32beca3 100644
--- a/general/api-client/difference-between-desktop-app-and-browser-extension.mdx
+++ b/general/api-client/difference-between-desktop-app-and-browser-extension.mdx
@@ -1,12 +1,12 @@
---
-title: Desktop App vs Browser Extension
-label: Differences Between Desktop App and Browser Extension
+title: Desktop App vs Web App
+label: Desktop App vs Web App
slug: difference-between-desktop-app-and-browser-extension
description: >-
- Compare Requestly Desktop App and Browser Extension features to choose the right platform for your API testing needs.
-seoTitle: Requestly - Desktop App vs Browser Extension Comparison
+ Compare Requestly Desktop App and web app experiences to choose the right setup for your API testing needs.
+seoTitle: Requestly - Desktop App vs Web App Comparison
seoDescription: >-
- Detailed comparison of Requestly Desktop App and Browser Extension for API testing. Learn which platform fits your workflow best.
+ Compare Requestly Desktop App and web app for API testing. Learn which setup fits your workflow best.
visibility: PUBLIC
---
@@ -14,10 +14,10 @@ visibility: PUBLIC
## Choose Your Platform
-Requestly is available on **two platforms**, each with unique strengths:
+Requestly is available in **two ways**, each with different strengths:
-
+
**Best for:** Quick API testing, web development, lightweight workflows
@@ -28,7 +28,7 @@ Requestly is available on **two platforms**, each with unique strengths:
- **Can't decide?** Both platforms sync your collections and environments
+ **Can't decide?** Both experiences sync your collections and environments
through Team Workspaces, so you can use whichever suits your current task.
@@ -36,22 +36,22 @@ Requestly is available on **two platforms**, each with unique strengths:
## Feature Comparison
-Use this table to compare capabilities and choose the right platform for your needs.
+Use this table to compare capabilities and choose the right setup for your needs.
### Platform Availability
-| Feature | Browser Extension | Desktop App |
+| Feature | Web app | Desktop App |
| ---------------------- | ------------------------------------------------- | --------------------- |
| **Supported Browsers** | Chrome, Firefox, Edge, Brave, Arc, Vivaldi, Opera | N/A |
| **Supported OS** | Any OS with supported browser | Windows, macOS, Linux |
-| **Installation** | Chrome Web Store / Firefox. | Download installer |
-| **Launch Speed** | Instant (already in browser) | Fast (standalone app) |
+| **Installation** | Sign in from your browser | Download installer |
+| **Launch Speed** | Fast (in browser) | Fast (standalone app) |
---
### API Testing Capabilities
-| Feature | Browser Extension | Desktop App |
+| Feature | Web app | Desktop App |
| ----------------------------- | ---------------------------------------------------- | ---------------- |
| **REST API Support** | ✅ Full support | ✅ Full support |
| **GraphQL Support** | ✅ Full support | ✅ Full support |
@@ -68,8 +68,8 @@ Use this table to compare capabilities and choose the right platform for your ne
### Organization & Workflow
-| Feature | Browser Extension | Desktop App |
-| -------------------------------- | ----------------- | ---------------- |
+| Feature | Web app | Desktop App |
+| -------------------------------- | ------- | ---------------- |
| **API Collections** | ✅ Full support | ✅ Full support |
| **Sub-collections / Folders** | ✅ Supported | ✅ Supported |
| **Environment Variables** | ✅ Supported | ✅ Supported |
@@ -86,8 +86,8 @@ Use this table to compare capabilities and choose the right platform for your ne
### Authentication & Security
-| Feature | Browser Extension | Desktop App |
-| ---------------------------- | ------------------ | ------------------- |
+| Feature | Web app | Desktop App |
+| ---------------------------- | -------- | ------------------- |
| **API Key Auth** | ✅ Supported | ✅ Supported |
| **Bearer Token** | ✅ Supported | ✅ Supported |
| **Basic Auth** | ✅ Supported | ✅ Supported |
@@ -96,8 +96,8 @@ Use this table to compare capabilities and choose the right platform for your ne
### Import & Export
-| Feature | Browser Extension | Desktop App |
-| ----------------------------- | ----------------- | ------------ |
+| Feature | Web app | Desktop App |
+| ----------------------------- | ------- | ------------ |
| **Import from cURL** | ✅ Supported | ✅ Supported |
| **Import from Postman** | ✅ Supported | ✅ Supported |
| **Import OpenAPI/Swagger** | ✅ Supported | ✅ Supported |
@@ -108,8 +108,8 @@ Use this table to compare capabilities and choose the right platform for your ne
### Collaboration & Workspaces
-| Feature | Browser Extension | Desktop App |
-| ---------------------- | ---------------------------------- | ---------------------------------- |
+| Feature | Web app | Desktop App |
+| ---------------------- | ------------------------ | ---------------------------------- |
| **Local Workspace** | ❌ Not available | ✅ Supported |
| **Team Workspaces** | ✅ Supported | ✅ Supported |
@@ -118,17 +118,17 @@ Use this table to compare capabilities and choose the right platform for your ne
## Decision Guide
-
- ### Choose **Browser Extension** if you:
+
+ ### Choose the **web app** if you:
- ✅ Primarily test web APIs during frontend development
- - ✅ Want zero-install, instant access in your browser
+ - ✅ Want fast access in your browser
- ✅ Don't need file upload testing
- ✅ Work mostly with JSON/text payloads
- - ✅ Prefer a lightweight tool integrated with your browser
+ - ✅ Prefer a lightweight workflow in the browser
-
- Install from Chrome Web Store and start testing APIs instantly
+
+ Open the docs homepage and follow Getting Started
@@ -154,12 +154,12 @@ Use this table to compare capabilities and choose the right platform for your ne
## Can I Use Both?
-**Absolutely!** Many users use both platforms:
+**Absolutely!** Many people use both:
-- **Browser Extension** for quick web API testing during development
+- **Web app** for quick API testing during development
- **Desktop App** for advanced testing, mobile debugging, and session recording
-Your collections and environments sync across both platforms when you use Team Workspaces, giving you the flexibility to switch based on your current task.
+Your collections and environments sync across both when you use Team Workspaces, giving you flexibility to switch based on your current task.
---
@@ -167,27 +167,27 @@ Your collections and environments sync across both platforms when you use Team W
- Learn more about the browser extension
+ Choose a path and set up Requestly
- Explore desktop app capabilities
+ Install and configure the desktop app
- Get started with API Client in 5 minutes
+ Get started with API Client in a few minutes
diff --git a/general/api-client/import-export/import-from-wsdl.mdx b/general/api-client/import-export/import-from-wsdl.mdx
index 8bb9100..edcb1fc 100644
--- a/general/api-client/import-export/import-from-wsdl.mdx
+++ b/general/api-client/import-export/import-from-wsdl.mdx
@@ -6,7 +6,7 @@ A WSDL (Web Services Description Language) file defines the structure of a SOAP
- Open App and click the `Import` button.
+ In Requestly, open **API Client** and click the `Import` button.
diff --git a/general/api-client/overview.mdx b/general/api-client/overview.mdx
index a50d285..e9a8b1a 100644
--- a/general/api-client/overview.mdx
+++ b/general/api-client/overview.mdx
@@ -1,18 +1,19 @@
---
-title: API Client Overview
+title: Overview
label: Overview
slug: overview
description: >-
- Learn when to use Requestly API Client, how to get started fast, and which workflows to explore next.
+ Learn when to use Requestly as your API client, how to send requests, get started fast, and which workflows to explore next.
seoDescription: >-
- Learn how to use Requestly API Client for API testing, environments, collections, scripts, and assertions.
+ Learn how to use Requestly for API testing, sending HTTP requests, environments, collections, scripts, and assertions.
+seoTitle: Requestly API client overview
visibility: PUBLIC
---
-Requestly API Client is the fastest place to start when your goal is to send requests, inspect responses, organize APIs, and automate API testing workflows.
+In Requestly, you can send requests, inspect responses, organize APIs, and automate API testing workflows.
-## When To Use API Client
+## When To Use Requestly
-Use API Client when you want to:
+Use Requestly when you want to:
- send REST or GraphQL requests manually
- manage collections, folders, and reusable environments
@@ -24,7 +25,7 @@ If your goal is to inspect live traffic from an app or browser, start with [HTTP
## What You Can Do Here
-
+
Test REST and GraphQL APIs with full request and response controls.
@@ -37,59 +38,120 @@ If your goal is to inspect live traffic from an app or browser, start with [HTTP
Add scripts, assertions, and automation logic in JavaScript.
-## What You Need Before You Start
+
+## Sending requests
+
+Whether you are building and testing your own API or integrating with a third-party API, you can use Requestly to send requests and connect to the APIs you are working with. Your requests can retrieve, create, update, or delete data, and they can include parameters and authorization details.
+
+For example, if you are building a client application such as a mobile or web app for a store, you might send one request to retrieve a list of available products, another request to create a new order with selected product details, and another request to log a customer into their account.
+
+When you send a request, Requestly displays the API server’s response in a clear format so you can inspect, visualize, and troubleshoot it easily.
+
+
+
+### Get started with sending requests
+
+If you have not sent a request before, review [Sending your first request](/general/api-client/quick-start) before continuing.
+
+Explore the topics below to learn how to send API requests in Requestly:
+
+- To understand the basics of building requests, including selecting HTTP methods, entering URLs, and interpreting response status codes, see [Configure request](/general/api-client/send-api-request/create-requests/configure-request).
+
+- To learn how to add query parameters, path variables, and request body data in formats such as JSON, form data, and file uploads, see [Parameters and body data](/general/api-client/send-api-request/create-requests/parameters-and-body).
+
+- If your API requires specific headers or authentication tokens, learn how to configure them in [Request headers](/general/api-client/send-api-request/create-requests/request-headers).
+
+- Export requests as code snippets in multiple languages such as JavaScript, Python, and cURL. Learn more in [Generate client code](/general/api-client/send-api-request/create-requests/generate-client-code).
+
+- If your API requires identity verification or access control, review the [authorization guide](/general/api-client/send-api-request/authorization).
+
+- Use collections to group related requests for better organization and collaboration. Learn more in [API collections](/general/api-client/api-collections).
+
+- Variables allow you to reuse data across requests and switch values based on environments such as development, staging, or production. See [Variables and environments](/general/api-client/environments-and-variables).
+
+- Add JavaScript code to run before sending requests or after receiving responses to automate workflows and extract data. Learn more in [Scripts](/general/api-client/scripts).
+
+- Write automated tests to validate API responses and ensure reliability. See [Tests](/general/api-client/tests).
+
+In addition to standard HTTP requests, Requestly also supports other formats and protocols such as [GraphQL](/general/api-client/send-api-request/graphql-request). You can also [import from cURL](/general/api-client/import-export/import-from-curl), [import from Postman](/general/api-client/import-export/import-from-postman), or [import OpenAPI specifications](/general/api-client/import-export/import-openapi-spec).
+
+
+
+ Start by learning how to configure HTTP methods and URLs
+
+
+ Learn to add query params, path variables, and request body
+
+
+ Follow our complete quick start guide for beginners
+
+
+
+## What you need before you start
- a browser or desktop access to Requestly
- an endpoint to test, such as `https://app.requestly.io/echo`
- optional credentials or tokens if your API requires authorization
-## First Success Path
+## First success path
-
- Launch API Client from Requestly and create a new request.
+
+ Open Requestly and create a new request.
-
- Start with the [API Client quick start](/general/api-client/quick-start) to send a request and inspect the response.
+
+ Start with the [quick start](/general/api-client/quick-start) to send a request and inspect the response.
-
+
Move your requests into [collections](/general/api-client/api-collections) and set up [environments](/general/api-client/environments-and-variables) so you can reuse them across projects.
-
+
Add [authorization](/general/api-client/send-api-request/authorization), [scripts](/general/api-client/scripts), and [tests](/general/api-client/tests) to make the workflow repeatable.
-## Explore By Workflow
+## Explore by workflow
-
+
Follow the guided beginner walkthrough from first request to environments.
-
+
Learn request configuration, headers, body handling, authorization, and history.
-
+
Switch between dev, staging, and production without rewriting requests.
-
+
Add scripts, tests, and collection runs for repeatable API validation.
-
+
Bring work in from cURL, Postman, or OpenAPI and share collections back out.
-
+
Execute multi-request workflows against environments and test data.
-## Related Capabilities
+## Related capabilities
-
+
Use HTTP Rules when you need to rewrite live requests and responses during testing.
-
+
Use HTTP Interceptor when you need to inspect what your app is sending over the network.
diff --git a/general/api-client/quick-start.mdx b/general/api-client/quick-start.mdx
index 6b4b09f..fd097a9 100644
--- a/general/api-client/quick-start.mdx
+++ b/general/api-client/quick-start.mdx
@@ -14,12 +14,13 @@ Welcome to Requestly! This guide will help you get started in just a few minutes
## Prerequisites
-You'll need either:
-- **Browser Extension** ([Chrome](https://rqst.ly/chrome), Firefox, Edge, Brave) - Best for web API testing
-- **Desktop App** ([Download](https://requestly.com/downloads/)) - Best for mobile apps, local APIs, and advanced use cases
+You'll need access to Requestly in one of these ways:
+
+- **Web app** — open Requestly in a supported desktop browser for everyday API testing.
+- **Desktop app** — [download](https://requestly.com/downloads/) for workflows that need file uploads, multipart forms, or deeper system integration.
- Not sure which to use? Check out our [comparison guide](/general/api-client/difference-between-desktop-app-and-browser-extension) to help you decide.
+ Not sure which to use? See [Desktop app vs web app](/general/api-client/difference-between-desktop-app-and-browser-extension).
***
diff --git a/general/api-client/send-api-request/overview.mdx b/general/api-client/send-api-request/overview.mdx
deleted file mode 100644
index f304737..0000000
--- a/general/api-client/send-api-request/overview.mdx
+++ /dev/null
@@ -1,75 +0,0 @@
----
-title: "Overview"
-label: "Overview"
-slug: "overview"
-description: "Learn how to create and send API requests in Requestly. Test APIs, configure requests, and view responses without writing code."
-seoTitle: "Create API Requests in Requestly"
-seoDescription: "Complete guide to creating API requests in Requestly. Send HTTP requests, configure parameters, headers, and body data for effective API testing."
-visibility: "PUBLIC"
----
-
-Whether you are building and testing your own API or integrating with a third-party API, you can use Requestly to send requests and connect to the APIs you are working with. Your requests can retrieve, create, update, or delete data, and they can include parameters and authorization details.
-
-For example, if you are building a client application such as a mobile or web app for a store, you might send one request to retrieve a list of available products, another request to create a new order with selected product details, and another request to log a customer into their account.
-
-When you send a request, Requestly displays the API server’s response in a clear format so you can inspect, visualize, and troubleshoot it easily.
-
-
-
----
-
-## Get Started with Sending Requests
-
-If you have not sent a request before, review the [Sending Your First Request](/general/api-client/quick-start) guide before continuing.
-
-Explore the topics below to learn how to send API requests in Requestly:
-
-- To understand the basics of building requests, including selecting HTTP methods, entering URLs, and interpreting response status codes, see [Configure Request](/general/api-client/send-api-request/configure-request).
-
-- To learn how to add query parameters, path variables, and request body data in formats such as JSON, form data, and file uploads, see [Parameters and Body Data](/general/api-client/send-api-request/parameters-and-body).
-
-- If your API requires specific headers or authentication tokens, learn how to configure them in [Request Headers](/general/api-client/send-api-request/request-headers).
-
-- Export requests as code snippets in multiple languages such as JavaScript, Python, and cURL. Learn more in [Generate Client Code](/general/api-client/generate-client-code).
-
-- If your API requires identity verification or access control, review the [Authorization Guide](/general/api-client/authorization).
-
-- Use collections to group related requests for better organization and collaboration. Learn more in [API Collections](/general/api-client/api-collections).
-
-- Variables allow you to reuse data across requests and switch values based on environments such as development, staging, or production. See [Variables and Environments](/general/api-client/environments-and-variables).
-
-- Add JavaScript code to run before sending requests or after receiving responses to automate workflows and extract data. Learn more in [Scripts](/general/api-client/scripts).
-
-- Write automated tests to validate API responses and ensure reliability. See [Tests](/general/api-client/tests).
-
-- Export requests as code snippets in multiple languages such as JavaScript, Python, and cURL. Learn more in [Generate Client Code](/general/api-client/generate-client-code).
-
-In addition to standard HTTP requests, Requestly also supports other formats and protocols such as [GraphQL](/general/api-client/graphql-request). You can also [import from cURL](/general/api-client/import-export/import-from-curl), [migrate from Postman](/general/api-client/import-export/import-from-postman), or [import OpenAPI specifications](/general/api-client/import-export/import-openapi-spec).
-
----
-
-## What's Next?
-
-
-
- Start by learning how to configure HTTP methods and URLs
-
-
- Learn to add query params, path variables, and request body
-
-
- Follow our complete quick start guide for beginners
-
-
diff --git a/general/team/how-to-get-started-with-shared-workspace.mdx b/general/team/how-to-get-started-with-shared-workspace.mdx
index 6f7f1fe..59e6a4f 100644
--- a/general/team/how-to-get-started-with-shared-workspace.mdx
+++ b/general/team/how-to-get-started-with-shared-workspace.mdx
@@ -1,110 +1,110 @@
---
-title: Team Workspaces
-label: Team Workspaces
+title: Team projects
+label: Team projects
slug: how-to-get-started-with-shared-workspace
-description: Learn how to setup team workspace in Requestly
+description: Learn how to set up a team project in Requestly
visibility: PUBLIC
---
-Requestly’s **Team/Shared Workspaces** make collaboration easy by **syncing** all the **workpace data** between members can work together on **HTTP rules, mock APIs, the API client, and sessions**. Whether you're debugging, testing, or managing API workflows, a shared workspace ensures your team stays in sync and productive.
+Requestly’s **team and shared projects** make collaboration easy by **syncing** all **project data** so members can work together on **HTTP rules, mock APIs, the API client, and sessions**. Whether you're debugging, testing, or managing API workflows, a shared project keeps your team in sync and productive.
-### Setting Up a Shared Workspace
+### Setting up a shared project
-Let's create a shared workspace and invite some friends to collaborate in real-time. Follow these simple steps to get started.
+Let's create a shared project and invite teammates to collaborate in real time. Follow these simple steps to get started.
-### Create a Workspace
+### Create a project
-
- In the top-left corner of the sidebar, find the workspace dropdown (the default option is **Private Workspace**).
+
+ In the top-left corner of the sidebar, find the project dropdown (the default option is **Private project**).
-
- Click on the workspace dropdown and select the option **Join or Create Workspace**.
+
+ Click on the project dropdown and select the option **Join or Create Project**.
-
- Click on **Create New Workspace** from the options. Enter a name for your workspace in the provided field and click **Create Workspace**.
+
+ Click on **Create New Project** from the options. Enter a name for your project in the provided field and click **Create Project**.
- You can also check the checkbox at the bottom of this popup to invite your entire team while creating the workspace.
+ You can also check the checkbox at the bottom of this popup to invite your entire team while creating the project.
-## Managing Team Members
+## Managing team members
-To effectively manage access, admins can add team members, update their roles, or remove team members within a workspace. Below are the steps to perform these actions.
+To effectively manage access, admins can add team members, update their roles, or remove team members within a project. Below are the steps to perform these actions.
-### Adding New Members
+### Adding new members
-
- Navigate to the Requestly dashboard and switch to the workspace where you want to add members.
+
+ Navigate to the Requestly dashboard and switch to the project where you want to add members.
-
- Open the switch workspace panel and select **“Manage workspace”**
+
+ Open the switch project panel and select **“Manage project”**
- Here you can directly invite teammates or go to workspace settings to see the list of users before inviting.
+ Here you can directly invite teammates or go to project settings to see the list of users before inviting.
-
- In the workspace settings, click the **+ Invite People** button.
+
+ In the project settings, click the **+ Invite People** button.
-
+
Enter your teammates email addresses and assign them specific roles.
-
- Invited members will receive an email to join the workspace. Once they accept, they will appear in the members list.
+
+ Invited members will receive an email to join the project. Once they accept, they will appear in the members list.
-### Removing Members
+### Removing members
-
- Navigate to the Requestly dashboard and switch to the workspace where you want to add members.
+
+ Navigate to the Requestly dashboard and switch to the project where you want to remove members.
-
- Open the switch workspace panel and select **“Manage workspace”**
+
+ Open the switch project panel and select **“Manage project”**
- Locate the member you want to remove from the members’ list. Click the 3-dot menu next to their role and select **Remove user from Workspace**.
+ Locate the member you want to remove from the members’ list. Click the 3-dot menu next to their role and select **Remove user from project**.
-
+
A confirmation prompt will appear. Confirm the action to remove the member successfully.
-
+
If a member has been invited but not yet joined, you can revoke their invite from the same dropdown.
diff --git a/general/team/how-to-get-started-with-shared-workspace/managing-workspace.mdx b/general/team/how-to-get-started-with-shared-workspace/managing-workspace.mdx
index 17829c7..eeab5a5 100644
--- a/general/team/how-to-get-started-with-shared-workspace/managing-workspace.mdx
+++ b/general/team/how-to-get-started-with-shared-workspace/managing-workspace.mdx
@@ -1,44 +1,44 @@
---
-title: "Managing Workspace"
+title: "Managing your project"
slug: "managing-workspace"
path: "/team/how-to-get-started-with-shared-workspace/managing-workspace"
visibility: "PUBLIC"
format: "MDX"
-description: "Learn how to manage workspaces"
+description: "Learn how to manage projects in Requestly"
---
-### Renaming a workspace
+### Renaming a project
-Workspaces can be renamed by following these steps
+Projects can be renamed by following these steps
-
- In the Requestly dashboard, locate and click on your workspace name at the top.
+
+ In the Requestly dashboard, locate and click on your project name at the top.
-
- From the dropdown or navigation menu, select **Workspace Settings**.
+
+ From the dropdown or navigation menu, select **Project Settings**.
-
- In the **Workspace Settings** section, find the **Workspace Name** field and enter the new name
+
+ In the **Project Settings** section, find the **Project Name** field and enter the new name
-
+
- Click the **Save Changes** button to apply the new workspace name.
+ Click the **Save Changes** button to apply the new project name.
-### Delete a workspace
+### Delete a project
-Workspaces can be deleted using the `Delete Workspace` button in the workspace settings
+Projects can be deleted using the **Delete Project** button in the project settings
diff --git a/general/team/how-to-get-started-with-shared-workspace/user-roles.mdx b/general/team/how-to-get-started-with-shared-workspace/user-roles.mdx
index 34c9eba..86d4582 100644
--- a/general/team/how-to-get-started-with-shared-workspace/user-roles.mdx
+++ b/general/team/how-to-get-started-with-shared-workspace/user-roles.mdx
@@ -9,9 +9,9 @@ description: "Learn how to manage team collaboration securely in Requestly with
***
-Requestly enhances collaboration and security by allowing workspace admins to assign specific roles to users. This role-based access control (RBAC) ensures that only authorized members can access sensitive configurations, such as API keys and authentication tokens, and helps prevent unauthorised modifications.
+Requestly enhances collaboration and security by allowing project admins to assign specific roles to users. This role-based access control (RBAC) ensures that only authorized members can access sensitive configurations, such as API keys and authentication tokens, and helps prevent unauthorised modifications.
-In this doc, you'll learn how Requestly's RBAC works, the specific roles available, the permissions associated with each role, and how to change user roles within your workspace
+In this doc, you'll learn how Requestly's RBAC works, the specific roles available, the permissions associated with each role, and how to change user roles within your project
## How RBAC Works in Requestly
@@ -19,11 +19,11 @@ Requestly uses role-based access control (RBAC) to ensure that every team member
## User Roles and Their Permissions
-Each workspace has three roles, each with distinct permissions:
+Each project has three roles, each with distinct permissions:
#### **Admin**
-* Full control over **workspace settings, member management, and permissions**.
+* Full control over **project settings, member management, and permissions**.
* Can **create, edit, delete, and execute** Rules, APIs, and Sessions.
@@ -31,7 +31,7 @@ Each workspace has three roles, each with distinct permissions:
* Can **create, edit, delete, and execute** Rules, APIs, and Sessions.
-* **Cannot** manage team settings, members, or workspace-wide configurations.
+* **Cannot** manage team settings, members, or project-wide configurations.
#### **Viewer**
@@ -41,14 +41,14 @@ Each workspace has three roles, each with distinct permissions:
* **Read-only access**.
-* Can **view and execute** Rules, APIs, and Sessions but **cannot make any changes** or access sensitive workspace settings.
+* Can **view and execute** Rules, APIs, and Sessions but **cannot make any changes** or access sensitive project settings.
### Permissions Table
Below is a table that outlines key permissions for each role:
-
+
| **Permission** | **Admin** | **Editor** | **Viewer** |
| -------------------- | --------- | -------------------- | ---------- |
| Add a new user | ✅ | ✅ (Add as an editor) | ❌ |
@@ -94,17 +94,17 @@ Below is a table that outlines key permissions for each role:
## Changing Roles
-At times, you may need to update a team member’s role. Follow these steps to change roles within your workspace:
+At times, you may need to update a team member’s role. Follow these steps to change roles within your project:
-
- Navigate to the Requestly dashboard and switch to the workspace where you want to add members.
+
+ Navigate to the Requestly dashboard and switch to the project where you want to add members.
-
- Open the switch workspace panel and select **“Manage workspace”**
+
+ Open the switch project panel and select **“Manage project”**
diff --git a/general/team/local-workspace.mdx b/general/team/local-workspace.mdx
index 3eb8a39..07e5993 100644
--- a/general/team/local-workspace.mdx
+++ b/general/team/local-workspace.mdx
@@ -1,24 +1,24 @@
---
-title: "Local workspace"
-label: "Local workspace"
+title: "Local project"
+label: "Local project"
slug: "local-workspace"
-description: "Learn how to set up the Local Workspaces in requestly"
+description: "Learn how to set up local projects in Requestly"
visibility: "PUBLIC"
---
-Local Workspace in Requestly, like [Team Workspace](https://docs.requestly.com/general/team/how-to-get-started-with-shared-workspace), is a type of workspace. The key difference is that it stores all your data on your local system, ensuring full privacy. Your collections, requests, and environment data stay on your device and can’t be accessed by anyone else
+**Local project** in Requestly, like [team projects](https://docs.requestly.com/general/team/how-to-get-started-with-shared-workspace), is a way to isolate your work. The key difference is that it stores all your data on your local system, ensuring full privacy. Your collections, requests, and environment data stay on your device and can’t be accessed by anyone else
- Local Workspace is currently in **early beta** and available only for the API Client **on the desktop app**. Since it’s still in development, some features may not work as expected.
+ Local projects are currently in **early beta** and available only for the API Client **on the desktop app**. Since it’s still in development, some features may not work as expected.
Want to try it out? **Email us at** [**contact@requestly.io**](mailto:contact@requestly.io) **to get early access!**
-## **How to Create a Local Workspace**
+## **How to create a local project**
-
- Click on the **current workspace name** at the top-left corner of the Dashboard to open the workspace dropdown.
+
+ Click on the **current project name** at the top-left corner of the Dashboard to open the project dropdown.
-
- In the dropdown, click on **“Join or Create Workspace”** to access the workspace creation options, then select **“Create Workspace”** to start the setup
+
+ In the dropdown, click on **“Join or Create Project”** to access the project creation options, then select **“Create Project”** to start the setup
-
- Select **“Local Workspace”** as the workspace type. Enter a **workspace name** and choose a **folder** where all configurations and API data will be stored.
+
+ Select **“Local project”** as the project type. Enter a **project name** and choose a **folder** where all configurations and API data will be stored.
- Once all details are entered, click **“Create”** to finalize the setup. Your Local Workspace is now ready to use!
+ Once all details are entered, click **“Create”** to finalize the setup. Your local project is now ready to use!
-## **How to Delete a Local Workspace**
+## **How to delete a local project**
-
- Click the **current workspace name** in the top left to open the workspace dropdown.
+
+ Click the **current project name** in the top left to open the project dropdown.
- 
+ 
-
- Select the Local Workspace you want to remove and open its **Settings**.
+
+ Select the local project you want to remove and open its **Settings**.
- You can also delete any related files or folders stored on your device if you want to clean up everything linked to that workspace
+ You can also delete any related files or folders stored on your device if you want to clean up everything linked to that project
- 
+ 
-
- Click **Delete Workspace** and confirm the action by entering the workspace name. Then click the **Delete Workspace** button to complete the removal.
+
+ Click **Delete Project** and confirm the action by entering the project name. Then click the **Delete Project** button to complete the removal.
- 
+ 
-## **Known Limitations 🚧**
+## **Known limitations 🚧**
-Since **Local Workspaces** are currently in **beta**, some features are not yet available:
+Since **local projects** are currently in **beta**, some features are not yet available:
-- **Only API Client is Supported** – Local Workspaces are available only for the API Client; other Requestly features are not supported.
+- **Only API Client is supported** — Local projects are available only for the API Client; other Requestly features are not supported.
-We are actively working on improving Local Workspaces and will address these limitations in future updates. If you have any feedback or need support, please reach out to [**contact@requestly.io**](mailto:contact@requestly.io).
\ No newline at end of file
+We are actively working on improving local projects and will address these limitations in future updates. If you have any feedback or need support, please reach out to [**contact@requestly.io**](mailto:contact@requestly.io).
diff --git a/general/team/multiple-workspaces.mdx b/general/team/multiple-workspaces.mdx
index d8017b8..84f5804 100644
--- a/general/team/multiple-workspaces.mdx
+++ b/general/team/multiple-workspaces.mdx
@@ -1,79 +1,79 @@
---
-title: Working with Multiple Workspaces
-label: Working with Multiple Workspaces
+title: Working with multiple projects
+label: Working with multiple projects
slug: multiple-workspaces
visibility: PUBLIC
---
-Requestly allows you to **work with multiple local workspaces at once**. This makes it easier to collaborate across services (Auth, Payments, Orders, etc.) without merging everything into a single workspace.
+Requestly allows you to **work with multiple local projects at once**. This makes it easier to collaborate across services (Auth, Payments, Orders, etc.) without merging everything into a single project.
- **Note:** Multi-workspace view works only with **local workspaces** at this time.
+ **Note:** Multi-project view works only with **local projects** at this time.
-## How to Use Multiple Workspaces
+## How to use multiple projects
-Follow these steps to open multiple local workspaces in one view:
+Follow these steps to open multiple local projects in one view:
-
+
Open Requestly and navigate to the **API tab** from the sidebar.
-
- In the top-right corner, click on your current workspace name to open the **Workspace Selector** dropdown.
+
+ In the top-right corner, click on your current project name to open the **project selector** dropdown.
-
- Check the boxes next to the local workspaces you want to load together.
+
+ Check the boxes next to the local projects you want to load together.
-
- Your chosen workspaces will appear grouped in the selector.
+
+ Your chosen projects will appear grouped in the selector.
-That’s it! You can now test APIs across multiple workspaces in one seamless view.
+That’s it! You can now test APIs across multiple projects in one seamless view.
-## Using Environments in Multi-Workspace View
+## Using environments in multi-project view
-When working with multiple workspaces, each workspace keeps its own **separate environment**. This ensures that variables from one workspace do not interfere with another.
+When working with multiple projects, each project keeps its own **separate environment**. This ensures that variables from one project do not interfere with another.
-### **Switching Environments**
+### **Switching environments**
-You can switch environments using the **dropdown below the workspace name** in the sidebar. This lets you quickly toggle between different setups for the same workspace.
+You can switch environments using the **dropdown below the project name** in the sidebar. This lets you quickly toggle between different setups for the same project.
-### **Editing Environment Variables**
+### **Editing environment variables**
-To edit variables for a workspace:
+To edit variables for a project:
1. Go to the **Environments tab**.
-2. Select the workspace whose environment you want to edit.
+2. Select the project whose environment you want to edit.
-3. You’ll see all variables for that workspace listed, and you can add, update, or remove them as needed.
+3. You’ll see all variables for that project listed, and you can add, update, or remove them as needed.
-## Moving Requests Across Workspaces
+## Moving requests across projects
-You can easily move or share requests between different workspaces in multi-workspace view. There are two ways to do this:
+You can easily move or share requests between different projects in multi-project view. There are two ways to do this:
-### **Method 1: Drag and Drop**
+### **Method 1: Drag and drop**
-### **Method 2: Move via Menu**
+### **Method 2: Move via menu**
-
+
Click on the **three dots** menu next to the request you want to move.
@@ -85,21 +85,21 @@ You can easily move or share requests between different workspaces in multi-work
-
- Select the target workspace and the collection within it where you want to move the request.
+
+ Select the target project and the collection within it where you want to move the request.
-
- Click **Move** to complete the action. The request will now appear in the selected workspace and collection.
+
+ Click **Move** to complete the action. The request will now appear in the selected project and collection.
-## Sharing Data Across Workspaces
+## Sharing data across projects
-To share values (like tokens) across different workspaces, you can use [**Runtime Variables**](/general/api-client/environments-and-variables/runtime-variables). These act as **super-global variables** that are accessible across all workspaces. They can be created as temporary values for quick testing or persisted for longer use. You can view, edit, or clear them anytime from the **Runtime Variables tab** on the left.
+To share values (like tokens) across different projects, you can use [**Runtime Variables**](/general/api-client/environments-and-variables/runtime-variables). These act as **super-global variables** that are accessible across all projects. They can be created as temporary values for quick testing or persisted for longer use. You can view, edit, or clear them anytime from the **Runtime Variables tab** on the left.
diff --git a/general/team/workspaces.mdx b/general/team/workspaces.mdx
index 721b714..93c9dcd 100644
--- a/general/team/workspaces.mdx
+++ b/general/team/workspaces.mdx
@@ -2,21 +2,21 @@
title: Introduction
label: Overview
slug: workspaces
-description: Learn about workspaces in requestly
+description: Learn about projects in Requestly
visibility: PUBLIC
---
-A **workspace** in Requestly is like a project where you can store all related rules, mock APIs, API requests, and collections in one place. It helps keep everything organized and easily accessible for better management and collaboration.
+A **project** in Requestly is where you store all related rules, mock APIs, API requests, and collections in one place. It helps keep everything organized and easily accessible for better management and collaboration.
-### Understanding Workspaces
+### Understanding projects
-A Requestly workspace is like a project containing HTTP rules, API requests, Collections, and mocks. By default, you start in a private workspace, where no other user can view or access your rules.
+A Requestly project contains HTTP rules, API requests, collections, and mocks. By default, you start in a **private project**, where no other user can view or access your rules.
-This setup is ideal for personal projects or testing. However, you can create additional team workspaces and invite other users to collaborate in real-time, sharing rules, APIs and mocks effortlessly, or create a local workspace to keep all your data locally.
+This setup is ideal for personal work or testing. However, you can create additional **team projects** and invite other users to collaborate in real time, sharing rules, APIs, and mocks effortlessly, or create a **local project** to keep all your data on your machine.
-### Types of Workspaces :
+### Types of projects
-Requestly offers two main types of workspaces:
+Requestly offers two main types of projects:
-**Team Workspace** - A Team Workspace is a cloud-based workspace where all your data is securely stored and synced across teams and devices. This is ideal for users who work with teams and need to keep all data in sync with their team members.
+**Team project** — A team project is cloud-based: all your data is securely stored and synced across teams and devices. This is ideal when you work with a team and need everyone to stay in sync.
-**Local workspace ( beta )** - A Local workspace stores all your data in your local machine, ensuring complete control and privacy. It is designed for individual use, rather than team collaboration. This option is suitable for users who prefer local storage over the cloud.
+**Local project (beta)** — A local project stores all your data on your computer, giving you complete control and privacy. It is designed for individual use rather than team collaboration. Choose this option if you prefer local storage over the cloud.
From b8231aa22483f3532959be1cb6ae3fd80c096563 Mon Sep 17 00:00:00 2001
From: kanishkrawatt
Date: Tue, 7 Apr 2026 15:12:42 +0530
Subject: [PATCH 5/8] update navbar based on tab change
---
navbar-download-by-tab.js | 95 +++++++++++++++++++++++++++++++++++++++
1 file changed, 95 insertions(+)
create mode 100644 navbar-download-by-tab.js
diff --git a/navbar-download-by-tab.js b/navbar-download-by-tab.js
new file mode 100644
index 0000000..a49519c
--- /dev/null
+++ b/navbar-download-by-tab.js
@@ -0,0 +1,95 @@
+/**
+ * Updates the navbar "Download" CTA href when the user selects the
+ * "HTTP Interception" docs tab (Mintlify top-level navigation).
+ *
+ * Edit the URLs below if marketing wants different destinations.
+ */
+(function () {
+ var DEFAULT_DOWNLOAD_HREF = 'https://requestly.com/downloads';
+ /** Shown while the HTTP Interception tab is active (browser extension entry for traffic debugging). */
+ var HTTP_INTERCEPTION_DOWNLOAD_HREF = 'https://rqst.ly/chrome-store';
+
+ function findDownloadCtaAnchor() {
+ var byId = document.getElementById('topbar-cta-button');
+ if (byId) {
+ if (byId.tagName === 'A') return byId;
+ var inner = byId.querySelector && byId.querySelector('a[href]');
+ if (inner) return inner;
+ }
+ var header = document.querySelector('header') || document.getElementById('navbar');
+ if (header) {
+ var links = header.querySelectorAll('a[href*="requestly.com/downloads"], a[href*="rqst.ly"]');
+ for (var i = 0; i < links.length; i++) {
+ var a = links[i];
+ var label = (a.textContent || '').toLowerCase();
+ if (label.indexOf('download') !== -1) return a;
+ }
+ }
+ return null;
+ }
+
+ function isHttpInterceptionTabActive() {
+ var tabs = document.querySelectorAll('.nav-tabs a');
+ if (tabs[1].classList.contains("[text-shadow:-0.2px_0_0_currentColor,0.2px_0_0_currentColor]")) return true;
+ console.log('tabs[1].classList: ', tabs[1].classList);
+ console.log('isHttpInterceptionTabActive: false');
+ return false;
+ }
+
+ var debounce = false;
+ function syncDownloadCta() {
+ var anchor = findDownloadCtaAnchor();
+ if (!anchor || !anchor.getAttribute) return;
+
+ if (!anchor.getAttribute('data-cta-baseline-href')) {
+ var initial = anchor.getAttribute('href') || DEFAULT_DOWNLOAD_HREF;
+ anchor.setAttribute('data-cta-baseline-href', initial);
+ }
+
+ var baseline = anchor.getAttribute('data-cta-baseline-href') || DEFAULT_DOWNLOAD_HREF;
+ var next = isHttpInterceptionTabActive() ? HTTP_INTERCEPTION_DOWNLOAD_HREF : baseline;
+ if (anchor.getAttribute('href') !== next) {
+ anchor.setAttribute('href', next);
+ }
+ }
+
+ function scheduleSync() {
+ if (debounce) return;
+ debounce = true;
+ requestAnimationFrame(function () {
+ debounce = false;
+ syncDownloadCta();
+ });
+ }
+
+ if (document.readyState === 'loading') {
+ document.addEventListener('DOMContentLoaded', scheduleSync);
+ } else {
+ scheduleSync();
+ }
+ window.addEventListener('load', scheduleSync);
+
+ var mo = new MutationObserver(scheduleSync);
+ mo.observe(document.documentElement, {
+ childList: true,
+ subtree: true,
+ attributes: true,
+ attributeFilter: ['data-active', 'aria-selected', 'href'],
+ });
+
+ document.addEventListener('click', function (ev) {
+ var t = ev.target;
+ if (!t || !t.closest) return;
+ if (
+ t.closest('header') ||
+ t.closest('#navbar') ||
+ t.closest('.nav-tabs-item') ||
+ t.closest('.mobile-nav-tabs-item') ||
+ t.closest('[class*="nav-tabs"]')
+ ) {
+ setTimeout(scheduleSync, 0);
+ setTimeout(scheduleSync, 100);
+ }
+ }, true);
+ console.log('navbar-download-by-tab.js loaded');
+})();
From 50936b2c9953b276fc8c1e919b7d27ef6300602f Mon Sep 17 00:00:00 2001
From: kanishkrawatt
Date: Mon, 13 Apr 2026 11:55:21 +0530
Subject: [PATCH 6/8] Updated Requestly Interceptor Docs
---
docs.json | 15 ++-
...ween-desktop-app-and-browser-extension.mdx | 4 +-
.../api-client/environments-and-variables.mdx | 4 +-
.../environment-variables.mdx | 2 +-
.../runtime-variables.mdx | 2 +-
general/api-client/import-export.mdx | 6 +-
.../import-export-api-collections.mdx | 6 +-
.../import-export-api-environment.mdx | 6 +-
.../import-export/import-from-curl.mdx | 7 +-
.../import-export/import-from-postman.mdx | 2 +-
.../import-export/import-from-wsdl.mdx | 2 +-
.../import-export/import-openapi-spec.mdx | 4 +-
general/api-client/overview.mdx | 62 +++++--------
general/api-client/scripts.mdx | 2 +-
.../send-api-request/authorization.mdx | 6 +-
.../create-requests/configure-request.mdx | 9 +-
.../create-requests/generate-client-code.mdx | 6 +-
.../create-requests/overview.mdx | 11 +--
.../send-api-request/graphql-request.mdx | 5 +-
.../replay-request-from-history.mdx | 10 +-
.../api-client/send-api-request/send-soap.mdx | 5 +-
general/api-client/tests.mdx | 1 -
general/api-mocking/api-mocking.mdx | 6 +-
.../api-mocking/create-cloud-based-mocks.mdx | 8 +-
.../api-mocking/create-local-api-mocks.mdx | 28 +++---
general/getting-started/downloads.mdx | 10 +-
.../{introduction.mdx => overview.mdx} | 86 +++++++++++------
general/getting-started/quick-start-guide.mdx | 93 -------------------
.../browser-extension-setup.mdx | 33 ++++---
.../quick-start-guide/desktop-app-setup.mdx | 4 +-
.../http-interceptor/browser-extension.mdx | 12 +--
.../browser-interception.mdx | 14 +--
general/http-interceptor/desktop-app.mdx | 12 +--
.../desktop-app/android-devices.mdx | 18 ++--
.../android-simulator-interception.mdx | 28 +++---
.../desktop-app/browser-interception.mdx | 28 +++---
.../desktop-app/desktop-app-interception.mdx | 16 ++--
.../desktop-app/ios-devices-interception.mdx | 12 +--
.../ios-simulator-interception.mdx | 12 +--
.../desktop-app/network-table.mdx | 8 +-
.../http-interceptor/desktop-app/nodejs.mdx | 10 +-
.../http-interceptor/desktop-app/terminal.mdx | 10 +-
general/http-interceptor/overview.mdx | 8 +-
general/http-rules/advanced-usage.mdx | 8 +-
.../graphql-modify-request-response.mdx | 6 +-
.../http-rules/advanced-usage/grouping.mdx | 8 +-
...nditions-in-a-single-rule-in-requestly.mdx | 24 ++---
.../advanced-usage/pauseresume-requestly.mdx | 32 +++----
.../advanced-usage/pinning-rules.mdx | 14 +--
.../advanced-usage/shared-state.mdx | 10 +-
.../http-rules/advanced-usage/test-rules.mdx | 4 +-
.../validate-rules-execution.mdx | 18 ++--
general/http-rules/overview.mdx | 2 +-
general/http-rules/rule-types.mdx | 4 +-
.../rule-types/delay-network-requests.mdx | 2 +-
.../http-rules/rule-types/insert-scripts.mdx | 8 +-
general/http-rules/rule-types/map-local.mdx | 16 ++--
general/http-rules/rule-types/map-remote.mdx | 2 +-
.../http-rules/rule-types/modify-headers.mdx | 10 +-
.../rule-types/modify-query-params.mdx | 6 +-
.../rule-types/modify-response-body.mdx | 6 +-
.../rule-types/modify-user-agents.mdx | 10 +-
.../http-rules/rule-types/redirect-rule.mdx | 8 +-
.../http-rules/rule-types/replace-strings.mdx | 8 +-
general/http-rules/sharing.mdx | 2 +-
general/http-rules/sharing/download-rules.mdx | 2 +-
general/imports/charles-proxy.mdx | 16 ++--
general/imports/header-editor.mdx | 16 ++--
general/imports/modheader.mdx | 12 +--
general/imports/resource-override.mdx | 26 +++---
.../mock-server/create/create-mock-api.mdx | 6 +-
.../create/create-new-mock-file.mdx | 6 +-
.../mock-server/create/mock-collection.mdx | 2 +-
.../mock-server/import-and-export-mocks.mdx | 4 +-
general/mock-server/overview.mdx | 2 +-
general/mock-server/test.mdx | 4 +-
.../sessions/access-control-of-session.mdx | 6 +-
general/sessions/import-view-har-file.mdx | 20 ++--
general/sessions/overview.mdx | 6 +-
general/sessions/record-api-sessions.mdx | 30 +++---
general/sessions/record-bug-reports.mdx | 22 ++---
general/team/local-workspace.mdx | 18 +---
...equestly-using-my-browserstack-account.mdx | 10 +-
.../using-collection-runner-in-requestly.mdx | 24 ++---
...ariables-and-environments-in-requestly.mdx | 32 +++----
...disable-rule-application-status-widget.mdx | 2 +-
guides/disable-rules-syncing.mdx | 8 +-
...ing-certain-domains-on-the-desktop-app.mdx | 4 +-
...-fail-requests-based-on-request-counts.mdx | 4 +-
.../how-to-modify-cookies-using-requestly.mdx | 10 +-
...to-update-requestly-extension-manually.mdx | 14 +--
...questly-extension-in-browserstack-live.mdx | 58 ++++++------
...te-data-and-use-across-requestly-rules.mdx | 4 +-
...rameworks-like-selenium-and-playwright.mdx | 20 ++--
...ocument-using-modify-api-response-rule.mdx | 4 +-
...ders-in-web-automation-using-requestly.mdx | 20 ++--
guides/modifying-response-asynchronously.mdx | 6 +-
...-requestly-github-student-pack-benefit.mdx | 34 +++----
guides/record-and-mock-flaky-apis-in-bulk.mdx | 6 +-
...stly-integration-browserstack-app-live.mdx | 12 +--
public-apis/create-group.mdx | 6 +-
public-apis/create-rule.mdx | 8 +-
public-apis/delete-group.mdx | 4 +-
public-apis/delete-rule.mdx | 6 +-
public-apis/get-group.mdx | 6 +-
public-apis/get-rule.mdx | 8 +-
public-apis/overview.mdx | 12 +--
public-apis/update-existing-groups.mdx | 4 +-
public-apis/update-rule.mdx | 6 +-
.../install-certificate-windows.mdx | 18 ++--
.../intercepting-requests-from-localhost.mdx | 2 +-
.../system-wide-proxy-not-working-macos.mdx | 8 +-
...roubleshooting-proxy-not-shown-windows.mdx | 14 +--
.../troubleshooting-safari.mdx | 12 +--
...ubleshooting-untrusted-ssl-certificate.mdx | 14 +--
...-traffic-on-browser-mobile-or-emulator.mdx | 12 +--
.../http-rules/error-on-saving-rule.mdx | 4 +-
...nges-not-reflecting-in-chrome-devtools.mdx | 6 +-
troubleshoot/http-rules/rules-not-working.mdx | 32 +++----
...-your-requestly-version-in-the-browser.mdx | 26 +++---
.../troubleshooting-login-issues.mdx | 12 +--
121 files changed, 713 insertions(+), 818 deletions(-)
rename general/getting-started/{introduction.mdx => overview.mdx} (51%)
delete mode 100644 general/getting-started/quick-start-guide.mdx
diff --git a/docs.json b/docs.json
index 3e93833..dd338f0 100644
--- a/docs.json
+++ b/docs.json
@@ -156,8 +156,7 @@
{
"group": "Getting Started",
"pages": [
- "general/getting-started/introduction",
- "general/getting-started/quick-start-guide",
+ "general/getting-started/overview",
"general/getting-started/downloads",
"general/getting-started/quick-start-guide/browser-extension-setup",
"general/getting-started/quick-start-guide/desktop-app-setup",
@@ -541,6 +540,18 @@
}
},
"redirects": [
+ {
+ "source": "/general/getting-started/quick-start-guide",
+ "destination": "/general/getting-started/overview"
+ },
+ {
+ "source": "/general/getting-started/induction",
+ "destination": "/general/getting-started/overview"
+ },
+ {
+ "source": "/general/getting-started/introduction",
+ "destination": "/general/getting-started/overview"
+ },
{
"source": "/general/api-client/make-an-api-request",
"destination": "/general/api-client/overview"
diff --git a/general/api-client/difference-between-desktop-app-and-browser-extension.mdx b/general/api-client/difference-between-desktop-app-and-browser-extension.mdx
index 32beca3..c6ba4db 100644
--- a/general/api-client/difference-between-desktop-app-and-browser-extension.mdx
+++ b/general/api-client/difference-between-desktop-app-and-browser-extension.mdx
@@ -127,7 +127,7 @@ Use this table to compare capabilities and choose the right setup for your needs
- ✅ Work mostly with JSON/text payloads
- ✅ Prefer a lightweight workflow in the browser
-
+
Open the docs homepage and follow Getting Started
@@ -168,7 +168,7 @@ Your collections and environments sync across both when you use Team Workspaces,
Choose a path and set up Requestly
diff --git a/general/api-client/environments-and-variables.mdx b/general/api-client/environments-and-variables.mdx
index f956afc..5006e9c 100644
--- a/general/api-client/environments-and-variables.mdx
+++ b/general/api-client/environments-and-variables.mdx
@@ -13,7 +13,7 @@ When you run a request, Requestly replaces each `{{variable}}` with its actual v
Example: `https://{{base_url}}/users/{{user_id}}`
-If you've defined `base_url = api.example.com` and `user_id = 123`, the request resolves to - [`https://api.example.com/users/123`](https://api.example.com/users/123)
+If you've defined `base_url = api.example.com` and `user_id = 123`, the request resolves to - `https://api.example.com/users/123`
+TIP: Hover over any `{{variable}}` in your request to preview its resolved value instantly.
@@ -31,7 +31,7 @@ Define values based on your working environment (e.g., dev, staging, prod).
[Runtime Variables](/general/api-client/environments-and-variables/runtime-variables)
-Temporary values that last only for the current session—ideal for tokens or session IDs. They aren’t synced and can auto-clear after use.
+Temporary values that last only for the current session, ideal for tokens or session IDs. They aren’t synced and can auto-clear after use.
[Collection & SubCollection Variables](/general/api-client/environments-and-variables/collection-and-subcollection-variables)
diff --git a/general/api-client/environments-and-variables/environment-variables.mdx b/general/api-client/environments-and-variables/environment-variables.mdx
index f86f82b..b37fee0 100644
--- a/general/api-client/environments-and-variables/environment-variables.mdx
+++ b/general/api-client/environments-and-variables/environment-variables.mdx
@@ -24,7 +24,7 @@ Environment variables let you:
Example use cases:
-* `{{base_url}}` points to [`https://dev.api.com`](https://dev.api.com) in development and [`https://api.com`](https://api.com) in production
+* `{{base_url}}` points to `https://dev.api.com` in development and `https://api.com` in production
* Different `{{auth_token}}` for each environment
diff --git a/general/api-client/environments-and-variables/runtime-variables.mdx b/general/api-client/environments-and-variables/runtime-variables.mdx
index 374a13f..c4d40d4 100644
--- a/general/api-client/environments-and-variables/runtime-variables.mdx
+++ b/general/api-client/environments-and-variables/runtime-variables.mdx
@@ -62,7 +62,7 @@ Runtime variables are designed to give you flexibility when testing APIs across
You can use runtime variables just like environment or collection variables. Wrap the variable name in double curly braces `{{ }}`:
-[`https://api.example.com/users/{{session_id}}`](https://api.example.com/users/\{\{session_id)
+`https://api.example.com/users/{{session_id}}`
**Method 2: Set variables in scripts**\
You can define or update runtime variables in the **Scripts** tab using the `rq.variables` object.
diff --git a/general/api-client/import-export.mdx b/general/api-client/import-export.mdx
index f20d034..07073a9 100644
--- a/general/api-client/import-export.mdx
+++ b/general/api-client/import-export.mdx
@@ -1,13 +1,13 @@
---
-title: Import / Export
-label: Import / Export
+title: Overview
+label: Overview
slug: import-export
description: |-
Learn how to import and export API collections, environments, and requests
in Requestly.
visibility: PUBLIC
---
-Requestly’s API Client makes it easy to move your work across devices, collaborate with teammates, and back up your collections and environments using powerful import/export features.
+Requestly makes it easy to move your work across devices, collaborate with teammates, and back up your collections and environments using powerful import/export features.
This section covers everything you need to know about:
diff --git a/general/api-client/import-export/import-export-api-collections.mdx b/general/api-client/import-export/import-export-api-collections.mdx
index dcfc96c..2f62aec 100644
--- a/general/api-client/import-export/import-export-api-collections.mdx
+++ b/general/api-client/import-export/import-export-api-collections.mdx
@@ -1,5 +1,5 @@
---
-title: "API Collections"
+title: "Import / Export Collections"
slug: "import-export-api-collections"
path: "/api-client/import-export/import-export-api-collections"
visibility: "PUBLIC"
@@ -21,7 +21,7 @@ Exporting a collection generates a `.json` file that contains all the requests,
- [Download Requestly](https://requestly.com/downloads) and open the dashboard. From the sidebar, navigate to **APIs**.
+ [Download Requestly](https://requestly.com/downloads) and open app.
- [Download Requestly](https://requestly.com/downloads) and open the dashboard. From the sidebar, navigate to **APIs**.
+ [Download Requestly](https://requestly.com/downloads) and open app.
- Download Requestly and open the dashboard. From the sidebar, navigate to **APIs**.
+ Download Requestly and open app.
@@ -50,7 +50,7 @@ You can re-import an exported environment into any workspace to continue using y
- Download Requestly and open the dashboard. From the sidebar, navigate to **APIs**.
+ Download Requestly and open app.
diff --git a/general/api-client/import-export/import-from-curl.mdx b/general/api-client/import-export/import-from-curl.mdx
index 703a28e..0fee25b 100644
--- a/general/api-client/import-export/import-from-curl.mdx
+++ b/general/api-client/import-export/import-from-curl.mdx
@@ -6,14 +6,13 @@ visibility: "PUBLIC"
format: "MDX"
---
-Requestly’s API Client allows you to easily **import cURL commands** and convert them into fully editable API requests. This makes it simple to migrate from terminal-based workflows or share API requests across tools.
+Requestly allows you to easily **import cURL commands** and convert them into fully editable API requests. This makes it simple to migrate from terminal-based workflows or share API requests across tools.
## How to Import a cURL Command
-
- Download and launch Requestly (available as a web app or desktop app). Navigate to the **API** section from the dashboard.
-
+
+ Download and launch Requestly.
diff --git a/general/api-client/import-export/import-from-postman.mdx b/general/api-client/import-export/import-from-postman.mdx
index 0dcaf66..6c8e296 100644
--- a/general/api-client/import-export/import-from-postman.mdx
+++ b/general/api-client/import-export/import-from-postman.mdx
@@ -36,7 +36,7 @@ To use them in Requestly, you need to manually export global variables from Post
### **Importing into Requestly**
-**Step 1**: In Requestly, navigate to the **API Client** section.
+**Step 1**: Open **Requestly Desktop App**.
**Step 2**: Click the **Import** button located in the sidebar header and choose **Postman** from the import options.
diff --git a/general/api-client/import-export/import-from-wsdl.mdx b/general/api-client/import-export/import-from-wsdl.mdx
index edcb1fc..1175dd0 100644
--- a/general/api-client/import-export/import-from-wsdl.mdx
+++ b/general/api-client/import-export/import-from-wsdl.mdx
@@ -6,7 +6,7 @@ A WSDL (Web Services Description Language) file defines the structure of a SOAP
- In Requestly, open **API Client** and click the `Import` button.
+ Open **Requestly Desktop App** and click the `Import` button.
diff --git a/general/api-client/import-export/import-openapi-spec.mdx b/general/api-client/import-export/import-openapi-spec.mdx
index 0461965..85f711d 100644
--- a/general/api-client/import-export/import-openapi-spec.mdx
+++ b/general/api-client/import-export/import-openapi-spec.mdx
@@ -17,7 +17,7 @@ The importer supports both **YAML** and **JSON** OpenAPI files. When you upload
- Go to your **API Client workspace** in Requestly. Make sure you’re in the workspace where you want to import your API collection.
+ Open **Requestly Desktop App**. Make sure you’re in the Project where you want to import your API collection.
- In the left sidebar of the API Client, hover over the collection you wish to export and click the **three‑dot menu (⋯)**.
+ Hover over the collection you wish to export and click the **three‑dot menu (⋯)**.
diff --git a/general/api-client/overview.mdx b/general/api-client/overview.mdx
index e9a8b1a..1d6aa3c 100644
--- a/general/api-client/overview.mdx
+++ b/general/api-client/overview.mdx
@@ -3,10 +3,10 @@ title: Overview
label: Overview
slug: overview
description: >-
- Learn when to use Requestly as your API client, how to send requests, get started fast, and which workflows to explore next.
+ Learn how to use Requestly, how to send requests, get started fast, and which workflows to explore next.
seoDescription: >-
Learn how to use Requestly for API testing, sending HTTP requests, environments, collections, scripts, and assertions.
-seoTitle: Requestly API client overview
+seoTitle: Requestly Overview
visibility: PUBLIC
---
In Requestly, you can send requests, inspect responses, organize APIs, and automate API testing workflows.
@@ -15,10 +15,10 @@ In Requestly, you can send requests, inspect responses, organize APIs, and autom
Use Requestly when you want to:
-- send REST or GraphQL requests manually
-- manage collections, folders, and reusable environments
-- add authorization, scripts, and assertions
-- run repeatable request flows and share them with your team
+- Send REST or GraphQL requests manually
+- Manage collections, folders, and reusable environments
+- Add authorization, scripts, and assertions
+- Run repeatable request flows and share them with your team
If your goal is to inspect live traffic from an app or browser, start with [HTTP Interceptor](/general/http-interceptor/overview) instead. If you need to rewrite traffic in-place, use [HTTP Rules](/general/http-rules/overview).
@@ -31,7 +31,7 @@ If your goal is to inspect live traffic from an app or browser, start with [HTTP
Group related APIs into collections, folders, and reusable workflows.
-
+
Switch between environments and reuse dynamic values safely.
@@ -41,9 +41,7 @@ If your goal is to inspect live traffic from an app or browser, start with [HTTP
## Sending requests
-Whether you are building and testing your own API or integrating with a third-party API, you can use Requestly to send requests and connect to the APIs you are working with. Your requests can retrieve, create, update, or delete data, and they can include parameters and authorization details.
-
-For example, if you are building a client application such as a mobile or web app for a store, you might send one request to retrieve a list of available products, another request to create a new order with selected product details, and another request to log a customer into their account.
+Whether you are building your own API or working with a third-party service, Requestly lets you send `GET`, `POST`, `PUT`, `PATCH`, and `DELETE` requests. You can add query parameters, headers, request bodies, and authorization details to test how your API behaves across different scenarios.
When you send a request, Requestly displays the API server’s response in a clear format so you can inspect, visualize, and troubleshoot it easily.
@@ -51,29 +49,29 @@ When you send a request, Requestly displays the API server’s response in a cle
### Get started with sending requests
-If you have not sent a request before, review [Sending your first request](/general/api-client/quick-start) before continuing.
+If you have not sent a request before, start with [Sending your first request](/general/api-client/quick-start) before continuing.
-Explore the topics below to learn how to send API requests in Requestly:
+Explore the topics below to learn how to send requests in Requestly:
-- To understand the basics of building requests, including selecting HTTP methods, entering URLs, and interpreting response status codes, see [Configure request](/general/api-client/send-api-request/create-requests/configure-request).
+- To understand the basics of building requests, including selecting `HTTP methods`, entering `URLs`, and getting `response status codes`, go to [Configure request ->](/general/api-client/send-api-request/create-requests/configure-request).
-- To learn how to add query parameters, path variables, and request body data in formats such as JSON, form data, and file uploads, see [Parameters and body data](/general/api-client/send-api-request/create-requests/parameters-and-body).
+- To learn how to add query parameters, path variables, and request body data in formats such as `JSON`, `form data`, and `file uploads`, go to [Parameters and body data ->](/general/api-client/send-api-request/create-requests/parameters-and-body).
-- If your API requires specific headers or authentication tokens, learn how to configure them in [Request headers](/general/api-client/send-api-request/create-requests/request-headers).
+- If your API requires specific headers or authentication tokens, learn how to configure them in [Request headers ->](/general/api-client/send-api-request/create-requests/request-headers).
-- Export requests as code snippets in multiple languages such as JavaScript, Python, and cURL. Learn more in [Generate client code](/general/api-client/send-api-request/create-requests/generate-client-code).
+- Export requests as code snippets in multiple languages such as JavaScript, Python, and cURL. Learn more in [Generate client code ->](/general/api-client/send-api-request/create-requests/generate-client-code).
- If your API requires identity verification or access control, review the [authorization guide](/general/api-client/send-api-request/authorization).
-- Use collections to group related requests for better organization and collaboration. Learn more in [API collections](/general/api-client/api-collections).
+- Use collections to group related requests for better organization and collaboration. Learn more in [API collections ->](/general/api-client/api-collections).
-- Variables allow you to reuse data across requests and switch values based on environments such as development, staging, or production. See [Variables and environments](/general/api-client/environments-and-variables).
+- Variables allow you to reuse data across requests and switch values based on environments such as development, staging, or production. See [Variables and environments ->](/general/api-client/environments-and-variables).
-- Add JavaScript code to run before sending requests or after receiving responses to automate workflows and extract data. Learn more in [Scripts](/general/api-client/scripts).
+- Add JavaScript code to run before sending requests or after receiving responses to automate workflows and extract data. Learn more in [Scripts ->](/general/api-client/scripts).
-- Write automated tests to validate API responses and ensure reliability. See [Tests](/general/api-client/tests).
+- Write automated tests to validate API responses and ensure reliability. See [Tests ->](/general/api-client/tests).
-In addition to standard HTTP requests, Requestly also supports other formats and protocols such as [GraphQL](/general/api-client/send-api-request/graphql-request). You can also [import from cURL](/general/api-client/import-export/import-from-curl), [import from Postman](/general/api-client/import-export/import-from-postman), or [import OpenAPI specifications](/general/api-client/import-export/import-openapi-spec).
+In addition to standard HTTP requests, Requestly also supports other formats and protocols such as [GraphQL](/general/api-client/send-api-request/graphql-request) and [SOAP](/general/api-client/send-api-request/send-soap). You can also [import from cURL](/general/api-client/import-export/import-from-curl), [import from Postman](/general/api-client/import-export/import-from-postman), or [import OpenAPI specifications](/general/api-client/import-export/import-openapi-spec).
-## Explore by workflow
+## Explore Next
-
- Follow the guided beginner walkthrough from first request to environments.
-
Learn request configuration, headers, body handling, authorization, and history.
@@ -144,14 +139,3 @@ In addition to standard HTTP requests, Requestly also supports other formats and
Execute multi-request workflows against environments and test data.
-
-## Related capabilities
-
-
-
- Use HTTP Rules when you need to rewrite live requests and responses during testing.
-
-
- Use HTTP Interceptor when you need to inspect what your app is sending over the network.
-
-
diff --git a/general/api-client/scripts.mdx b/general/api-client/scripts.mdx
index d3bb5e3..085a2b6 100644
--- a/general/api-client/scripts.mdx
+++ b/general/api-client/scripts.mdx
@@ -101,7 +101,7 @@ You can use `console.log()` or `console.error()` in your Pre-Request and Post-Re
-Open your browser’s Developer Tools Console using **F12**, **Cmd + Option + J***,* or **Ctrl + Shift + J**. Logs from your Pre-Request and Post-Response Scripts will appear here in real time.
+Open your browser’s Developer Tools Console using **Cmd + Option + I** or **Ctrl + Shift + I**. Logs from your Pre-Request and Post-Response Scripts will appear here in real time.
In the console’s filter box, type or paste the keyword **#script** to view only Requestly script logs. This helps you isolate logs originating from your API client scripts.
diff --git a/general/api-client/send-api-request/authorization.mdx b/general/api-client/send-api-request/authorization.mdx
index b816f51..1842a18 100644
--- a/general/api-client/send-api-request/authorization.mdx
+++ b/general/api-client/send-api-request/authorization.mdx
@@ -18,9 +18,9 @@ Requestly allows you to send authorization data along with your API requests. Au
src="https://www.youtube.com/embed/pnZ8toyzjAM"
/>
-## Request Authorization
-
-Authorization details can be configured in the Authorization tab at either the collection level or the individual request level. When authentication is set at the collection level, it applies to all APIs within that collection unless a specific request defines its own authorization settings or selects **“NO-AUTH.”** Requestly automatically inserts the appropriate authorization information into the necessary sections of the request based on the chosen authentication type.
+
+Authorization details can be configured in the Authorization tab at either the **collection level** or the **request level**. When authentication is set at the collection level, it applies to all APIs within that collection unless a specific request defines its own authorization settings or selects **NO-AUTH.** Requestly automatically inserts the appropriate authorization information into the necessary sections of the request based on the chosen authentication type.
+
## Steps to Add Authorization
diff --git a/general/api-client/send-api-request/create-requests/configure-request.mdx b/general/api-client/send-api-request/create-requests/configure-request.mdx
index aa77b0e..1ba36d2 100644
--- a/general/api-client/send-api-request/create-requests/configure-request.mdx
+++ b/general/api-client/send-api-request/create-requests/configure-request.mdx
@@ -6,7 +6,7 @@ description: "Learn how to configure HTTP methods, URLs, and send API requests i
visibility: "PUBLIC"
---
-Configuring your API request properly is the first step to successful API testing. This guide covers how to set up HTTP methods, URLs, and send requests effectively.
+This guide covers how to set up HTTP methods, URLs, and send requests effectively.
## HTTP Methods
@@ -112,11 +112,11 @@ Once you've configured your request:
- Press the **Send** button to execute the request. Requestly will display the response in the panel below.
+ Press the **Send** button to execute the request. It will display the response in the panel below.
- Check the response status code, body, and headers to verify the request was successful.
+ Check the response `status code`, `body`, and `headers` to verify the request was successful.
**Common status codes:**
- `200 OK` - Success
@@ -137,7 +137,4 @@ Once you've configured your request:
Set up authentication and custom headers
-
- Configure API Key, Bearer Token, or Basic Auth
-
diff --git a/general/api-client/send-api-request/create-requests/generate-client-code.mdx b/general/api-client/send-api-request/create-requests/generate-client-code.mdx
index 9542ccc..7d67ad6 100644
--- a/general/api-client/send-api-request/create-requests/generate-client-code.mdx
+++ b/general/api-client/send-api-request/create-requests/generate-client-code.mdx
@@ -3,7 +3,7 @@ title: Generate Client Code
label: Generate Client Code
slug: generate-client-code
description: >-
- Easily generate client code snippets for API requests with Requestly. Supports
+ Easily generate client code snippets for API requests. Supports
multiple languages including Python, Ruby, PHP, R, and shell.
seoDescription: >-
Easily generate client code snippets for API requests with Requestly. Supports
@@ -67,7 +67,3 @@ Requestly supports generating client code in multiple programming languages, cov
* **Shell - HTTPie**
* **Shell - Wget**
-
-
- We are expanding the list of support languages, if you want to see a particular language here you can either open an issue or directly open a PR on our GitHub repo.
-
diff --git a/general/api-client/send-api-request/create-requests/overview.mdx b/general/api-client/send-api-request/create-requests/overview.mdx
index 249ed1b..e565592 100644
--- a/general/api-client/send-api-request/create-requests/overview.mdx
+++ b/general/api-client/send-api-request/create-requests/overview.mdx
@@ -8,9 +8,9 @@ seoDescription: "Complete guide to creating API requests in Requestly. Send HTTP
visibility: "PUBLIC"
---
-The API client in Requestly allows you to easily send API requests, without the need for writing code or using a terminal. It lets you test APIs, retrieve data, and explore how they work by simply creating a request, clicking Send, and viewing the response within Requestly.
+Requestly allows you to easily send API requests, without the need for writing code or using a terminal. It lets you test APIs, retrieve data, and explore how they work by simply creating a request, clicking Send, and viewing the response.
-This feature is perfect for developers testing API endpoints during development, QA engineers validating API responses for edge cases, and support engineers debugging API issues in real-time.
+This is useful for developers testing API endpoints during development, QA engineers validating API responses for edge cases, and support engineers debugging API issues in real-time.
@@ -20,7 +20,7 @@ Follow these steps to send your first API request:
- Click the **API Client** link in the left sidebar of the Requestly application, then click the `+ New` button to create a new request and select **Request** from the menu.
+ Open **Requestly Desktop App**, then click the `+ New` button to create a new request and select **Request** from the menu.
- Pick the HTTP method (e.g., GET, POST) and type the URL of the API you want to test.
+ Pick the HTTP method (e.g., `GET`, `POST`) and type the URL of the API you want to test.
Configure headers for authentication and content types
-
- Export your requests as code in multiple programming languages
-
\ No newline at end of file
diff --git a/general/api-client/send-api-request/graphql-request.mdx b/general/api-client/send-api-request/graphql-request.mdx
index ea787ed..79efc19 100644
--- a/general/api-client/send-api-request/graphql-request.mdx
+++ b/general/api-client/send-api-request/graphql-request.mdx
@@ -7,7 +7,6 @@ description: >-
and define variables
visibility: PUBLIC
---
-***
GraphQL requests work over HTTP just like REST, but instead of defining multiple endpoints, you typically interact with a **single endpoint** (e.g., `/graphql`) and specify the exact data you want. This gives you flexibility, reduces over-fetching, and makes debugging APIs much simpler.
@@ -17,7 +16,7 @@ GraphQL requests work over HTTP just like REST, but instead of defining multiple
- Click the **API Client** link in the left sidebar of the Requestly application, then click the `+ New` button to create a new request and select **GraphQL request** from the menu.
+ Open **Requestly Desktop App**, then click the `+ New` button to create a new request and select **GraphQL request** from the menu.
@@ -74,7 +73,7 @@ GraphQL requests work over HTTP just like REST, but instead of defining multiple
- Click the **API Client** link in the left sidebar of the Requestly application, then click the `+ New` button to create a new request and select **GraphQL request** from the menu.
+ Open **Requestly Desktop App**, then click the `+ New` button to create a new request and select **GraphQL request** from the menu.
diff --git a/general/api-client/send-api-request/replay-request-from-history.mdx b/general/api-client/send-api-request/replay-request-from-history.mdx
index fc4ab6c..276b1c6 100644
--- a/general/api-client/send-api-request/replay-request-from-history.mdx
+++ b/general/api-client/send-api-request/replay-request-from-history.mdx
@@ -15,7 +15,7 @@ visibility: PUBLIC
The API Call History feature allows users to track and manage all requests triggered from the API Client. The most recent request is displayed at the top of the history panel, providing a clear chronological view of interactions.
- History is stored locally in your browser's local storage and is not synced to the cloud considering the security and privacy of your data.
+ History is stored locally and is not synced to the cloud.
### Viewing API Call History
@@ -34,14 +34,6 @@ Click the "Clear History" button located at the top of the history sidebar. This
-### Limitations
-
-* **Browser Dependency:** The history is only maintained for the browser in which it was created.
-
-* **Session Constraints:** Responses are cached only within the active browser session. Closing the tab clears all cached responses.
-
-* **Request Limit:** Only the last 20 requests are preserved in the history. Older entries are automatically removed as new requests are made.
-
## What's Next?
diff --git a/general/api-client/send-api-request/send-soap.mdx b/general/api-client/send-api-request/send-soap.mdx
index ac04c8c..349328f 100644
--- a/general/api-client/send-api-request/send-soap.mdx
+++ b/general/api-client/send-api-request/send-soap.mdx
@@ -14,7 +14,7 @@ SOAP (Simple Object Access Protocol) is a protocol for exchanging structured inf
- Click the **API Client** in the left sidebar, then click the `+ New` button to create a new request. Select a standard **HTTP request** since SOAP works over HTTP.
+ Open **Requestly Desktop App**, then click the `+ New` button to create a new request. Select a standard **HTTP request** since SOAP works over HTTP.
@@ -29,7 +29,8 @@ SOAP (Simple Object Access Protocol) is a protocol for exchanging structured inf
Add your SOAP service endpoint URL and set the method to **POST**. Example endpoint:
-
+
+ For example:
```http
http://www.dneonline.com/calculator.asmx
```
diff --git a/general/api-client/tests.mdx b/general/api-client/tests.mdx
index 2745d70..8daa12b 100644
--- a/general/api-client/tests.mdx
+++ b/general/api-client/tests.mdx
@@ -7,7 +7,6 @@ description: >-
validations like status code checks and JSON body tests.
visibility: PUBLIC
---
-***
Automated API testing ensures endpoints function as expected. Requestly allows you to write tests using JavaScript with the [`rq`](/general/api-client/scripts#requestly-javascript-api-rq) object enabling validations, schema checks, and automated workflows.
diff --git a/general/api-mocking/api-mocking.mdx b/general/api-mocking/api-mocking.mdx
index f8cf831..d69d4c4 100644
--- a/general/api-mocking/api-mocking.mdx
+++ b/general/api-mocking/api-mocking.mdx
@@ -22,17 +22,17 @@ By using API mocking, you can:
* Simulate performance scenarios like delayed responses.
-With **Requestly**, you can easily create and manage API mocks to streamline your development workflow. Requestly provides two approaches to mocking APIs:
+With **Requestly Interceptor**, you can easily create and manage API mocks to streamline your development workflow. Requestly Interceptor provides two approaches to mocking APIs:
### **Create Local API Mocks**
-Using Requestly’s **Modify Response** feature, you can easily create **Local API Mocks** to simulate API responses without hitting the actual server. This is perfect for testing and development when you need to work offline or want to simulate specific scenarios. You can create mocks for individual endpoints or use a recorded session from requestly interceptor to create mock responses in bulk
+Using Requestly Interceptor’s **Modify Response** feature, you can easily create **Local API Mocks** to simulate API responses without hitting the actual server. This is perfect for testing and development when you need to work offline or want to simulate specific scenarios. You can create mocks for individual endpoints or use a recorded session from Requestly Interceptor to create mock responses in bulk.
For detailed instructions on setting up Local Mocks and Modify Response, visit our [Local Mocks Documentation](/general/api-mocking/create-local-api-mocks).
## Create Cloud Mocks
-With **Requestly’s** , you can upload or create files directly on Requestly’s servers. These files can then be used as **redirect destinations** for any API request using Requestly’s **Redirect Rule**. This allows you to simulate API responses effortlessly without relying on a live server.
+With **Mock Server**, you can upload or create files directly on Requestly Interceptor’s servers. These files can then be used as **redirect destinations** for any API request using Requestly Interceptor’s **Redirect Rule**. This allows you to simulate API responses effortlessly without relying on a live server.
Each mock file is accessible via a **dedicated URL**, making it easy to share across teams and environments. This approach is perfect for collaborative testing, automated workflows, and ensuring consistent API simulation throughout the development and testing lifecycle.
diff --git a/general/api-mocking/create-cloud-based-mocks.mdx b/general/api-mocking/create-cloud-based-mocks.mdx
index f5fdd9c..188cd77 100644
--- a/general/api-mocking/create-cloud-based-mocks.mdx
+++ b/general/api-mocking/create-cloud-based-mocks.mdx
@@ -5,17 +5,17 @@ slug: create-cloud-based-mocks
description: Learn how to create modify and manage mock files in requestly
visibility: PUBLIC
---
-Cloud-based mocks let you simulate API responses by hosting mock data online instead of running a local server. With Requestly’s Mock Server, you can upload mock files like JSON or HTML and redirect real API requests to these files. It’s a fast, shareable, and reliable way to mock backend APIs for frontend development and testing in isolation.
+Cloud-based mocks let you simulate API responses by hosting mock data online instead of running a local server. With Requestly Interceptor’s Mock Server, you can upload mock files like JSON or HTML and redirect real API requests to these files. It’s a fast, shareable, and reliable way to mock backend APIs for frontend development and testing in isolation.
## How to Create a Cloud-based Mock
To create a cloud mock, you’ll first create a file in Mock Server and then set up a Redirect Rule to serve it in place of a real API.
-### Step 1: Create a File in Requestly Mock Server
+### Step 1: Create a File in Requestly Interceptor Mock Server
- From the Requestly Dashboard, go to the **Files** tab in the sidebar.
+ From the Requestly Interceptor Dashboard, go to the **Files** tab in the sidebar.
@@ -67,7 +67,7 @@ To create a cloud mock, you’ll first create a file in Mock Server and then set
> 💡 Example:
>
- > Match the bakery products API in the [Requestly Playground:](https://requestly-playground.com/)
+ > Match the bakery products API in the [Requestly Interceptor Playground:](https://requestly-playground.com/)
>
> [`https://rest.requestly-playground.com/api/products?searchJoin=and&with=type%3Bauthor&limit=30&language=en&search=type.slug:bakery%3Bstatus:publish`](https://rest.requestly-playground.com/api/products?searchJoin=and\&with=type%3Bauthor\&limit=30\&language=en\&search=type.slug:bakery%3Bstatus:publish)
diff --git a/general/api-mocking/create-local-api-mocks.mdx b/general/api-mocking/create-local-api-mocks.mdx
index 5882338..094054e 100644
--- a/general/api-mocking/create-local-api-mocks.mdx
+++ b/general/api-mocking/create-local-api-mocks.mdx
@@ -2,27 +2,27 @@
title: 'Create Local API Mocks '
label: Create Local API Mocks
slug: create-local-api-mocks
-description: Learn how to mock APIs locally with ease using Requestly
+description: Learn how to mock APIs locally with ease using Requestly Interceptor
seoTitle: Create Local API Mocks
visibility: PUBLIC
---
## **Introduction**
-Creating mock APIs locally with Requestly is a powerful way to simulate server responses directly in your development environment. This feature is invaluable for developers looking to test features, handle edge cases, or debug applications without relying on live servers.
+Creating mock APIs locally with Requestly Interceptor is a powerful way to simulate server responses directly in your development environment. This feature is invaluable for developers looking to test features, handle edge cases, or debug applications without relying on live servers.
-On this page, you'll see how to use Requestly’s Modify API Response rule to mock API responses and create bulk mocks using recorded sessions, making your workflow faster and more efficient.
+On this page, you'll see how to use Requestly Interceptor’s Modify API Response rule to mock API responses and create bulk mocks using recorded sessions, making your workflow faster and more efficient.
## **Steps to Create a Mock API Using the Modify Response Rule**
The **Modify API Response** rule allows you to intercept and alter API responses without needing changes on the server. It’s a powerful feature for testing, debugging, and mocking APIs during development.
-This rule is available on both the **Requestly desktop app** and the **browser extension**, giving you flexibility across environments.
+This rule is available on both the **Requestly Interceptor desktop app** and the **browser extension**, giving you flexibility across environments.
To create a mock API, you can use this rule to intercept and return a static response for a specific request without sending it to the server.
-
- Log in to your Requestly account and navigate to the **HTTP** **Rules** section.
+
+ Log in to your Requestly Interceptor account and navigate to the **HTTP** **Rules** section.
@@ -34,7 +34,7 @@ To create a mock API, you can use this rule to intercept and return a static res
- Set up your Modify API Response rule with the necessary configurations. We'll use [**Requestly Playground**](https://www.requestly-playground.com/) as a demo for this [example](https://app.requestly.io/rules#sharedList/320743d1f2eb488bb71047ae5501c7fc-Requestly-Playground):
+ Set up your Modify API Response rule with the necessary configurations. We'll use [**Requestly Interceptor Playground**](https://www.requestly-playground.com/) as a demo for this [example](https://app.requestly.io/rules#sharedList/320743d1f2eb488bb71047ae5501c7fc-Requestly Interceptor-Playground):
@@ -66,15 +66,15 @@ Bulk API Mocking allows you to mock multiple API endpoints at once using recorde
**Record a Session**
-If you haven’t already recorded a session, start by capturing the API requests and responses you want to mock using Requestly’s interceptor and save it in a session, start by:
+If you haven’t already recorded a session, start by capturing the API requests and responses you want to mock using Requestly Interceptor’s interceptor and save it in a session, start by:
-
- Open the Requestly Desktop App and navigate to the **network traffic** tab on the left sidebar.
+
+ Open the Requestly Interceptor Desktop App and navigate to the **network traffic** tab on the left sidebar.
- Click any of the `Connect Apps` buttons to open the **Connect Panel**, which displays all supported apps Requestly can connect to.
+ Click any of the `Connect Apps` buttons to open the **Connect Panel**, which displays all supported apps Requestly Interceptor can connect to.
@@ -86,7 +86,7 @@ If you haven’t already recorded a session, start by capturing the API requests
- Perform the actions or user flows in your app or website to trigger the API requests you want to record. Requestly will log all requests and responses automatically.
+ Perform the actions or user flows in your app or website to trigger the API requests you want to record. Requestly Interceptor will log all requests and responses automatically.
@@ -108,7 +108,7 @@ Once you've recorded an API session, you can easily generate bulk mock rules bas
- Navigate to the **Sessions** tab in the left sidebar of the Requestly dashboard.
+ Navigate to the **Sessions** tab in the left sidebar of the Requestly Interceptor dashboard.
@@ -154,7 +154,7 @@ Once you've recorded an API session, you can easily generate bulk mock rules bas
- Click **Create Rules** to generate the mock rules. Requestly will automatically create a collection of **Modify Response** rules, all enabled and ready to use.
+ Click **Create Rules** to generate the mock rules. Requestly Interceptor will automatically create a collection of **Modify Response** rules, all enabled and ready to use.
diff --git a/general/getting-started/downloads.mdx b/general/getting-started/downloads.mdx
index c644a49..359199c 100644
--- a/general/getting-started/downloads.mdx
+++ b/general/getting-started/downloads.mdx
@@ -1,14 +1,14 @@
---
-title: "Download Requestly"
+title: "Download Requestly Interceptor"
label: "Downloads"
slug: "downloads"
visibility: "PUBLIC"
-description: "Requestly is available across browsers and desktop platforms."
+description: "Requestly Interceptor is available across browsers and desktop platforms."
---
Choose the version that fits your workflow and start testing, debugging, or modifying network traffic instantly.
-## Requestly For Browsers
+## Requestly Interceptor For Browsers
@@ -41,7 +41,7 @@ Choose the version that fits your workflow and start testing, debugging, or modi
-## Requestly for Desktop
+## Requestly Interceptor for Desktop
@@ -69,7 +69,7 @@ Choose the version that fits your workflow and start testing, debugging, or modi
### **Install using Winget for Windows**
-You can install Requestly on Windows through Winget.\
+You can install Requestly Interceptor on Windows through Winget.\
Run this command in PowerShell or Command Prompt:
```bash
diff --git a/general/getting-started/introduction.mdx b/general/getting-started/overview.mdx
similarity index 51%
rename from general/getting-started/introduction.mdx
rename to general/getting-started/overview.mdx
index 51a0455..9574484 100644
--- a/general/getting-started/introduction.mdx
+++ b/general/getting-started/overview.mdx
@@ -1,20 +1,16 @@
---
-title: "Introduction"
-label: "Introduction"
-slug: "introduction"
-description: "Start here to understand Requestly, choose the right workflow, and get to your first success quickly."
+title: "Overview"
+label: "Overview"
+slug: "overview"
+description: "Start here to understand Requestly Interceptor, choose the right workflow, complete setup, and reach your first success quickly."
visibility: "PUBLIC"
---
-Requestly helps you test APIs, intercept traffic, modify requests and responses, mock backend behavior, and share debugging context with your team.
-If you are new to Requestly, start by choosing the workflow that matches what you want to do first.
+Requestly Interceptor helps you inspect and modify network traffic in real time. You can debug browser requests, intercept mobile and desktop app traffic, rewrite requests and responses, create mocks, and share debugging sessions with your team.
## Choose Your Path
-
- Send your first request, organize collections, add environments, and validate responses.
-
Use the Browser Extension when you want to inspect and modify traffic in the browser.
@@ -27,17 +23,10 @@ If you are new to Requestly, start by choosing the workflow that matches what yo
Build reusable mock APIs and hosted responses for testing, demos, and collaboration.
-
- Record bug reports, capture API sessions, import HAR files, and share findings with your team.
-
## Understand The Product Areas
-### API Testing
-
-Use the [API Client](/general/api-client/overview) to send requests, organize collections, manage environments, write assertions, and automate test flows.
-
### Debugging & Interception
Use the [HTTP Interceptor](/general/http-interceptor/overview) when you need to inspect live traffic from a browser, desktop app, mobile device, emulator, terminal, or Node.js runtime.
@@ -50,19 +39,42 @@ Use [HTTP Rules](/general/http-rules/overview) to modify headers, redirect reque
Use [API Mocking](/general/api-mocking/api-mocking) and [Mock Server](/general/mock-server/overview) to simulate backend behavior for development, testing, demos, and failure scenarios.
-### Collaboration & Sessions
+## Which Setup Should You Choose?
+
+
+
+ Choose the Browser Extension when:
+
+ - you only need browser-based workflows
+ - you want quick setup with no system proxy configuration
+ - you plan to inspect traffic, create rules, or work from the extension popup
-Use [Sessions](/general/sessions/overview) and [Workspaces](/general/team/workspaces) to capture debugging context, share reproducible artifacts, and collaborate across teams.
+
+ Install the extension, understand the interface, and learn what it can do.
+
+
+
+ Choose the Desktop App when:
+
+ - you need to intercept mobile devices, emulators, or desktop apps
+ - you need system-wide or proxy-based interception
+ - you want richer network capture, HAR workflows, or advanced debugging
+
+
+ Install the desktop app and connect the right runtime for your workflow.
+
+
+
+
+
+ Still deciding? Read [how the Browser Extension differs from the Desktop App](/general/others/how-is-bowser-extension-different-from-a-desktop-app).
+
## Recommended First Steps
If you only need browser-based traffic tools, start with the Browser Extension. If you need to intercept mobile apps, emulators, localhost traffic, or system-wide traffic, use the Desktop App.
-
-
- Use the [platform comparison guide](/general/api-client/difference-between-desktop-app-and-browser-extension) if you are not sure which setup to choose.
-
Follow either the [Browser Extension setup](/general/getting-started/quick-start-guide/browser-extension-setup) or [Desktop App setup](/general/getting-started/quick-start-guide/desktop-app-setup) guide.
@@ -70,23 +82,39 @@ Use [Sessions](/general/sessions/overview) and [Workspaces](/general/team/worksp
Pick one clear first task:
- - [Send your first API request](/general/api-client/quick-start)
- [Inspect live traffic](/general/http-interceptor/overview)
- [Create your first traffic rule](/general/http-rules/rule-types)
- [Create your first mock](/general/mock-server/create/create-mock-api)
+
+ After your first successful task, explore sessions, collaboration, advanced rules, and mock scenarios.
+
-## Next Steps
+## Common Journeys
-
-
- Follow the guided onboarding flow for the most common Requestly workflows.
+
+
+ Start with HTTP Rules if you need to change traffic without updating application code.
+
+
+ Start with HTTP Interceptor if you need to see live network traffic and trace issues.
+
+ Start with Sessions if you need reproducible bug reports or sharable network captures.
+
+
+ Start with Mock Server when you need stable responses for testing or demos.
+
+
+
+## Next Steps
+
+
Get help with certificate, localhost, proxy, and device interception issues.
- Automate Requestly workflows programmatically.
+ Automate Requestly Interceptor workflows programmatically.
-
\ No newline at end of file
+
diff --git a/general/getting-started/quick-start-guide.mdx b/general/getting-started/quick-start-guide.mdx
deleted file mode 100644
index d670614..0000000
--- a/general/getting-started/quick-start-guide.mdx
+++ /dev/null
@@ -1,93 +0,0 @@
----
-title: Quick Start
-label: Quick Start
-slug: quick-start-guide
-description: >-
- Choose the right Requestly workflow, complete setup, and get to your first successful task quickly.
-visibility: PUBLIC
----
-Requestly can support several workflows, but most new users only need one path to start. Use this page to pick the right setup and reach your first success faster.
-
-## Pick Your Starting Workflow
-
-
-
- Best for sending requests, working with collections, managing environments, and writing assertions.
-
-
- Best for intercepting and modifying requests directly in supported browsers.
-
-
- Best for mobile apps, emulators, localhost traffic, command-line tools, and system-wide debugging.
-
-
- Best for modifying headers, redirecting URLs, rewriting responses, and simulating backend behavior.
-
-
-
-## Which Setup Should You Choose?
-
-
-
- Choose the Browser Extension when:
-
- - you only need browser-based workflows
- - you want quick setup with no system proxy configuration
- - you plan to inspect traffic, create rules, or use the API Client in the browser
-
-
- Install the extension, understand the interface, and learn what it can do.
-
-
-
- Choose the Desktop App when:
-
- - you need to intercept mobile devices, emulators, or desktop apps
- - you need system-wide or proxy-based interception
- - you want richer network capture, HAR workflows, or advanced debugging
-
-
- Install the desktop app and connect the right runtime for your workflow.
-
-
-
-
-
- Still deciding? Read the [Browser Extension vs Desktop App comparison](/general/api-client/difference-between-desktop-app-and-browser-extension).
-
-
-## Reach Your First Success
-
-
-
- Finish either the [Browser Extension setup](/general/getting-started/quick-start-guide/browser-extension-setup) or [Desktop App setup](/general/getting-started/quick-start-guide/desktop-app-setup).
-
-
- Start with one clear outcome instead of exploring every feature at once.
-
- - [Send your first API request](/general/api-client/quick-start)
- - [Inspect traffic with HTTP Interceptor](/general/http-interceptor/overview)
- - [Create your first HTTP Rule](/general/http-rules/rule-types)
- - [Create your first mock](/general/mock-server/create/create-mock-api)
-
-
- After your first successful task, expand into environments, assertions, automation, sessions, and collaboration workflows.
-
-
-
-## Common Journeys
-
-
-
- Start with API Client if your immediate goal is testing an endpoint.
-
-
- Start with HTTP Rules if you need to change traffic without updating application code.
-
-
- Start with HTTP Interceptor if you need to see live network traffic and trace issues.
-
-
- Start with Sessions if you need reproducible bug reports or sharable network captures.
-
-
diff --git a/general/getting-started/quick-start-guide/browser-extension-setup.mdx b/general/getting-started/quick-start-guide/browser-extension-setup.mdx
index 5273bba..261673f 100644
--- a/general/getting-started/quick-start-guide/browser-extension-setup.mdx
+++ b/general/getting-started/quick-start-guide/browser-extension-setup.mdx
@@ -6,14 +6,14 @@ visibility: "PUBLIC"
format: "MDX"
---
-The Requestly Browser Extension is a lightweight yet powerful tool designed for developers working on **browser-based workflows**.
+The Requestly Interceptor Browser Extension is a lightweight yet powerful tool designed for developers working on **browser-based workflows**.
-Requestly’s browser extension is available for all major browsers including **Chrome, Firefox, Edge, Brave, Vivaldi, Arc**, and **Opera**.
+Requestly Interceptor’s browser extension is available for all major browsers including **Chrome, Firefox, Edge, Brave, Vivaldi, Arc**, and **Opera**.
With the Browser Extension, you can:
- Intercept and modify network requests directly in your browser
-- Use the in-browser **Network Inspector** and **API Client**
+- Use the in-browser **Network Inspector**
- Capture rich debugging data (console logs, network logs, screen recordings)
- Connect with the Desktop App for enhanced capabilities like bulk mocking
@@ -22,14 +22,14 @@ With the Browser Extension, you can:
Click here to download
- the Requestly extension for your favorite browser.
+ the Requestly Interceptor extension for your favorite browser.
The extension uses your browser’s native network APIs, which means **no conflicts with VPNs or proxies** — and it runs seamlessly without installing any system-level tools.
### **Extension Popup**
-You can open the Requestly Extension popup by clicking its icon in the browser’s extensions list or top bar if pinned. We recommend pinning the Requestly Extension for quick access.
+You can open the Requestly Interceptor Extension popup by clicking its icon in the browser’s extensions list or top bar if pinned. We recommend pinning the Requestly Interceptor Extension for quick access.
-
- Start with API Testing if you want a quick first success.
+
+ Choose a path and complete setup for interception-focused workflows.
Learn how interception works inside the browser extension.
diff --git a/general/getting-started/quick-start-guide/desktop-app-setup.mdx b/general/getting-started/quick-start-guide/desktop-app-setup.mdx
index e44e3c5..327e136 100644
--- a/general/getting-started/quick-start-guide/desktop-app-setup.mdx
+++ b/general/getting-started/quick-start-guide/desktop-app-setup.mdx
@@ -6,7 +6,7 @@ visibility: "PUBLIC"
format: "MDX"
---
-The Requestly Desktop App is a powerful **network interceptor** designed for developers. Whether you're building, testing, or debugging, it gives you the tools to intercept, inspect, and modify both **requests and responses** across your entire system
+The Requestly Interceptor Desktop App is a powerful **network interceptor** designed for developers. Whether you're building, testing, or debugging, it gives you the tools to intercept, inspect, and modify both **requests and responses** across your entire system
It goes beyond what browser-based tools can offer by supporting full system-level traffic interception, making it perfect for debugging desktop apps, mobile simulators, and more.
@@ -59,7 +59,7 @@ If you only need browser-based interception and a lighter setup, start with the
- Learn how Requestly interception works across browsers, devices, and runtimes.
+ Learn how interception works across browsers, devices, and runtimes.
Record requests and responses you can analyze, replay, or share.
diff --git a/general/http-interceptor/browser-extension.mdx b/general/http-interceptor/browser-extension.mdx
index e0cecb8..e861b79 100644
--- a/general/http-interceptor/browser-extension.mdx
+++ b/general/http-interceptor/browser-extension.mdx
@@ -6,7 +6,7 @@ description: "Learn how to use Browser Extention to intercept HTTP Request and R
visibility: "PUBLIC"
---
-**Requestly’s browser extension** is the simplest way to intercept and modify HTTP requests and responses directly **within your browser**. It’s lightweight, easy to install, and perfect for debugging frontend issues or simulating API responses—without needing to run a local proxy or configure complex setups.
+**Requestly Interceptor’s browser extension** is the simplest way to intercept and modify HTTP requests and responses directly **within your browser**. It’s lightweight, easy to install, and perfect for debugging frontend issues or simulating API responses—without needing to run a local proxy or configure complex setups.
Whether you're a frontend developer testing new **API integrations** or a QA engineer simulating error scenarios, the browser extension gives you powerful tools right in your development environment.
@@ -33,7 +33,7 @@ Once the browser extension is installed, you can start intercepting traffic with
This guide walks you through launching a connected browser, viewing traffic in the network table, and verifying the proxy setup.
-[Requestly’s Browser Extension is a lightweight interceptor](/general/http-interceptor/browser-interception) that runs directly in your browser. It allows you to intercept, modify, and control both incoming responses and outgoing requests, making it a powerful tool for developers and testers.
+[Requestly Interceptor’s Browser Extension is a lightweight interceptor](/general/http-interceptor/browser-interception) that runs directly in your browser. It allows you to intercept, modify, and control both incoming responses and outgoing requests, making it a powerful tool for developers and testers.
## **Browser extension features**
@@ -48,14 +48,14 @@ Learn more about how to work with browser interceptor [here.](/general/http-inte
## Supported Browsers & Profiles
-Requestly supports all modern browsers, and you can use it with many browsers like Google Chrome, Firefox, and Safari. Here’s a breakdown of the browser support:
+Requestly Interceptor supports all modern browsers, and you can use it with many browsers like Google Chrome, Firefox, and Safari. Here’s a breakdown of the browser support:
- **Chromium-Based Browsers**
- Requestly is available on all Chrome-based browsers through the Chrome Web Store. This includes Google Chrome, Microsoft Edge, Brave, Opera, and others.
+ Requestly Interceptor is available on all Chrome-based browsers through the Chrome Web Store. This includes Google Chrome, Microsoft Edge, Brave, Opera, and others.
- **Firefox**
We officially support Firefox, ensuring a seamless experience for Firefox browser.
-- **Safari (API Client Only)**
+- **Safari (limited support)**
- The Requestly extension is available for Safari, but currently, it only supports the API Client. Support for HTTP rules will be available soon.
\ No newline at end of file
+ The Requestly Interceptor extension is available for Safari with a smaller feature set today. Full support for HTTP rules is coming soon.
\ No newline at end of file
diff --git a/general/http-interceptor/browser-extension/browser-interception.mdx b/general/http-interceptor/browser-extension/browser-interception.mdx
index f0f776c..99a4992 100644
--- a/general/http-interceptor/browser-extension/browser-interception.mdx
+++ b/general/http-interceptor/browser-extension/browser-interception.mdx
@@ -6,10 +6,10 @@ visibility: "PUBLIC"
format: "MDX"
---
-Once you’ve installed the Requestly browser extension, you can start intercepting, inspecting, and modifying HTTP(S) traffic directly in your browser. This feature is great for testing APIs, debugging frontend issues, and simulating server responses, without touching your backend or deploying changes.
+Once you’ve installed the Requestly Interceptor browser extension, you can start intercepting, inspecting, and modifying HTTP(S) traffic directly in your browser. This feature is great for testing APIs, debugging frontend issues, and simulating server responses, without touching your backend or deploying changes.
- This guide assumes you’ve already installed the [`Requestly browser extension`](https://requestly.com/downloads) for your browser. If not, start there.
+ This guide assumes you’ve already installed the [`Requestly Interceptor browser extension`](https://requestly.com/downloads) for your browser. If not, start there.
### Steps to Intercept traffic in Browser DevTools
@@ -24,8 +24,8 @@ Once you’ve installed the Requestly browser extension, you can start intercept
fullwidth="false"
/>
-
- Click on the **Requestly** tab.
+
+ Click on the **Requestly Interceptor** tab.
- If it is not visible, click on the **\>\>** button to expand the hidden tabs and then select **Requestly**
+ If it is not visible, click on the **\>\>** button to expand the hidden tabs and then select **Requestly Interceptor**
- If you want to intercept traffic from another browser extension, please use the [Requestly Desktop App](https://docs.requestly.com/general/http-interceptor/desktop-app#desktop-app) instead.
+ If you want to intercept traffic from another browser extension, please use the [Requestly Interceptor Desktop App](https://docs.requestly.com/general/http-interceptor/desktop-app#desktop-app) instead.
The **Network Traffic** tab displays a network table where all requests and responses from the webpage are listed. This tab provides debugging options such as:
@@ -74,7 +74,7 @@ Once open, this tab will list out all the requests made by your browser. Here, y
- **Delay Request**
- **Cancel Request**
- Clicking any of these buttons will take you to the Requestly dashboard with some parameters set, Here you can customize and apply your modifications.
+ Clicking any of these buttons will take you to the Requestly Interceptor dashboard with some parameters set, Here you can customize and apply your modifications.
diff --git a/general/http-interceptor/desktop-app.mdx b/general/http-interceptor/desktop-app.mdx
index 9afb93e..8d4dcd1 100644
--- a/general/http-interceptor/desktop-app.mdx
+++ b/general/http-interceptor/desktop-app.mdx
@@ -5,11 +5,11 @@ slug: desktop-app
description: ''
visibility: PUBLIC
---
-Requestly’s Desktop App is a powerful standalone interceptor that operates as a web proxy, giving you complete control over network traffic across all applications. It allows you to intercept, modify, and inspect both requests and responses, making it an essential tool for developers and testers working beyond the browser environment.
+Requestly Interceptor’s Desktop App is a powerful standalone interceptor that operates as a web proxy, giving you complete control over network traffic across all applications. It allows you to intercept, modify, and inspect both requests and responses, making it an essential tool for developers and testers working beyond the browser environment.
### Supported Platforms
-* [**Browsers**](/general/http-interceptor/desktop-app/browser-interception) - Configure Requestly with popular web browsers like Chrome, Firefox, Edge, etc
+* [**Browsers**](/general/http-interceptor/desktop-app/browser-interception) - Configure Requestly Interceptor with popular web browsers like Chrome, Firefox, Edge, etc
* [**Android devices**](/general/http-interceptor/desktop-app/android-devices) - Intercept Traffic from your Android smartphones and tablets.
@@ -17,10 +17,10 @@ Requestly’s Desktop App is a powerful standalone interceptor that operates as
* [**iOS Devices**](/general/http-interceptor/desktop-app/ios-devices-interception) - Set up your iPhones and iPads to intercept their traffic
-* [**iOS Emulator**](/general/http-interceptor/desktop-app/ios-simulator-interception) - Use Requestly with iOS simulators in Xcode.
+* [**iOS Emulator**](/general/http-interceptor/desktop-app/ios-simulator-interception) - Use Requestly Interceptor with iOS simulators in Xcode.
-* [**Node.js**](/general/http-interceptor/desktop-app/nodejs) - Integrate Requestly with Node.js applications to debug server-side network requests and responses during development or testing
+* [**Node.js**](/general/http-interceptor/desktop-app/nodejs) - Integrate Requestly Interceptor with Node.js applications to debug server-side network requests and responses during development or testing
-* [**Terminal**](/general/http-interceptor/desktop-app/terminal) - Use Requestly with command-line tools or scripts to intercept and manipulate HTTP requests for automation and debugging.
+* [**Terminal**](/general/http-interceptor/desktop-app/terminal) - Use Requestly Interceptor with command-line tools or scripts to intercept and manipulate HTTP requests for automation and debugging.
-* [**Systemwide proxy**](/general/http-interceptor/desktop-app/desktop-app-interception) - Configure Requestly as a systemwide proxy to capture and manipulate traffic across all applications and devices connected to your network.
+* [**Systemwide proxy**](/general/http-interceptor/desktop-app/desktop-app-interception) - Configure Requestly Interceptor as a systemwide proxy to capture and manipulate traffic across all applications and devices connected to your network.
diff --git a/general/http-interceptor/desktop-app/android-devices.mdx b/general/http-interceptor/desktop-app/android-devices.mdx
index 7f2974b..eab9b06 100644
--- a/general/http-interceptor/desktop-app/android-devices.mdx
+++ b/general/http-interceptor/desktop-app/android-devices.mdx
@@ -4,12 +4,12 @@ slug: "android-devices"
path: "/http-interceptor/desktop-app/android-devices"
visibility: "PUBLIC"
format: "MDX"
-description: "Learn how to set up Requestly to intercept, monitor, and debug HTTP requests on your Android devices for Android app development, debugging, and testing."
+description: "Learn how to set up Requestly Interceptor to intercept, monitor, and debug HTTP requests on your Android devices for Android app development, debugging, and testing."
---
***
-When working with Android apps, debugging HTTP Requests can be a challenge. Requestly provides an easy-to-use solution for everyone who needs to monitor, modify, or debug HTTP requests and responses during development or QA testing. This section outlines step-by-step instructions, guiding you on how to set up Requestly for your Android device.
+When working with Android apps, debugging HTTP Requests can be a challenge. Requestly Interceptor provides an easy-to-use solution for everyone who needs to monitor, modify, or debug HTTP requests and responses during development or QA testing. This section outlines step-by-step instructions, guiding you on how to set up Requestly Interceptor for your Android device.
By the end of this guide, you will have a fully functional interception setup tailored to your Android development needs.
@@ -25,11 +25,11 @@ If you have a rooted device the setup is straightforward -
- Use a USB cable to connect your device to your computer and launch the **Requestly Desktop App**.
+ Use a USB cable to connect your device to your computer and launch the **Requestly Interceptor Desktop App**.
- On the Requestly dashboard click **Connect Apps > Mobile Apps and Browser**, and Requestly will automatically list out detected devices. Simply click **Connect** to proceed. 🎉
+ On the Requestly Interceptor dashboard click **Connect Apps > Mobile Apps and Browser**, and Requestly Interceptor will automatically list out detected devices. Simply click **Connect** to proceed. 🎉
@@ -39,7 +39,7 @@ If you have a rooted device the setup is straightforward -
## Non Rooted Setup
-If your device is not rooted, you can manually setup Requestly by following these steps:
+If your device is not rooted, you can manually setup Requestly Interceptor by following these steps:
### Configure proxy
@@ -65,9 +65,9 @@ If your device is not rooted, you can manually setup Requestly by following thes
Input the following:
- * **Proxy Hostname:** Use the IP shown in the Requestly Desktop App (e.g., `192.168.1.10`).
+ * **Proxy Hostname:** Use the IP shown in the Requestly Interceptor Desktop App (e.g., `192.168.1.10`).
- * **Proxy Port:** Use the port displayed in the Requestly Desktop App (e.g., `8080`).
+ * **Proxy Port:** Use the port displayed in the Requestly Interceptor Desktop App (e.g., `8080`).
@@ -77,7 +77,7 @@ If your device is not rooted, you can manually setup Requestly by following thes
### Install CA Certificate
-To intercept HTTPS traffic, you also need to install Requestly's root CA certificate on your device:
+To intercept HTTPS traffic, you also need to install Requestly Interceptor's root CA certificate on your device:
@@ -148,7 +148,7 @@ Add these configs to your app codebase for it to work
## **Turn off Interception**
-Remember to disable the HTTP Proxy in your Settings when you stop using Requestly, otherwise, you'll get confusing network failures in your applications! You just need to set the network proxy(part 1) the next time you want to debug with Requestly.
+Remember to disable the HTTP Proxy in your Settings when you stop using Requestly Interceptor, otherwise, you'll get confusing network failures in your applications! You just need to set the network proxy(part 1) the next time you want to debug with Requestly Interceptor.
diff --git a/general/http-interceptor/desktop-app/android-simulator-interception.mdx b/general/http-interceptor/desktop-app/android-simulator-interception.mdx
index a5e0481..75ccfb1 100644
--- a/general/http-interceptor/desktop-app/android-simulator-interception.mdx
+++ b/general/http-interceptor/desktop-app/android-simulator-interception.mdx
@@ -4,12 +4,12 @@ slug: "android-simulator-interception"
path: "/http-interceptor/desktop-app/android-simulator-interception"
visibility: "PUBLIC"
format: "MDX"
-description: "Learn how to set up Requestly to intercept, monitor, and debug HTTP requests on your Android Simulator for Android app development and testing."
+description: "Learn how to set up Requestly Interceptor to intercept, monitor, and debug HTTP requests on your Android Simulator for Android app development and testing."
---
***
-When working with Android apps, debugging HTTP Requests can be a challenge. Requestly provides an easy-to-use solution for everyone who needs to monitor, modify, or debug HTTP requests and responses during development or QA testing. This section outlines step-by-step instructions, guiding you on how to set up Requestly for your Android emulator.
+When working with Android apps, debugging HTTP Requests can be a challenge. Requestly Interceptor provides an easy-to-use solution for everyone who needs to monitor, modify, or debug HTTP requests and responses during development or QA testing. This section outlines step-by-step instructions, guiding you on how to set up Requestly Interceptor for your Android emulator.
By the end of this guide, you will have a fully functional interception setup tailored to your Android development needs.
@@ -23,15 +23,15 @@ For a visual walkthrough, check out our YouTube video guide:
## Automatic Setup
-Requestly offers a one-click setup for Android emulators using Desktop App version **1.7.0+**. Here's how:
+Requestly Interceptor offers a one-click setup for Android emulators using Desktop App version **1.7.0+**. Here's how:
Ensure your emulator is up and running before proceeding
-
- Launch the Requestly desktop application on your computer.
+
+ Launch the Requestly Interceptor desktop application on your computer.
@@ -53,7 +53,7 @@ If you have ADB installed, you can skip the proxy setup through the emulator's U
adb shell settings put global http_proxy ":"
```
-Make sure to change the: in the above command to the one mentioned in the header of the Requestly desktop app
+Make sure to change the: in the above command to the one mentioned in the header of the Requestly Interceptor desktop app
Otherwise, follow these steps to configure the proxy manually:
@@ -77,9 +77,9 @@ Otherwise, follow these steps to configure the proxy manually:
- * **Proxy Hostname:** Use the IP shown in the Requestly Desktop App (e.g., `192.168.1.10`).
+ * **Proxy Hostname:** Use the IP shown in the Requestly Interceptor Desktop App (e.g., `192.168.1.10`).
- * **Proxy Port:** Use the port displayed in the Requestly Desktop App (e.g., `8080`).
+ * **Proxy Port:** Use the port displayed in the Requestly Interceptor Desktop App (e.g., `8080`).
@@ -89,13 +89,13 @@ Otherwise, follow these steps to configure the proxy manually:
## CA Certificate Installation
-To intercept HTTPS traffic, you need to install Requestly's root CA certificate on the emulator. You can do this in two ways:
+To intercept HTTPS traffic, you need to install Requestly Interceptor's root CA certificate on the emulator. You can do this in two ways:
**Option 1: From the Desktop:**
-
- * Open the Requestly Desktop App.
+
+ * Open the Requestly Interceptor Desktop App.
* Navigate to **Connect Apps > Others > Manual Setup > Save Certificate** to download the root CA certificate.
@@ -188,7 +188,7 @@ Add these configs to your app codebase for it to work
## **Deactivate Proxy (After done debugging)**
-Please make sure to revert the proxy after you are done testing using Requestly
+Please make sure to revert the proxy after you are done testing using Requestly Interceptor
```bash
adb shell settings put global http_proxy :0
@@ -214,9 +214,9 @@ Here's the code that makes this happen in a single click
2. On `Connect`
- 1. Root the device (To install Requestly CA)
+ 1. Root the device (To install Requestly Interceptor CA)
- 2. Inject Requestly CA (if not already)
+ 2. Inject Requestly Interceptor CA (if not already)
3. Setup Proxy on Emulator
diff --git a/general/http-interceptor/desktop-app/browser-interception.mdx b/general/http-interceptor/desktop-app/browser-interception.mdx
index f08e75c..901d9b5 100644
--- a/general/http-interceptor/desktop-app/browser-interception.mdx
+++ b/general/http-interceptor/desktop-app/browser-interception.mdx
@@ -6,7 +6,7 @@ visibility: "PUBLIC"
format: "MDX"
---
-Requestly desktop app allows you to connect multiple browsers, making it easy to configure and switch between them for network interception.
+Requestly Interceptor desktop app allows you to connect multiple browsers, making it easy to configure and switch between them for network interception.
To connect browser instance, open the **Connect Panel**, follow these steps:
@@ -20,27 +20,27 @@ To connect browser instance, open the **Connect Panel**, follow these steps:
- This will open the **Connect Panel**, displaying all supported browsers on your system, along with other sources that Requestly supports.
+ This will open the **Connect Panel**, displaying all supported browsers on your system, along with other sources that Requestly Interceptor supports.
-
- Select your preferred browser from the Connect Panel and click **Launch/Open**. This will start a new browser instance configured with the Requestly proxy.
+
+ Select your preferred browser from the Connect Panel and click **Launch/Open**. This will start a new browser instance configured with the Requestly Interceptor proxy.
- 1. For Chromium-based browsers, Requestly applies the `--proxy-server` flag, configuring the browser to route all network traffic through the Requestly proxy server
+ 1. For Chromium-based browsers, Requestly Interceptor applies the `--proxy-server` flag, configuring the browser to route all network traffic through the Requestly Interceptor proxy server
2. Then requestly automatically installs CA certificate to your system’s certificate store.
- The newly launched browser instance will automatically open [amiusing.requestly.io](https://amiusing.requestly.io/). A success message on this page confirms that the browser is using Requestly’s proxy.
+ The newly launched browser instance will automatically open [amiusing.requestly.io](https://amiusing.requestly.io/). A success message on this page confirms that the browser is using Requestly Interceptor’s proxy.
- Return to the Requestly dashboard to review all captured network traffic in the Network table.
+ Return to the Requestly Interceptor dashboard to review all captured network traffic in the Network table.
@@ -48,7 +48,7 @@ To connect browser instance, open the **Connect Panel**, follow these steps:
## Supported Browsers & Profiles
-The **Connect Panel** shows a list of browsers that Requestly supports. You can select from various profiles for browsers such as Google Chrome, Firefox, and Safari. Here are the details of each browser and its profile options:
+The **Connect Panel** shows a list of browsers that Requestly Interceptor supports. You can select from various profiles for browsers such as Google Chrome, Firefox, and Safari. Here are the details of each browser and its profile options:
* **Google Chrome (New Profile)**:
@@ -64,21 +64,21 @@ The **Connect Panel** shows a list of browsers that Requestly supports. You can
* **Arc**:
- Arc is another modern browser supported by Requestly. You can create a new profile or use an existing one.
+ Arc is another modern browser supported by Requestly Interceptor. You can create a new profile or use an existing one.
* **Safari**:
Connect to the Safari browser, clicking the connect button will open a new Safari window.
- When you launch Safari from Requestly, it sets a system-wide proxy due to technical constraints. Make sure to turn it off after done debugging
+ When you launch Safari from Requestly Interceptor, it sets a system-wide proxy due to technical constraints. Make sure to turn it off after done debugging
-For other browsers, find the proxy IP and port at the top of Requestly’s dashboard and refer to your browser's documentation to configure proxy settings.
+For other browsers, find the proxy IP and port at the top of Requestly Interceptor’s dashboard and refer to your browser's documentation to configure proxy settings.
## **Connect existing browser profile**
-You can connect your existing browser profile to the desktop app using the [**Requestly extension**](https://requestly.com/downloads/)**.**
+You can connect your existing browser profile to the desktop app using the [**Requestly Interceptor extension**](https://requestly.com/downloads/)**.**
Available on desktop app version >=1.7.4
@@ -90,7 +90,7 @@ You can connect your existing browser profile to the desktop app using the [**Re
1. Launch the desktop app
-2. Open the Requestly extension popup in the browser profile you want to connect.
+2. Open the Requestly Interceptor extension popup in the browser profile you want to connect.
@@ -104,7 +104,7 @@ With this method, you can easily link your current browser profile to the deskto
## Custom Browser Launch Options
-Requestly offers **custom browser launch options** for certain browsers, specifically Chromium-based ones. These options allow you to tweak the behavior of the browser during interception.
+Requestly Interceptor offers **custom browser launch options** for certain browsers, specifically Chromium-based ones. These options allow you to tweak the behavior of the browser during interception.
Use the buttons next to the browser selection to customize the launch options. Here's a quick rundown of the **preset configurations**:
diff --git a/general/http-interceptor/desktop-app/desktop-app-interception.mdx b/general/http-interceptor/desktop-app/desktop-app-interception.mdx
index c7882ab..04ff464 100644
--- a/general/http-interceptor/desktop-app/desktop-app-interception.mdx
+++ b/general/http-interceptor/desktop-app/desktop-app-interception.mdx
@@ -4,7 +4,7 @@ slug: "desktop-app-interception"
path: "/http-interceptor/desktop-app/desktop-app-interception"
visibility: "PUBLIC"
format: "MDX"
-description: "Learn how to set up and manage a system-wide proxy with Requestly to intercept and debug network requests across all applications."
+description: "Learn how to set up and manage a system-wide proxy with Requestly Interceptor to intercept and debug network requests across all applications."
---
***
@@ -12,26 +12,26 @@ description: "Learn how to set up and manage a system-wide proxy with Requestly
Setting up a system-wide proxy allows you to intercept and debug network requests from all applications on your computer, not just your browser. This is particularly useful in situations where an application-level proxy setup is not available.
- This feature is only available in the **Requestly Desktop App**. Ensure you are using the desktop version to proceed with these steps.
+ This feature is only available in the **Requestly Interceptor Desktop App**. Ensure you are using the desktop version to proceed with these steps.
## Setting Up System-Wide Proxy
- Open the Requestly desktop app and click the **Connect App** button at the top to view the sources you can intercept.
+ Open the Requestly Interceptor desktop app and click the **Connect App** button at the top to view the sources you can intercept.
- From the displayed sources, select **Enable Requestly system-wide** to enable traffic interception across all applications on your device.
+ From the displayed sources, select **Enable Requestly Interceptor system-wide** to enable traffic interception across all applications on your device.
- The first time you select this option, you’ll be prompted to enter your system password. This step allows Requestly to add its CA certificate to your system, making it possible to modify HTTPS requests.
+ The first time you select this option, you’ll be prompted to enter your system password. This step allows Requestly Interceptor to add its CA certificate to your system, making it possible to modify HTTPS requests.
@@ -45,17 +45,17 @@ Setting up a system-wide proxy allows you to intercept and debug network request
## Turn Off System-Wide Proxy
-To disable the system-wide proxy, go to the **Connect App** section in the Requestly Desktop App and click on the **Disconnect** option to turn it off. This will stop intercepting traffic across your system.
+To disable the system-wide proxy, go to the **Connect App** section in the Requestly Interceptor Desktop App and click on the **Disconnect** option to turn it off. This will stop intercepting traffic across your system.
### Filtering by App and Domain
-Requestly makes it easy to organize and focus on specific network traffic:
+Requestly Interceptor makes it easy to organize and focus on specific network traffic:
-Requestly provides two dropdowns in the **Network Inspector's** left sidebar for easy filtering:
+Requestly Interceptor provides two dropdowns in the **Network Inspector's** left sidebar for easy filtering:
* **Apps Dropdown**:
diff --git a/general/http-interceptor/desktop-app/ios-devices-interception.mdx b/general/http-interceptor/desktop-app/ios-devices-interception.mdx
index 0ace331..b4b2783 100644
--- a/general/http-interceptor/desktop-app/ios-devices-interception.mdx
+++ b/general/http-interceptor/desktop-app/ios-devices-interception.mdx
@@ -4,12 +4,12 @@ slug: "ios-devices-interception"
path: "/http-interceptor/desktop-app/ios-devices-interception"
visibility: "PUBLIC"
format: "MDX"
-description: "Learn how to set up Requestly to intercept, monitor, and debug HTTP requests on your iOS Apps for iOS app development, debugging, and testing."
+description: "Learn how to set up Requestly Interceptor to intercept, monitor, and debug HTTP requests on your iOS Apps for iOS app development, debugging, and testing."
---
***
-When working with iOS apps, debugging HTTP requests can be challenging. Requestly offers an easy-to-use solution for monitoring, modifying, and debugging HTTP requests and responses during development or QA testing. Once you're familiar with the [HTTP Interceptor and network table](/general/http-interceptor/overview), you can follow step-by-step instructions to set up Requestly for intercepting network traffic on your iOS devices, ensuring a fully functional interception setup for your iOS app development needs.
+When working with iOS apps, debugging HTTP requests can be challenging. Requestly Interceptor offers an easy-to-use solution for monitoring, modifying, and debugging HTTP requests and responses during development or QA testing. Once you're familiar with the [HTTP Interceptor and network table](/general/http-interceptor/overview), you can follow step-by-step instructions to set up Requestly Interceptor for intercepting network traffic on your iOS devices, ensuring a fully functional interception setup for your iOS app development needs.
iOS device interception is only supported on the Desktop App.
@@ -40,7 +40,7 @@ Setting up HTTP interception on physical iOS devices requires configuring a prox
- Set the proxy settings to `Manual`. Then, enter the IP address of the computer and the proxy port. You can find these on the top banner of the Requestly desktop app.
+ Set the proxy settings to `Manual`. Then, enter the IP address of the computer and the proxy port. You can find these on the top banner of the Requestly Interceptor desktop app.
@@ -56,7 +56,7 @@ Setting up HTTP interception on physical iOS devices requires configuring a prox
- Now open Safari on your IOS device and go to [**http://requestly.io/ssl**](http://requestly.io/ssl)**(remember to use HTTP, not HTTPS)**. This should download a custom profile on your device which contains the Requestly CA certificate.
+ Now open Safari on your IOS device and go to [**http://requestly.io/ssl**](http://requestly.io/ssl)**(remember to use HTTP, not HTTPS)**. This should download a custom profile on your device which contains the Requestly Interceptor CA certificate.
@@ -66,7 +66,7 @@ Setting up HTTP interception on physical iOS devices requires configuring a prox
- Finally, you need to enable trust for CA certificates that were installed along with this custom profile. Go to `Settings` → `General` → `About` → `Certificate Trust Settings`. You should see a certificate under the name RQProxyCA. Enable the trust for Requestly's certificate authority for intercepting HTTPS traffic.
+ Finally, you need to enable trust for CA certificates that were installed along with this custom profile. Go to `Settings` → `General` → `About` → `Certificate Trust Settings`. You should see a certificate under the name RQProxyCA. Enable the trust for Requestly Interceptor's certificate authority for intercepting HTTPS traffic.
@@ -78,7 +78,7 @@ Setting up HTTP interception on physical iOS devices requires configuring a prox
## **Turn off Interception**
-Remember to disable the HTTP Proxy in your Settings when you stop using Requestly, otherwise, you'll get confusing network failures in your applications! You just need to set the network proxy(part 1) the next time you want to debug with Requestly.
+Remember to disable the HTTP Proxy in your Settings when you stop using Requestly Interceptor, otherwise, you'll get confusing network failures in your applications! You just need to set the network proxy(part 1) the next time you want to debug with Requestly Interceptor.
1. Navigate to `Settings` → `Wi-Fi` → `Select current Wi-Fi` → `Configure Proxy`
diff --git a/general/http-interceptor/desktop-app/ios-simulator-interception.mdx b/general/http-interceptor/desktop-app/ios-simulator-interception.mdx
index 4d4d44d..517fb4d 100644
--- a/general/http-interceptor/desktop-app/ios-simulator-interception.mdx
+++ b/general/http-interceptor/desktop-app/ios-simulator-interception.mdx
@@ -4,12 +4,12 @@ slug: "ios-simulator-interception"
path: "/http-interceptor/desktop-app/ios-simulator-interception"
visibility: "PUBLIC"
format: "MDX"
-description: "Learn how to set up Requestly to intercept, monitor, and debug HTTP requests on your iOS Simulator for iOS app development and testing."
+description: "Learn how to set up Requestly Interceptor to intercept, monitor, and debug HTTP requests on your iOS Simulator for iOS app development and testing."
---
***
-When working with iOS apps, debugging HTTP requests can be challenging. Requestly offers an easy-to-use solution for monitoring, modifying, and debugging HTTP requests and responses during development or QA testing. Once you're familiar with the HTTP Interceptor and network table, you can follow step-by-step instructions to set up Requestly for intercepting network traffic on your iOS Simulator, ensuring a fully functional interception setup for your iOS app development needs.
+When working with iOS apps, debugging HTTP requests can be challenging. Requestly Interceptor offers an easy-to-use solution for monitoring, modifying, and debugging HTTP requests and responses during development or QA testing. Once you're familiar with the HTTP Interceptor and network table, you can follow step-by-step instructions to set up Requestly Interceptor for intercepting network traffic on your iOS Simulator, ensuring a fully functional interception setup for your iOS app development needs.
iOS Simulator interception is only supported on the Desktop App.
@@ -17,7 +17,7 @@ When working with iOS apps, debugging HTTP requests can be challenging. Requestl
## **Setup iOS Simulator for Interception**
-The **iOS Simulator** is a virtual device that runs on a Mac desktop or laptop, and its proxy setup for HTTP interception is similar to that of a physical device. Since the simulator runs locally on your Mac, Requestly offers an added advantage by enabling a seamless, **one-click setup** for interception.
+The **iOS Simulator** is a virtual device that runs on a Mac desktop or laptop, and its proxy setup for HTTP interception is similar to that of a physical device. Since the simulator runs locally on your Mac, Requestly Interceptor offers an added advantage by enabling a seamless, **one-click setup** for interception.
### One-click Simulator Setup for Interception
@@ -27,7 +27,7 @@ The **iOS Simulator** is a virtual device that runs on a Mac desktop or laptop,
Make sure the simulator is running before proceeding.
-**Step 2**: In Requestly Desktop App, open **Connect Apps** Panel, switch to **Mobile apps & browsers** tab, and click **Refresh Device**. This will display all currently running simulators.
+**Step 2**: In Requestly Interceptor Desktop App, open **Connect Apps** Panel, switch to **Mobile apps & browsers** tab, and click **Refresh Device**. This will display all currently running simulators.
@@ -45,7 +45,7 @@ The **iOS Simulator** is a virtual device that runs on a Mac desktop or laptop,
### Troubleshooting
-#### Simulator Not Listed in Requestly?
+#### Simulator Not Listed in Requestly Interceptor?
If you do not see your simulator listed after refreshing, follow these steps:
@@ -66,5 +66,5 @@ If you do not see your simulator listed after refreshing, follow these steps:
This command ensures that the correct Xcode installation is selected.
-
+
diff --git a/general/http-interceptor/desktop-app/network-table.mdx b/general/http-interceptor/desktop-app/network-table.mdx
index 7582acc..4c76846 100644
--- a/general/http-interceptor/desktop-app/network-table.mdx
+++ b/general/http-interceptor/desktop-app/network-table.mdx
@@ -6,7 +6,7 @@ visibility: "PUBLIC"
format: "MDX"
---
-The **Network Table** is the heart of Requestly’s Desktop App; here you can monitor, inspect, and manage all intercepted network traffic. It’s packed with powerful features to help you debug with ease. Here's a quick overview of its key components:
+The **Network Table** is the heart of Requestly Interceptor’s Desktop App; here you can monitor, inspect, and manage all intercepted network traffic. It’s packed with powerful features to help you debug with ease. Here's a quick overview of its key components:
@@ -40,11 +40,11 @@ Use the filter option to find a set of particular requests from hundreds of inte
## Network Modification
-One of Requestly’s most powerful capabilities is **network modification**, allowing you to dynamically alter requests and responses in real time. This feature helps in debugging, testing, and even bypassing certain network constraints. Here’s how you can modify network traffic:
+One of Requestly Interceptor’s most powerful capabilities is **network modification**, allowing you to dynamically alter requests and responses in real time. This feature helps in debugging, testing, and even bypassing certain network constraints. Here’s how you can modify network traffic:
- Right-click on any network request in the Requestly Network Interceptor.
+ Right-click on any network request in the Network Traffic table.
@@ -66,7 +66,7 @@ One of Requestly’s most powerful capabilities is **network modification**, al
### Testing Modification
-Now, when the same request is triggered again, the request will be highlighted. This indicates that the Requestly Rule is applied to the request.
+Now, when the same request is triggered again, the request will be highlighted. This indicates that the Requestly Interceptor Rule is applied to the request.
diff --git a/general/http-interceptor/desktop-app/nodejs.mdx b/general/http-interceptor/desktop-app/nodejs.mdx
index 9f99b09..c7e13c4 100644
--- a/general/http-interceptor/desktop-app/nodejs.mdx
+++ b/general/http-interceptor/desktop-app/nodejs.mdx
@@ -4,14 +4,14 @@ slug: "nodejs"
path: "/http-interceptor/desktop-app/nodejs"
visibility: "PUBLIC"
format: "MDX"
-description: "Learn How to Set Up Requestly Proxy in Your Node.js Application"
+description: "Learn How to Set Up Requestly Interceptor Proxy in Your Node.js Application"
---
## **Steps**
- Go to the **Requestly desktop** **app** and click on the **Connect apps** button. A popup modal will appear.
+ Go to the **Requestly Interceptor desktop** **app** and click on the **Connect apps** button. A popup modal will appear.
@@ -37,7 +37,7 @@ description: "Learn How to Set Up Requestly Proxy in Your Node.js Application"
Open the terminal where you will start your **Node.js server** and paste the copied command. Press **Enter** to execute it.
- If the command runs successfully, you should see a confirmation message in your terminal indicating that **Requestly interception is enabled**.
+ If the command runs successfully, you should see a confirmation message in your terminal indicating that **interception is enabled**.
@@ -49,8 +49,8 @@ description: "Learn How to Set Up Requestly Proxy in Your Node.js Application"
## **Testing Proxy**
-1. Go to `Network Traffic` tab in Requestly Desktop App.
+1. Go to `Network Traffic` tab in Requestly Interceptor Desktop App.
-2) Now Make a curl request to [**https://amiusing.requestly.io/**](https://amiusing.requestly.io/) using your terminal and look for that request in the Requestly Network Interceptor.
+2) Now Make a curl request to [**https://amiusing.requestly.io/**](https://amiusing.requestly.io/) using your terminal and look for that request in the **Network Traffic** tab.
diff --git a/general/http-interceptor/desktop-app/terminal.mdx b/general/http-interceptor/desktop-app/terminal.mdx
index 82f8665..8cc9c03 100644
--- a/general/http-interceptor/desktop-app/terminal.mdx
+++ b/general/http-interceptor/desktop-app/terminal.mdx
@@ -4,14 +4,14 @@ slug: "terminal"
path: "/http-interceptor/desktop-app/terminal"
visibility: "PUBLIC"
format: "MDX"
-description: "Learn how to set up the Requestly proxy in the terminal to intercept and modify terminal requests effortlessly."
+description: "Learn how to set up the Requestly Interceptor proxy in the terminal to intercept and modify terminal requests effortlessly."
---
## **Steps**
- Go to the **Requestly desktop** **app** and click on the **Connect apps** button. A popup modal will appear.
+ Go to the **Requestly Interceptor desktop** **app** and click on the **Connect apps** button. A popup modal will appear.
@@ -37,7 +37,7 @@ description: "Learn how to set up the Requestly proxy in the terminal to interce
Open the terminal where you will start your **Node.js server** and paste the copied command. Press **Enter** to execute it.
- If the command runs successfully, you should see a confirmation message in your terminal indicating that **Requestly interception is enabled**.
+ If the command runs successfully, you should see a confirmation message in your terminal indicating that **interception is enabled**.
@@ -45,9 +45,9 @@ description: "Learn how to set up the Requestly proxy in the terminal to interce
## **Testing Proxy**
-1. Go to `Network Traffic` tab in Requestly Desktop App.
+1. Go to `Network Traffic` tab in Requestly Interceptor Desktop App.
-2) Now Make a curl request to [**https://amiusing.requestly.io/**](https://amiusing.requestly.io/) using your terminal and look for that request in the Requestly Network Interceptor.
+2) Now Make a curl request to [**https://amiusing.requestly.io/**](https://amiusing.requestly.io/) using your terminal and look for that request in the **Network Traffic** tab.
```plaintext
curl https://amiusing.requestly.io/
diff --git a/general/http-interceptor/overview.mdx b/general/http-interceptor/overview.mdx
index 7a4e3d6..767f7bb 100644
--- a/general/http-interceptor/overview.mdx
+++ b/general/http-interceptor/overview.mdx
@@ -5,7 +5,7 @@ slug: overview
description: >-
Learn when to use HTTP Interceptor, choose the right interception setup, and debug traffic across browsers, devices, and runtimes.
seoDescription: >-
- Debug HTTP traffic in real time with Requestly HTTP Interceptor for browsers, mobile devices, emulators, Node.js, terminal tools, and system-wide setups.
+ Debug HTTP traffic in real time with Requestly Interceptor for browsers, mobile devices, emulators, Node.js, terminal tools, and system-wide setups.
visibility: PUBLIC
---
HTTP Interceptor helps you inspect and debug real network traffic. Use it when you need to see what your browser, app, device, or runtime is actually sending and receiving.
@@ -19,7 +19,7 @@ Use HTTP Interceptor when you want to:
- verify whether an issue is in the client, proxy, or backend
- capture traffic for sessions, HAR analysis, or later mocking
-If you already know exactly how you want to change traffic, go to [HTTP Rules](/general/http-rules/overview). If you want to test APIs manually, start with [API Client](/general/api-client/overview).
+If you already know exactly how you want to change traffic, go to [HTTP Rules](/general/http-rules/overview).
## Choose Your Interception Setup
@@ -39,7 +39,7 @@ If you already know exactly how you want to change traffic, go to [HTTP Rules](/
Use the Browser Extension for browser-based traffic. Use the Desktop App when you need proxy-based interception outside the browser.
- Follow one setup path and make sure the browser, device, or runtime is correctly connected to Requestly.
+ Follow one setup path and make sure the browser, device, or runtime is correctly connected to Requestly Interceptor.
Open the [network table](/general/http-interceptor/desktop-app/network-table) or browser interception view and verify requests appear before moving on to rules or mocks.
@@ -79,7 +79,7 @@ If you already know exactly how you want to change traffic, go to [HTTP Rules](/
Save traffic and debugging context for sharing, replaying, or mock creation.
- Analyze previously captured network data inside Requestly.
+ Analyze previously captured network data inside Requestly Interceptor.
Use the troubleshooting path for certificate, localhost, proxy, or device issues.
diff --git a/general/http-rules/advanced-usage.mdx b/general/http-rules/advanced-usage.mdx
index 7010fc3..f0c29b2 100644
--- a/general/http-rules/advanced-usage.mdx
+++ b/general/http-rules/advanced-usage.mdx
@@ -4,7 +4,7 @@ label: Advanced Usage
slug: advanced-usage
visibility: PUBLIC
---
-Learn about advance features of Requestly, designed to help you optimize your workflows and enhance productivity. Below, you'll find an overview of key advanced features, each linking to a detailed page for further exploration. Click on a card to learn more.
+Learn about advance features of Requestly Interceptor, designed to help you optimize your workflows and enhance productivity. Below, you'll find an overview of key advanced features, each linking to a detailed page for further exploration. Click on a card to learn more.
@@ -31,12 +31,12 @@ Learn about advance features of Requestly, designed to help you optimize your wo
**Store and share data dynamically across rules.** Use $sharedState for conditional edits, data aggregation, and token handling.
-
- **Toggle Requestly on demand.** Easily pause or resume all rules to suit your workflow.
+
+ **Toggle Requestly Interceptor on demand.** Easily pause or resume all rules to suit your workflow.
- **Keep rule statuses consistent across devices.** Ensure your rules stay in sync, no matter where you use Requestly.
+ **Keep rule statuses consistent across devices.** Ensure your rules stay in sync, no matter where you use Requestly Interceptor.
diff --git a/general/http-rules/advanced-usage/graphql-modify-request-response.mdx b/general/http-rules/advanced-usage/graphql-modify-request-response.mdx
index a807cc9..92df165 100644
--- a/general/http-rules/advanced-usage/graphql-modify-request-response.mdx
+++ b/general/http-rules/advanced-usage/graphql-modify-request-response.mdx
@@ -4,12 +4,12 @@ slug: "graphql-modify-request-response"
path: "/http-rules/advanced-usage/graphql-modify-request-response"
visibility: "PUBLIC"
format: "MDX"
-description: "Learn to modify GraphQL API requests and responses using Requestly to debug and test GraphQL APIs."
+description: "Learn to modify GraphQL API requests and responses using Requestly Interceptor to debug and test GraphQL APIs."
---
***
-Unlike REST APIs, GraphQL APIs provide a flexible approach to querying and mutating data through a single endpoint. They allow clients to specify exactly what data is needed, reducing over-fetching and under-fetching issues common with REST APIs. GraphQL APIs can be modified to customize requests and responses for testing and debugging. This guide provides detailed steps to achieve this using Requestly.
+Unlike REST APIs, GraphQL APIs provide a flexible approach to querying and mutating data through a single endpoint. They allow clients to specify exactly what data is needed, reducing over-fetching and under-fetching issues common with REST APIs. GraphQL APIs can be modified to customize requests and responses for testing and debugging. This guide provides detailed steps to achieve this using Requestly Interceptor.
## Modifying GraphQL Responses
@@ -121,7 +121,7 @@ function modifyResponse(args) {
const { url, response, requestData, responseJSON } = args;
if (requestData.query?.includes("query getUsers")) {
- console.log("Requestly: Modifying response", { query: requestData.query });
+ console.log("Requestly Interceptor: Modifying response", { query: requestData.query });
return { ...responseJSON, custom: true };
}
diff --git a/general/http-rules/advanced-usage/grouping.mdx b/general/http-rules/advanced-usage/grouping.mdx
index 97609e3..c7eebf2 100644
--- a/general/http-rules/advanced-usage/grouping.mdx
+++ b/general/http-rules/advanced-usage/grouping.mdx
@@ -4,20 +4,20 @@ slug: "grouping"
path: "/http-rules/advanced-usage/grouping"
visibility: "PUBLIC"
format: "MDX"
-description: "Learn how to organize and manage Requestly rules efficiently by grouping them for easier management and toggle status."
+description: "Learn how to organize and manage Requestly Interceptor rules efficiently by grouping them for easier management and toggle status."
---
***
-Requestly offers ten distinct types of rules that allow you to override default network request behaviors in a webpage. As the number of rules increases, managing them individually can become cumbersome. To address this, Requestly provides the ability to organize these rules into logical groups, enabling you to enable or disable them as a set.
+Requestly Interceptor offers ten distinct types of rules that allow you to override default network request behaviors in a webpage. As the number of rules increases, managing them individually can become cumbersome. To address this, Requestly Interceptor provides the ability to organize these rules into logical groups, enabling you to enable or disable them as a set.
### Creating a New Group
-To create a new group in Requestly, follow these steps:
+To create a new group in Requestly Interceptor, follow these steps:
- Navigate to the Requestly Dashboard and open HTTP Rules.
+ Navigate to the Requestly Interceptor Dashboard and open HTTP Rules.
diff --git a/general/http-rules/advanced-usage/multiple-conditions-in-a-single-rule-in-requestly.mdx b/general/http-rules/advanced-usage/multiple-conditions-in-a-single-rule-in-requestly.mdx
index 0c1871c..d6fc88c 100644
--- a/general/http-rules/advanced-usage/multiple-conditions-in-a-single-rule-in-requestly.mdx
+++ b/general/http-rules/advanced-usage/multiple-conditions-in-a-single-rule-in-requestly.mdx
@@ -1,17 +1,17 @@
---
-title: "Multiple Conditions in a Single Rule in Requestly"
+title: "Multiple Conditions in a Single Rule in Requestly Interceptor"
slug: "multiple-conditions-in-a-single-rule-in-requestly"
path: "/http-rules/advanced-usage/multiple-conditions-in-a-single-rule-in-requestly"
visibility: "PUBLIC"
format: "MDX"
-description: "Learn how to define and use multiple conditions in a single rule in Requestly to optimise rule management."
+description: "Learn how to define and use multiple conditions in a single rule in Requestly Interceptor to optimise rule management."
---
-Requestly allows users to define **multiple conditions within a single rule**, making request modifications easier. Instead of creating separate rules for each scenario, you can configure a single rule to handle multiple actions, targeting multiple URLs at once in a single rule.
+Requestly Interceptor allows users to define **multiple conditions within a single rule**, making request modifications easier. Instead of creating separate rules for each scenario, you can configure a single rule to handle multiple actions, targeting multiple URLs at once in a single rule.
### How Multiple Conditions Work
-Requestly evaluates multiple conditions within a single rule independently. If a condition matches, the corresponding action is executed. This allows users to apply different modifications without needing separate rules for each case.
+Requestly Interceptor evaluates multiple conditions within a single rule independently. If a condition matches, the corresponding action is executed. This allows users to apply different modifications without needing separate rules for each case.
### Why to use Multiple Conditions in a Single Rule?
@@ -19,7 +19,7 @@ Using multiple conditions in a single rule makes your workspace cleaner and more
### Redirect Rule
-The **Redirect Rule** in Requestly allows users to define multiple conditions within a single rule, enabling different URLs to be redirected to different destinations. Instead of creating separate redirect rules for each URL, you can consolidate multiple redirections into one rule for better organization and efficiency.
+The **Redirect Rule** in Requestly Interceptor allows users to define multiple conditions within a single rule, enabling different URLs to be redirected to different destinations. Instead of creating separate redirect rules for each URL, you can consolidate multiple redirections into one rule for better organization and efficiency.
@@ -31,7 +31,7 @@ The **Redirect Rule** in Requestly allows users to define multiple conditions wi
### Replace Rule
-The **Replace Rule** in Requestly allows users to define multiple conditions within a single rule to modify different parts of a URL dynamically. Instead of creating separate replace rules for different replacements, you can manage them all in one rule, ensuring efficient and flexible URL transformations.
+The **Replace Rule** in Requestly Interceptor allows users to define multiple conditions within a single rule to modify different parts of a URL dynamically. Instead of creating separate replace rules for different replacements, you can manage them all in one rule, ensuring efficient and flexible URL transformations.
@@ -43,7 +43,7 @@ The **Replace Rule** in Requestly allows users to define multiple conditions wit
### Query Param Rule
-The **Query Param Rule** in Requestly allows users to define multiple conditions within a single rule to modify query parameters in different URLs. Instead of manually appending, updating, or removing query parameters in multiple rules, you can consolidate all changes into one rule .
+The **Query Param Rule** in Requestly Interceptor allows users to define multiple conditions within a single rule to modify query parameters in different URLs. Instead of manually appending, updating, or removing query parameters in multiple rules, you can consolidate all changes into one rule .
@@ -55,7 +55,7 @@ The **Query Param Rule** in Requestly allows users to define multiple conditions
### Modify Headers Rule
-The **Modify Headers Rule** in Requestly allows users to define multiple conditions within a single rule to **add, modify, or remove HTTP headers** across different URLs. Instead of creating multiple rules for different header modifications, you can consolidate them into one rule, ensuring efficiency and better rule management.
+The **Modify Headers Rule** in Requestly Interceptor allows users to define multiple conditions within a single rule to **add, modify, or remove HTTP headers** across different URLs. Instead of creating multiple rules for different header modifications, you can consolidate them into one rule, ensuring efficiency and better rule management.
@@ -67,7 +67,7 @@ The **Modify Headers Rule** in Requestly allows users to define multiple conditi
### Modify User Agent
-The **Modify User Agent Rule** in Requestly allows users to define multiple conditions within a single rule to **modify the User-Agent header** for different URLs. This is particularly useful for testing how a website behaves across different browsers, devices, and platforms without needing to use actual devices or browser extensions.
+The **Modify User Agent Rule** in Requestly Interceptor allows users to define multiple conditions within a single rule to **modify the User-Agent header** for different URLs. This is particularly useful for testing how a website behaves across different browsers, devices, and platforms without needing to use actual devices or browser extensions.
@@ -81,7 +81,7 @@ The **Modify User Agent Rule** in Requestly allows users to define multiple cond
### Cancel Request Rule
-The **Cancel Request Rule** in Requestly allows users to define multiple conditions within a single rule to **block specific requests** based on different URLs. This is useful for preventing unnecessary or harmful requests, improving performance, and ensuring a cleaner browsing or testing environment.
+The **Cancel Request Rule** in Requestly Interceptor allows users to define multiple conditions within a single rule to **block specific requests** based on different URLs. This is useful for preventing unnecessary or harmful requests, improving performance, and ensuring a cleaner browsing or testing environment.
@@ -95,7 +95,7 @@ The **Cancel Request Rule** in Requestly allows users to define multiple conditi
### Delay Network Request Rule
-The **Delay Network Request Rule** in Requestly allows users to define multiple conditions within a single rule to **artificially delay specific requests**. This is useful for testing how applications behave under slow network conditions or simulating real-world latency issues.
+The **Delay Network Request Rule** in Requestly Interceptor allows users to define multiple conditions within a single rule to **artificially delay specific requests**. This is useful for testing how applications behave under slow network conditions or simulating real-world latency issues.
@@ -139,4 +139,4 @@ Insert Script rule allows you to insert multiple scripts and styles on a single
* **Avoid Blocking UI:** Large scripts should be loaded asynchronously when possible.
-* **Test in Requestly:** Use the **Test Rule** feature to ensure scripts load in the right sequence.
+* **Test in Requestly Interceptor:** Use the **Test Rule** feature to ensure scripts load in the right sequence.
diff --git a/general/http-rules/advanced-usage/pauseresume-requestly.mdx b/general/http-rules/advanced-usage/pauseresume-requestly.mdx
index 1a858ac..6320e25 100644
--- a/general/http-rules/advanced-usage/pauseresume-requestly.mdx
+++ b/general/http-rules/advanced-usage/pauseresume-requestly.mdx
@@ -1,52 +1,52 @@
---
-title: "Pause/Resume Requestly"
+title: "Pause/Resume Requestly Interceptor"
slug: "pauseresume-requestly"
path: "/http-rules/advanced-usage/pauseresume-requestly"
visibility: "PUBLIC"
format: "MDX"
-description: "Learn how to temporarily pause and resume Requestly rules to test your website’s original behavior without interference."
+description: "Learn how to temporarily pause and resume Requestly Interceptor rules to test your website’s original behavior without interference."
---
***
-Requestly provides an easy way to intercept and modify web requests, but there are instances when you might want to pause its functionality temporarily. This document outlines how to pause and resume Requestly to test your website's original behavior without interference from active Requestly rules.
+Requestly Interceptor provides an easy way to intercept and modify web requests, but there are instances when you might want to pause its functionality temporarily. This document outlines how to pause and resume Requestly Interceptor to test your website's original behavior without interference from active Requestly Interceptor rules.
-## Pausing Requestly
+## Pausing Requestly Interceptor
-To temporarily stop Requestly from intercepting and modifying web requests, follow these steps:
+To temporarily stop Requestly Interceptor from intercepting and modifying web requests, follow these steps:
-
- Locate and click the Requestly icon in your browser’s toolbar to open the menu.
+
+ Locate and click the Requestly Interceptor icon in your browser’s toolbar to open the menu.
-
- Find the toggle labeled "Requestly running." Click it to deactivate Requestly. The label will change to "Requestly paused," indicating that Requestly is now inactive and no rules are being applied.
+
+ Find the toggle labeled "Requestly Interceptor running." Click it to deactivate Requestly Interceptor. The label will change to "Requestly Interceptor paused," indicating that Requestly Interceptor is now inactive and no rules are being applied.
-## Resuming Requestly
+## Resuming Requestly Interceptor
-To re-enable Requestly and allow its rules to intercept and modify requests again, follow these steps:
+To re-enable Requestly Interceptor and allow its rules to intercept and modify requests again, follow these steps:
-
- Locate and click the Requestly icon in your browser’s toolbar to open the menu.
+
+ Locate and click the Requestly Interceptor icon in your browser’s toolbar to open the menu.
-
- Click the Requestly icon in your browser’s toolbar and find the toggle labeled "Requestly paused." Click the toggle to activate Requestly. The label will change to "Requestly running," confirming activation.
+
+ Click the Requestly Interceptor icon in your browser’s toolbar and find the toggle labeled "Requestly Interceptor paused." Click the toggle to activate Requestly Interceptor. The label will change to "Requestly Interceptor running," confirming activation.
- Refresh your browser page to ensure that Requestly’s rules are properly applied.
+ Refresh your browser page to ensure that Requestly Interceptor’s rules are properly applied.
diff --git a/general/http-rules/advanced-usage/pinning-rules.mdx b/general/http-rules/advanced-usage/pinning-rules.mdx
index 424cd89..509b873 100644
--- a/general/http-rules/advanced-usage/pinning-rules.mdx
+++ b/general/http-rules/advanced-usage/pinning-rules.mdx
@@ -4,12 +4,12 @@ slug: "pinning-rules"
path: "/http-rules/advanced-usage/pinning-rules"
visibility: "PUBLIC"
format: "MDX"
-description: "Pin rules in Requestly for quick access and easy toggling directly from the Chrome toolbar."
+description: "Pin rules in Requestly Interceptor for quick access and easy toggling directly from the Chrome toolbar."
---
***
-Pinning rules in Requestly allows you to quickly access and manage your rules directly from the Chrome toolbar, streamlining your workflow without the need to open the Requestly app. This feature is particularly useful for toggling rules on or off with ease.
+Pinning rules in Requestly Interceptor allows you to quickly access and manage your rules directly from the Chrome toolbar, streamlining your workflow without the need to open the Requestly Interceptor app. This feature is particularly useful for toggling rules on or off with ease.
## Benefits of Pinning Rules
@@ -17,15 +17,15 @@ Pinning rules in Requestly allows you to quickly access and manage your rules di
2. **Simplified Management**: Toggle rules on or off with a single click.
-3. **Improved Workflow**: Avoid the need to open the Requestly app, streamlining your debugging or testing tasks.
+3. **Improved Workflow**: Avoid the need to open the Requestly Interceptor app, streamlining your debugging or testing tasks.
## How to Pin a Rule
-To pin a rule in Requestly, follow these steps:
+To pin a rule in Requestly Interceptor, follow these steps:
- Navigate to the list of rules in your Requestly dashboard.
+ Navigate to the list of rules in your Requestly Interceptor dashboard.
@@ -37,7 +37,7 @@ To pin a rule in Requestly, follow these steps:
-Once pinned, the rule will be accessible from the Requestly icon in your Chrome toolbar.
+Once pinned, the rule will be accessible from the Requestly Interceptor icon in your Chrome toolbar.
### Accessing Pinned Rules
@@ -45,7 +45,7 @@ To access and manage your pinned rules:
- Click on the Requestly icon located on the Chrome toolbar.
+ Click on the Requestly Interceptor icon located on the Chrome toolbar.
diff --git a/general/http-rules/advanced-usage/shared-state.mdx b/general/http-rules/advanced-usage/shared-state.mdx
index 95b1047..54c0b6b 100644
--- a/general/http-rules/advanced-usage/shared-state.mdx
+++ b/general/http-rules/advanced-usage/shared-state.mdx
@@ -4,7 +4,7 @@ slug: "shared-state"
path: "/http-rules/advanced-usage/shared-state"
visibility: "PUBLIC"
format: "MDX"
-description: "Discover how to use Shared State in Requestly to manage data across Modify Request and Response rules with examples and best practices."
+description: "Discover how to use Shared State in Requestly Interceptor to manage data across Modify Request and Response rules with examples and best practices."
---
***
@@ -12,14 +12,14 @@ description: "Discover how to use Shared State in Requestly to manage data acros
Shared State allows developers to store and retrieve data within and across Modify Request Body and Modify API Response rules. This functionality is facilitated by `$sharedState`, a JavaScript object where you can assign key-value pairs to enhance rule customisation.
- Shared State was introduced in the Requestly extension version `24.8.13` and Desktop App `1.7.1` . Make sure you are using the latest version.
+ Shared State was introduced in the Requestly Interceptor extension version `24.8.13` and Desktop App `1.7.1` . Make sure you are using the latest version.
## Use Cases for Shared State
1. **Conditional Request/Response Modification**: Use shared state to modify requests or responses dynamically based on conditions stored in prior requests. For example, you can conditionally fail requests based on request counts.
-2. **Data Aggregation Across Requests**: Collect and aggregate data from multiple requests to use within a rule. For instance, you can store API responses and utilize them for further processing across different Requestly rules.
+2. **Data Aggregation Across Requests**: Collect and aggregate data from multiple requests to use within a rule. For instance, you can store API responses and utilize them for further processing across different Requestly Interceptor rules.
3. **Token Management Across API Requests**: Manage shared values such as tokens or other critical data across various API interactions, streamlining complex workflows.
@@ -27,7 +27,7 @@ Shared State allows developers to store and retrieve data within and across Modi
- Start by creating a new "Modify Request" or "Modify Response" rule in Requestly. You can access this feature in both the web app and desktop versions.
+ Start by creating a new "Modify Request" or "Modify Response" rule in Requestly Interceptor. You can access this feature in both the web app and desktop versions.
@@ -103,7 +103,7 @@ Shared State allows developers to store and retrieve data within and across Modi
- `$sharedState` has different runtime contexts in the Requestly Desktop App and the Requestly browser extension.
+ `$sharedState` has different runtime contexts in the Requestly Interceptor Desktop App and the Requestly Interceptor browser extension.
* **Desktop App**: Data persists until the app is closed.
diff --git a/general/http-rules/advanced-usage/test-rules.mdx b/general/http-rules/advanced-usage/test-rules.mdx
index af3d87a..d90550c 100644
--- a/general/http-rules/advanced-usage/test-rules.mdx
+++ b/general/http-rules/advanced-usage/test-rules.mdx
@@ -4,7 +4,7 @@ slug: "test-rules"
path: "/http-rules/advanced-usage/test-rules"
visibility: "PUBLIC"
format: "MDX"
-description: "Validate and debug HTTP rules in real-time using Requestly's \"Test This Rule\" feature with session recording and detailed test reports."
+description: "Validate and debug HTTP rules in real-time using Requestly Interceptor's \"Test This Rule\" feature with session recording and detailed test reports."
---
***
@@ -61,7 +61,7 @@ The **Test This Rule** feature in the HTTP Rules section allows users to validat
## Advanced Usage: View Test Session
-To gain more details about the test report, you can view the network and console logs of the testing session by clicking on the **Watch Session** button. Requestly maintains reports for the last three tests you’ve run for each rule. Learn [more about the sessions here](/general/session-book/record-bug-reports).
+To gain more details about the test report, you can view the network and console logs of the testing session by clicking on the **Watch Session** button. Requestly Interceptor maintains reports for the last three tests you’ve run for each rule. Learn [more about the sessions here](/general/session-book/record-bug-reports).
diff --git a/general/http-rules/advanced-usage/validate-rules-execution.mdx b/general/http-rules/advanced-usage/validate-rules-execution.mdx
index 5b9fa37..ae07453 100644
--- a/general/http-rules/advanced-usage/validate-rules-execution.mdx
+++ b/general/http-rules/advanced-usage/validate-rules-execution.mdx
@@ -4,22 +4,22 @@ slug: "validate-rules-execution"
path: "/http-rules/advanced-usage/validate-rules-execution"
visibility: "PUBLIC"
format: "MDX"
-description: "Learn how to verify if a Requestly rule is executed successfully."
+description: "Learn how to verify if a Requestly Interceptor rule is executed successfully."
---
***
-The way Requestly shows rule executions varies between the browser extension and desktop app, tailored to their respective environments:
+The way Requestly Interceptor shows rule executions varies between the browser extension and desktop app, tailored to their respective environments:
- Once you have enabled a Requestly rule to modify some part of a network request or the page, the next thing you would like to do is confirm if the rule executed successfully.
+ Once you have enabled a Requestly Interceptor rule to modify some part of a network request or the page, the next thing you would like to do is confirm if the rule executed successfully.
Here are 4 ways to know if a rule is executed on a page.
## 1. Extension icon turns green
- If any of the rules executes on the current page, the Requestly icon in the extension toolbar (next to the address bar) will turn from a normal icon to a green icon.
+ If any of the rules executes on the current page, the Requestly Interceptor icon in the extension toolbar (next to the address bar) will turn from a normal icon to a green icon.
@@ -60,8 +60,8 @@ The way Requestly shows rule executions varies between the browser extension and
## 3. Executed Rules Tab in Popup
-
- Click on the **Requestly Icon** in the browser toolbar to open the extension.
+
+ Click on the **Requestly Interceptor Icon** in the browser toolbar to open the extension.
@@ -75,7 +75,7 @@ The way Requestly shows rule executions varies between the browser extension and
***
- ## 4. Requestly DevTools Tab
+ ## 4. Requestly Interceptor DevTools Tab
@@ -84,8 +84,8 @@ The way Requestly shows rule executions varies between the browser extension and
-
- Go to the **Requestly tab** within DevTools.
+
+ Go to the **Requestly Interceptor tab** within DevTools.
diff --git a/general/http-rules/overview.mdx b/general/http-rules/overview.mdx
index 1dd7442..2772123 100644
--- a/general/http-rules/overview.mdx
+++ b/general/http-rules/overview.mdx
@@ -6,7 +6,7 @@ description: >-
Learn when to use HTTP Rules, how to create your first rule, and which traffic modification workflows to explore next.
seoTitle: Overview
seoDescription: >-
- Learn how to use Requestly HTTP Rules to modify headers, redirect URLs, rewrite bodies, delay responses, and share rules.
+ Learn how to use Requestly Interceptor HTTP Rules to modify headers, redirect URLs, rewrite bodies, delay responses, and share rules.
visibility: PUBLIC
---
HTTP Rules are the fastest way to change traffic without changing your app. Use them to modify headers, rewrite request or response bodies, redirect calls, inject scripts, delay traffic, or map requests to local and remote resources.
diff --git a/general/http-rules/rule-types.mdx b/general/http-rules/rule-types.mdx
index 4975727..59c57cb 100644
--- a/general/http-rules/rule-types.mdx
+++ b/general/http-rules/rule-types.mdx
@@ -3,13 +3,13 @@ title: HTTP Rules
label: HTTP Rules
slug: rule-types
description: >-
- Learn about Requestly's rule types like Redirect, Modify Headers, and Insert
+ Learn about Requestly Interceptor's rule types like Redirect, Modify Headers, and Insert
Script to customize and control your web requests effectively.
visibility: PUBLIC
---
***
-HTTP Rules in Requestly enable you to efficiently control web traffic. With these rules, you can modify requests and responses, redirect or block network calls, insert custom scripts, and manage headers. These powerful tools help you customise and optimise your browsing experience for testing, debugging, or development purposes.
+HTTP Rules in Requestly Interceptor enable you to efficiently control web traffic. With these rules, you can modify requests and responses, redirect or block network calls, insert custom scripts, and manage headers. These powerful tools help you customise and optimise your browsing experience for testing, debugging, or development purposes.
### Types of Rules
diff --git a/general/http-rules/rule-types/delay-network-requests.mdx b/general/http-rules/rule-types/delay-network-requests.mdx
index 6ff2d1d..5dab63f 100644
--- a/general/http-rules/rule-types/delay-network-requests.mdx
+++ b/general/http-rules/rule-types/delay-network-requests.mdx
@@ -9,7 +9,7 @@ description: "Learn how to configure HTTP rules to simulate network latency for
***
-The **Delay Network Request** rule in Requestly enables you to simulate network latency on HTTP requests for testing and debugging purposes. By adding delays, you can observe how your application behaves under slow network conditions.
+The **Delay Network Request** rule in Requestly Interceptor enables you to simulate network latency on HTTP requests for testing and debugging purposes. By adding delays, you can observe how your application behaves under slow network conditions.
## Why Use the Delay Network Requests?
diff --git a/general/http-rules/rule-types/insert-scripts.mdx b/general/http-rules/rule-types/insert-scripts.mdx
index 6524002..0deecc6 100644
--- a/general/http-rules/rule-types/insert-scripts.mdx
+++ b/general/http-rules/rule-types/insert-scripts.mdx
@@ -4,7 +4,7 @@ slug: "insert-scripts"
path: "/http-rules/rule-types/insert-scripts"
visibility: "PUBLIC"
format: "MDX"
-description: "Learn how to use Requestly's Insert Script Rule to inject JavaScript or CSS into web pages without changing the original code"
+description: "Learn how to use Requestly Interceptor's Insert Script Rule to inject JavaScript or CSS into web pages without changing the original code"
---
***
@@ -54,7 +54,7 @@ To see how the Insert Script Rule can be configured and applied in different sce
* **Value:** `requestly-playground.com`
- This example targets any requests made to the [**Requestly Play**](/general/http-rules/advanced-usage/advance-targeting)[**ground**](https://requestly-playground.com), ensuring the script is applied wherever the URL contains `requestly-playground.com`.
+ This example targets any requests made to the [**Requestly Interceptor Play**](/general/http-rules/advanced-usage/advance-targeting)[**ground**](https://requestly-playground.com), ensuring the script is applied wherever the URL contains `requestly-playground.com`.
@@ -73,7 +73,7 @@ To see how the Insert Script Rule can be configured and applied in different sce
In the **URL** option, add a link to an external file containing the script or CSS.
- > **You can also pick the response from the Requestly File Server using the** `Pick from File Server` **feature.** This allows you to inject scripts or JSON responses hosted on the File Server directly into your rule.
+ > **You can also pick the response from the Requestly Interceptor File Server using the** `Pick from File Server` **feature.** This allows you to inject scripts or JSON responses hosted on the File Server directly into your rule.
@@ -132,7 +132,7 @@ To see how the Insert Script Rule can be configured and applied in different sce
While injecting JavaScript, you can enhance the `
+
+
+
+
+
+
+#### Videos
+
+Use the HTML video element for self-hosted video content:
+
+
+
+Embed YouTube videos using iframe elements:
+
+
+
+#### Tooltips
+
+Example of tooltip usage:
+
+
+ 
+
+## When To Use The Desktop App
+
+Use the Desktop App when you want to:
+
+- intercept traffic from mobile apps, emulators, desktop apps, terminal tools, or Node.js
+- capture system-wide traffic through a local proxy
+- work with localhost traffic and advanced debugging scenarios
+- record API sessions, import HAR files, or create mocks from captured traffic
+
+If you only need browser-based interception and a lighter setup, start with the [Browser Extension setup](/general/getting-started/quick-start-guide/browser-extension-setup).
+
+## Recommended Next Steps
+
+
diff --git a/troubleshoot/http-interceptor/unable-to-intercept-web-traffic-on-browser-mobile-or-emulator.mdx b/troubleshoot/http-interceptor/unable-to-intercept-web-traffic-on-browser-mobile-or-emulator.mdx
index e46fd4e..e1f00e2 100644
--- a/troubleshoot/http-interceptor/unable-to-intercept-web-traffic-on-browser-mobile-or-emulator.mdx
+++ b/troubleshoot/http-interceptor/unable-to-intercept-web-traffic-on-browser-mobile-or-emulator.mdx
@@ -5,90 +5,97 @@ slug: unable-to-intercept-web-traffic-on-browser-mobile-or-emulator
description: Troubleshooting guide to resolve common interceptor issues
visibility: PUBLIC
---
-If you're unable to intercept web traffic using the Requestly Desktop App, use the following guide to identify and resolve common issues based on your interception environment.
+Use this page as a decision tree when setup looks complete but traffic is still missing from Requestly.
-## Identify Your Interception Environment
+## Start With The Fastest Checks
-Determine where you're attempting to intercept traffic from:
+Before diving into platform-specific troubleshooting, confirm these basics:
-* Desktop browsers
+- Requestly is running and the correct browser, device, or runtime is connected
+- you completed the relevant [HTTP Interceptor setup guide](/general/http-interceptor/overview)
+- the traffic you expect is actually leaving the app or browser
+- you are looking in the correct Requestly interception view
-* System-wide traffic (entire machine)
+## Choose The Symptom That Matches Your Issue
-* iOS or Android devices
+
- Here you can directly invite teammates or go to workspace settings to see the list of users before inviting.
+ Here you can directly invite teammates or go to project settings to see the list of users before inviting.
diff --git a/general/team/how-to-get-started-with-shared-workspace/managing-workspace.mdx b/general/team/how-to-get-started-with-shared-workspace/managing-workspace.mdx
index 17829c7..eeab5a5 100644
--- a/general/team/how-to-get-started-with-shared-workspace/managing-workspace.mdx
+++ b/general/team/how-to-get-started-with-shared-workspace/managing-workspace.mdx
@@ -1,44 +1,44 @@
---
-title: "Managing Workspace"
+title: "Managing your project"
slug: "managing-workspace"
path: "/team/how-to-get-started-with-shared-workspace/managing-workspace"
visibility: "PUBLIC"
format: "MDX"
-description: "Learn how to manage workspaces"
+description: "Learn how to manage projects in Requestly"
---
-### Renaming a workspace
+### Renaming a project
-Workspaces can be renamed by following these steps
+Projects can be renamed by following these steps
- Click the **Save Changes** button to apply the new workspace name.
+ Click the **Save Changes** button to apply the new project name.
diff --git a/general/team/how-to-get-started-with-shared-workspace/user-roles.mdx b/general/team/how-to-get-started-with-shared-workspace/user-roles.mdx
index 34c9eba..86d4582 100644
--- a/general/team/how-to-get-started-with-shared-workspace/user-roles.mdx
+++ b/general/team/how-to-get-started-with-shared-workspace/user-roles.mdx
@@ -9,9 +9,9 @@ description: "Learn how to manage team collaboration securely in Requestly with
***
-Requestly enhances collaboration and security by allowing workspace admins to assign specific roles to users. This role-based access control (RBAC) ensures that only authorized members can access sensitive configurations, such as API keys and authentication tokens, and helps prevent unauthorised modifications.
+Requestly enhances collaboration and security by allowing project admins to assign specific roles to users. This role-based access control (RBAC) ensures that only authorized members can access sensitive configurations, such as API keys and authentication tokens, and helps prevent unauthorised modifications.
-In this doc, you'll learn how Requestly's RBAC works, the specific roles available, the permissions associated with each role, and how to change user roles within your workspace
+In this doc, you'll learn how Requestly's RBAC works, the specific roles available, the permissions associated with each role, and how to change user roles within your project
## How RBAC Works in Requestly
@@ -19,11 +19,11 @@ Requestly uses role-based access control (RBAC) to ensure that every team member
## User Roles and Their Permissions
-Each workspace has three roles, each with distinct permissions:
+Each project has three roles, each with distinct permissions:
#### **Admin**
-* Full control over **workspace settings, member management, and permissions**.
+* Full control over **project settings, member management, and permissions**.
* Can **create, edit, delete, and execute** Rules, APIs, and Sessions.
@@ -31,7 +31,7 @@ Each workspace has three roles, each with distinct permissions:
* Can **create, edit, delete, and execute** Rules, APIs, and Sessions.
-* **Cannot** manage team settings, members, or workspace-wide configurations.
+* **Cannot** manage team settings, members, or project-wide configurations.
#### **Viewer**
@@ -41,14 +41,14 @@ Each workspace has three roles, each with distinct permissions:
* **Read-only access**.
-* Can **view and execute** Rules, APIs, and Sessions but **cannot make any changes** or access sensitive workspace settings.
+* Can **view and execute** Rules, APIs, and Sessions but **cannot make any changes** or access sensitive project settings.
### Permissions Table
Below is a table that outlines key permissions for each role:
-### **Editing Environment Variables**
+### **Editing environment variables**
-To edit variables for a workspace:
+To edit variables for a project:
1. Go to the **Environments tab**.
-2. Select the workspace whose environment you want to edit.
+2. Select the project whose environment you want to edit.
-3. You’ll see all variables for that workspace listed, and you can add, update, or remove them as needed.
+3. You’ll see all variables for that project listed, and you can add, update, or remove them as needed.
-## Moving Requests Across Workspaces
+## Moving requests across projects
-You can easily move or share requests between different workspaces in multi-workspace view. There are two ways to do this:
+You can easily move or share requests between different projects in multi-project view. There are two ways to do this:
-### **Method 1: Drag and Drop**
+### **Method 1: Drag and drop**
-### **Method 2: Move via Menu**
+### **Method 2: Move via menu**
@@ -85,21 +85,21 @@ You can easily move or share requests between different workspaces in multi-work
diff --git a/general/team/workspaces.mdx b/general/team/workspaces.mdx
index 721b714..93c9dcd 100644
--- a/general/team/workspaces.mdx
+++ b/general/team/workspaces.mdx
@@ -2,21 +2,21 @@
title: Introduction
label: Overview
slug: workspaces
-description: Learn about workspaces in requestly
+description: Learn about projects in Requestly
visibility: PUBLIC
---
-A **workspace** in Requestly is like a project where you can store all related rules, mock APIs, API requests, and collections in one place. It helps keep everything organized and easily accessible for better management and collaboration.
+A **project** in Requestly is where you store all related rules, mock APIs, API requests, and collections in one place. It helps keep everything organized and easily accessible for better management and collaboration.
-### Understanding Workspaces
+### Understanding projects
-A Requestly workspace is like a project containing HTTP rules, API requests, Collections, and mocks. By default, you start in a private workspace, where no other user can view or access your rules.
+A Requestly project contains HTTP rules, API requests, collections, and mocks. By default, you start in a **private project**, where no other user can view or access your rules.
-This setup is ideal for personal projects or testing. However, you can create additional team workspaces and invite other users to collaborate in real-time, sharing rules, APIs and mocks effortlessly, or create a local workspace to keep all your data locally.
+This setup is ideal for personal work or testing. However, you can create additional **team projects** and invite other users to collaborate in real time, sharing rules, APIs, and mocks effortlessly, or create a **local project** to keep all your data on your machine.
-### Types of Workspaces :
+### Types of projects
-Requestly offers two main types of workspaces:
+Requestly offers two main types of projects:
-**Team Workspace** - A Team Workspace is a cloud-based workspace where all your data is securely stored and synced across teams and devices. This is ideal for users who work with teams and need to keep all data in sync with their team members.
+**Team project** — A team project is cloud-based: all your data is securely stored and synced across teams and devices. This is ideal when you work with a team and need everyone to stay in sync.
-**Local workspace ( beta )** - A Local workspace stores all your data in your local machine, ensuring complete control and privacy. It is designed for individual use, rather than team collaboration. This option is suitable for users who prefer local storage over the cloud.
+**Local project (beta)** — A local project stores all your data on your computer, giving you complete control and privacy. It is designed for individual use rather than team collaboration. Choose this option if you prefer local storage over the cloud.
From b8231aa22483f3532959be1cb6ae3fd80c096563 Mon Sep 17 00:00:00 2001
From: kanishkrawatt 
Configure headers for authentication and content types
-### Limitations
-
-* **Browser Dependency:** The history is only maintained for the browser in which it was created.
-
-* **Session Constraints:** Responses are cached only within the active browser session. Closing the tab clears all cached responses.
-
-* **Request Limit:** Only the last 20 requests are preserved in the history. Older entries are automatically removed as new requests are made.
-
## What's Next?
@@ -66,15 +66,15 @@ Bulk API Mocking allows you to mock multiple API endpoints at once using recorde
**Record a Session**
-If you haven’t already recorded a session, start by capturing the API requests and responses you want to mock using Requestly’s interceptor and save it in a session, start by:
+If you haven’t already recorded a session, start by capturing the API requests and responses you want to mock using Requestly Interceptor’s interceptor and save it in a session, start by:
- 
- If it is not visible, click on the **\>\>** button to expand the hidden tabs and then select **Requestly**
+ If it is not visible, click on the **\>\>** button to expand the hidden tabs and then select **Requestly Interceptor**
- * **Proxy Hostname:** Use the IP shown in the Requestly Desktop App (e.g., `192.168.1.10`).
+ * **Proxy Hostname:** Use the IP shown in the Requestly Interceptor Desktop App (e.g., `192.168.1.10`).
- * **Proxy Port:** Use the port displayed in the Requestly Desktop App (e.g., `8080`).
+ * **Proxy Port:** Use the port displayed in the Requestly Interceptor Desktop App (e.g., `8080`).
- This will open the **Connect Panel**, displaying all supported browsers on your system, along with other sources that Requestly supports.
+ This will open the **Connect Panel**, displaying all supported browsers on your system, along with other sources that Requestly Interceptor supports.
- 1. For Chromium-based browsers, Requestly applies the `--proxy-server` flag, configuring the browser to route all network traffic through the Requestly proxy server
+ 1. For Chromium-based browsers, Requestly Interceptor applies the `--proxy-server` flag, configuring the browser to route all network traffic through the Requestly Interceptor proxy server
2. Then requestly automatically installs CA certificate to your system’s certificate store.
@@ -104,7 +104,7 @@ With this method, you can easily link your current browser profile to the deskto
## Custom Browser Launch Options
-Requestly offers **custom browser launch options** for certain browsers, specifically Chromium-based ones. These options allow you to tweak the behavior of the browser during interception.
+Requestly Interceptor offers **custom browser launch options** for certain browsers, specifically Chromium-based ones. These options allow you to tweak the behavior of the browser during interception.
Use the buttons next to the browser selection to customize the launch options. Here's a quick rundown of the **preset configurations**:
diff --git a/general/http-interceptor/desktop-app/desktop-app-interception.mdx b/general/http-interceptor/desktop-app/desktop-app-interception.mdx
index c7882ab..04ff464 100644
--- a/general/http-interceptor/desktop-app/desktop-app-interception.mdx
+++ b/general/http-interceptor/desktop-app/desktop-app-interception.mdx
@@ -4,7 +4,7 @@ slug: "desktop-app-interception"
path: "/http-interceptor/desktop-app/desktop-app-interception"
visibility: "PUBLIC"
format: "MDX"
-description: "Learn how to set up and manage a system-wide proxy with Requestly to intercept and debug network requests across all applications."
+description: "Learn how to set up and manage a system-wide proxy with Requestly Interceptor to intercept and debug network requests across all applications."
---
***
@@ -12,26 +12,26 @@ description: "Learn how to set up and manage a system-wide proxy with Requestly
Setting up a system-wide proxy allows you to intercept and debug network requests from all applications on your computer, not just your browser. This is particularly useful in situations where an application-level proxy setup is not available.
### Filtering by App and Domain
-Requestly makes it easy to organize and focus on specific network traffic:
+Requestly Interceptor makes it easy to organize and focus on specific network traffic:
-Requestly provides two dropdowns in the **Network Inspector's** left sidebar for easy filtering:
+Requestly Interceptor provides two dropdowns in the **Network Inspector's** left sidebar for easy filtering:
* **Apps Dropdown**:
diff --git a/general/http-interceptor/desktop-app/ios-devices-interception.mdx b/general/http-interceptor/desktop-app/ios-devices-interception.mdx
index 0ace331..b4b2783 100644
--- a/general/http-interceptor/desktop-app/ios-devices-interception.mdx
+++ b/general/http-interceptor/desktop-app/ios-devices-interception.mdx
@@ -4,12 +4,12 @@ slug: "ios-devices-interception"
path: "/http-interceptor/desktop-app/ios-devices-interception"
visibility: "PUBLIC"
format: "MDX"
-description: "Learn how to set up Requestly to intercept, monitor, and debug HTTP requests on your iOS Apps for iOS app development, debugging, and testing."
+description: "Learn how to set up Requestly Interceptor to intercept, monitor, and debug HTTP requests on your iOS Apps for iOS app development, debugging, and testing."
---
***
-When working with iOS apps, debugging HTTP requests can be challenging. Requestly offers an easy-to-use solution for monitoring, modifying, and debugging HTTP requests and responses during development or QA testing. Once you're familiar with the [HTTP Interceptor and network table](/general/http-interceptor/overview), you can follow step-by-step instructions to set up Requestly for intercepting network traffic on your iOS devices, ensuring a fully functional interception setup for your iOS app development needs.
+When working with iOS apps, debugging HTTP requests can be challenging. Requestly Interceptor offers an easy-to-use solution for monitoring, modifying, and debugging HTTP requests and responses during development or QA testing. Once you're familiar with the [HTTP Interceptor and network table](/general/http-interceptor/overview), you can follow step-by-step instructions to set up Requestly Interceptor for intercepting network traffic on your iOS devices, ensuring a fully functional interception setup for your iOS app development needs.
@@ -45,7 +45,7 @@ The **iOS Simulator** is a virtual device that runs on a Mac desktop or laptop,
### Troubleshooting
-#### Simulator Not Listed in Requestly?
+#### Simulator Not Listed in Requestly Interceptor?
If you do not see your simulator listed after refreshing, follow these steps:
@@ -66,5 +66,5 @@ If you do not see your simulator listed after refreshing, follow these steps:
This command ensures that the correct Xcode installation is selected.
@@ -40,11 +40,11 @@ Use the filter option to find a set of particular requests from hundreds of inte
## Network Modification
-One of Requestly’s most powerful capabilities is **network modification**, allowing you to dynamically alter requests and responses in real time. This feature helps in debugging, testing, and even bypassing certain network constraints. Here’s how you can modify network traffic:
+One of Requestly Interceptor’s most powerful capabilities is **network modification**, allowing you to dynamically alter requests and responses in real time. This feature helps in debugging, testing, and even bypassing certain network constraints. Here’s how you can modify network traffic:
diff --git a/general/http-interceptor/desktop-app/nodejs.mdx b/general/http-interceptor/desktop-app/nodejs.mdx
index 9f99b09..c7e13c4 100644
--- a/general/http-interceptor/desktop-app/nodejs.mdx
+++ b/general/http-interceptor/desktop-app/nodejs.mdx
@@ -4,14 +4,14 @@ slug: "nodejs"
path: "/http-interceptor/desktop-app/nodejs"
visibility: "PUBLIC"
format: "MDX"
-description: "Learn How to Set Up Requestly Proxy in Your Node.js Application"
+description: "Learn How to Set Up Requestly Interceptor Proxy in Your Node.js Application"
---
## **Steps**
diff --git a/general/http-interceptor/desktop-app/terminal.mdx b/general/http-interceptor/desktop-app/terminal.mdx
index 82f8665..8cc9c03 100644
--- a/general/http-interceptor/desktop-app/terminal.mdx
+++ b/general/http-interceptor/desktop-app/terminal.mdx
@@ -4,14 +4,14 @@ slug: "terminal"
path: "/http-interceptor/desktop-app/terminal"
visibility: "PUBLIC"
format: "MDX"
-description: "Learn how to set up the Requestly proxy in the terminal to intercept and modify terminal requests effortlessly."
+description: "Learn how to set up the Requestly Interceptor proxy in the terminal to intercept and modify terminal requests effortlessly."
---
## **Steps**
@@ -31,7 +31,7 @@ The **Redirect Rule** in Requestly allows users to define multiple conditions wi
### Replace Rule
-The **Replace Rule** in Requestly allows users to define multiple conditions within a single rule to modify different parts of a URL dynamically. Instead of creating separate replace rules for different replacements, you can manage them all in one rule, ensuring efficient and flexible URL transformations.
+The **Replace Rule** in Requestly Interceptor allows users to define multiple conditions within a single rule to modify different parts of a URL dynamically. Instead of creating separate replace rules for different replacements, you can manage them all in one rule, ensuring efficient and flexible URL transformations.
@@ -43,7 +43,7 @@ The **Replace Rule** in Requestly allows users to define multiple conditions wit
### Query Param Rule
-The **Query Param Rule** in Requestly allows users to define multiple conditions within a single rule to modify query parameters in different URLs. Instead of manually appending, updating, or removing query parameters in multiple rules, you can consolidate all changes into one rule .
+The **Query Param Rule** in Requestly Interceptor allows users to define multiple conditions within a single rule to modify query parameters in different URLs. Instead of manually appending, updating, or removing query parameters in multiple rules, you can consolidate all changes into one rule .
@@ -55,7 +55,7 @@ The **Query Param Rule** in Requestly allows users to define multiple conditions
### Modify Headers Rule
-The **Modify Headers Rule** in Requestly allows users to define multiple conditions within a single rule to **add, modify, or remove HTTP headers** across different URLs. Instead of creating multiple rules for different header modifications, you can consolidate them into one rule, ensuring efficiency and better rule management.
+The **Modify Headers Rule** in Requestly Interceptor allows users to define multiple conditions within a single rule to **add, modify, or remove HTTP headers** across different URLs. Instead of creating multiple rules for different header modifications, you can consolidate them into one rule, ensuring efficiency and better rule management.
@@ -67,7 +67,7 @@ The **Modify Headers Rule** in Requestly allows users to define multiple conditi
### Modify User Agent
-The **Modify User Agent Rule** in Requestly allows users to define multiple conditions within a single rule to **modify the User-Agent header** for different URLs. This is particularly useful for testing how a website behaves across different browsers, devices, and platforms without needing to use actual devices or browser extensions.
+The **Modify User Agent Rule** in Requestly Interceptor allows users to define multiple conditions within a single rule to **modify the User-Agent header** for different URLs. This is particularly useful for testing how a website behaves across different browsers, devices, and platforms without needing to use actual devices or browser extensions.
@@ -81,7 +81,7 @@ The **Modify User Agent Rule** in Requestly allows users to define multiple cond
### Cancel Request Rule
-The **Cancel Request Rule** in Requestly allows users to define multiple conditions within a single rule to **block specific requests** based on different URLs. This is useful for preventing unnecessary or harmful requests, improving performance, and ensuring a cleaner browsing or testing environment.
+The **Cancel Request Rule** in Requestly Interceptor allows users to define multiple conditions within a single rule to **block specific requests** based on different URLs. This is useful for preventing unnecessary or harmful requests, improving performance, and ensuring a cleaner browsing or testing environment.
@@ -95,7 +95,7 @@ The **Cancel Request Rule** in Requestly allows users to define multiple conditi
### Delay Network Request Rule
-The **Delay Network Request Rule** in Requestly allows users to define multiple conditions within a single rule to **artificially delay specific requests**. This is useful for testing how applications behave under slow network conditions or simulating real-world latency issues.
+The **Delay Network Request Rule** in Requestly Interceptor allows users to define multiple conditions within a single rule to **artificially delay specific requests**. This is useful for testing how applications behave under slow network conditions or simulating real-world latency issues.
@@ -139,4 +139,4 @@ Insert Script rule allows you to insert multiple scripts and styles on a single
* **Avoid Blocking UI:** Large scripts should be loaded asynchronously when possible.
-* **Test in Requestly:** Use the **Test Rule** feature to ensure scripts load in the right sequence.
+* **Test in Requestly Interceptor:** Use the **Test Rule** feature to ensure scripts load in the right sequence.
diff --git a/general/http-rules/advanced-usage/pauseresume-requestly.mdx b/general/http-rules/advanced-usage/pauseresume-requestly.mdx
index 1a858ac..6320e25 100644
--- a/general/http-rules/advanced-usage/pauseresume-requestly.mdx
+++ b/general/http-rules/advanced-usage/pauseresume-requestly.mdx
@@ -1,52 +1,52 @@
---
-title: "Pause/Resume Requestly"
+title: "Pause/Resume Requestly Interceptor"
slug: "pauseresume-requestly"
path: "/http-rules/advanced-usage/pauseresume-requestly"
visibility: "PUBLIC"
format: "MDX"
-description: "Learn how to temporarily pause and resume Requestly rules to test your website’s original behavior without interference."
+description: "Learn how to temporarily pause and resume Requestly Interceptor rules to test your website’s original behavior without interference."
---
***
-Requestly provides an easy way to intercept and modify web requests, but there are instances when you might want to pause its functionality temporarily. This document outlines how to pause and resume Requestly to test your website's original behavior without interference from active Requestly rules.
+Requestly Interceptor provides an easy way to intercept and modify web requests, but there are instances when you might want to pause its functionality temporarily. This document outlines how to pause and resume Requestly Interceptor to test your website's original behavior without interference from active Requestly Interceptor rules.
-## Pausing Requestly
+## Pausing Requestly Interceptor
-To temporarily stop Requestly from intercepting and modifying web requests, follow these steps:
+To temporarily stop Requestly Interceptor from intercepting and modifying web requests, follow these steps:
diff --git a/general/http-rules/advanced-usage/validate-rules-execution.mdx b/general/http-rules/advanced-usage/validate-rules-execution.mdx
index 5b9fa37..ae07453 100644
--- a/general/http-rules/advanced-usage/validate-rules-execution.mdx
+++ b/general/http-rules/advanced-usage/validate-rules-execution.mdx
@@ -4,22 +4,22 @@ slug: "validate-rules-execution"
path: "/http-rules/advanced-usage/validate-rules-execution"
visibility: "PUBLIC"
format: "MDX"
-description: "Learn how to verify if a Requestly rule is executed successfully."
+description: "Learn how to verify if a Requestly Interceptor rule is executed successfully."
---
***
-The way Requestly shows rule executions varies between the browser extension and desktop app, tailored to their respective environments:
+The way Requestly Interceptor shows rule executions varies between the browser extension and desktop app, tailored to their respective environments:
@@ -60,8 +60,8 @@ The way Requestly shows rule executions varies between the browser extension and
## 3. Executed Rules Tab in Popup
@@ -73,7 +73,7 @@ To see how the Insert Script Rule can be configured and applied in different sce
