Collections Guide

Learn how to organize API requests into collections, create folder structures, and manage saved configurations for efficient API testing workflows.

What Are Collections

Collections are groups of saved API requests that help you organize and manage your API testing workflow. Instead of reconfiguring requests every time, save them once and reuse them across sessions.

Why Use Collections?

Organization by Project: Group all API requests for a specific project or client in one place
API Version Management: Maintain separate collections for v1, v2, and beta endpoints
Workflow Efficiency: Create sequences like "Auth → Fetch Data → Update → Delete" for testing complete user flows
Offline Storage: All collections are stored locally on your device, ensuring privacy and offline access
Team Collaboration: Export collections to share with teammates or sync via cloud services

Collections work in both offline and online modes. When logged in to Postman or Apidog, collections sync automatically with cloud services.

Create a Collection

Follow these steps to create your first collection.

Open Collections Screen

Tap the menu icon (three horizontal lines) in the top-left corner, then select "Collections" from the drawer menu.

Tap the Create Button

On the Collections screen, tap the "+" button in the top-right corner or the "Create Collection" button if you don't have any collections yet.

Enter Collection Details

Provide a descriptive name for your collection (e.g., "GitHub API v3", "E-commerce Backend", "Weather Service"). Optionally add a description to document the collection's purpose.

Save the Collection

Tap "Save" to create the collection. It will immediately appear in your Collections list, ready to receive requests.

Pro Tip: Use naming conventions like "Project - Environment" (e.g., "Acme API - Production") to keep collections organized when managing multiple projects.

Add Requests

Once you've created a collection, you can add API requests to it from the main request screen.

Saving a New Request

Configure your API request on the home screen (URL, method, headers, body, etc.)
Tap the "Save" button in the top-right corner
Select "Save to Collection" from the options
Choose the target collection from the list
Optionally select a folder within the collection (or create a new folder)
Give your request a descriptive name (e.g., "Get User Profile", "Create Order")
Tap "Save" to add the request to your collection

The request is saved with its complete configuration including:

HTTP method (GET, POST, PUT, DELETE, etc.)
URL and query parameters
Headers (Authorization, Content-Type, custom headers)
Request body (JSON, form-data, x-www-form-urlencoded, raw text)
Authentication settings
Pre-request and post-response scripts (if configured)

Quick Save: When saving multiple similar requests, use descriptive names that indicate the action: "User - Get by ID", "User - Update", "User - Delete". This makes requests easier to find later.

Organize with Folders

Folders help you organize requests within collections into logical groups. Think of folders as categories or feature modules.

Creating Folders

Within any collection, you can create folders to group related requests:

Open the collection details view
Tap "Add Folder" or the folder icon
Name the folder (e.g., "Authentication", "User Management", "Products")
Tap "Create" to add the folder

Nested Folder Structure

RestForge supports nested folders for complex API structures. Create subfolders within folders to mirror your API's resource hierarchy:

Example Folder Structure E-commerce API Collection ├── Authentication │ ├── Login │ ├── Logout │ └── Refresh Token ├── Products │ ├── List Products │ ├── Get Product Details │ ├── Create Product │ └── Update Product └── Orders ├── Create Order ├── Get Order Status └── Cancel Order

Reordering Requests and Folders

Long-press on any request or folder to enter drag mode, then drag it to a new position. This helps you arrange requests in the order they're typically executed (e.g., authentication first, then data operations).

Edit & Delete

Collections, folders, and requests can be edited or removed at any time.

Editing Collections

To edit a collection's name or description:

Open the Collections screen
Tap the three-dot menu icon next to the collection
Select "Edit Collection"
Update the name or description
Tap "Save" to apply changes

Editing Requests

To modify a saved request:

Navigate to the request in your collection
Tap to load it into the request editor
Make your changes (URL, headers, body, etc.)
Tap "Save" to update the request

Alternatively, tap the three-dot menu next to the request and select "Edit" to change only the request name without loading the full configuration.

Deleting Items

To delete a request, folder, or collection:

Tap the three-dot menu icon next to the item
Select "Delete"
Confirm the deletion in the dialog

Warning: Deleting a collection or folder removes all contained requests and subfolders permanently. This action cannot be undone. Consider exporting the collection before deletion if you might need it later.

Collection Variables

Collection variables are scoped to a specific collection and are accessible to all requests within that collection. They're useful for storing configuration values that apply across multiple requests.

When to Use Collection Variables

API Keys: Store authentication tokens specific to one API service
Resource IDs: Save IDs returned from one request to use in subsequent requests
Common Headers: Define values like API versions or client identifiers
Test Data: Store test user IDs, product IDs, or other test fixtures

Setting Collection Variables

Use JavaScript in pre-request or post-response scripts to set collection variables:

JavaScript // Set a collection variable pm.collectionVariables.set('userId', '12345'); pm.collectionVariables.set('apiVersion', 'v2'); // Get a collection variable const userId = pm.collectionVariables.get('userId'); console.log('User ID:', userId);

Using Variables in Requests

Reference collection variables using double curly braces:

Example URL https://api.example.com/{{apiVersion}}/users/{{userId}}

Variable Priority: Collection variables have lower priority than environment variables. If both define the same key, the environment variable value is used. Learn more in the Environments Guide.

Run from Collection

Running requests from your collections is fast and straightforward.

Loading a Request

Open the Collections screen from the drawer menu
Navigate to your collection and expand it to view requests
Tap on any request to load it into the request editor
The request loads with all saved configuration (URL, headers, body, etc.)
Tap "Send" to execute the request

Request History

Every request sent from a collection is automatically saved to your request history. This allows you to:

Review response data from previous runs
Compare responses over time
Audit API behavior changes
Recover from accidental modifications

Running Multiple Requests

For sequential execution of multiple requests (e.g., login → fetch data → update), use the Collection Runner feature:

Open collection details
Tap "Run Collection"
Select which requests to run and in what order
Review results for each request in the run summary

Import Collections

RestForge supports importing collections from multiple sources, making migration from other tools seamless.

Supported Import Formats

Format	Source	Version Support
Postman Collection	Postman desktop/web	v2.0, v2.1
Apidog Collection	Apidog app	Latest
Insomnia Export	Insomnia app	v4
OpenAPI Specification	Swagger/OpenAPI tools	2.0, 3.0, 3.1
Bruno Collection	Bruno app	Latest

How to Import

Detailed import instructions are available in the Import & Export Guide. Quick overview:

Export your collection from the source tool (Postman, Insomnia, etc.)
In RestForge, tap "Import" on the Collections screen
Select the file source (Files app, iCloud Drive, etc.)
Choose the exported file
Review the import preview and tap "Import"

Cloud Sync Import: If you're logged into Postman or Apidog, collections sync automatically from the cloud without manual import. See the Cloud Sync Guide for details.

Tips & Best Practices

Follow these recommendations to get the most out of collections in RestForge.

Naming Conventions

Collections: Use project or API names: "Stripe API", "Internal Auth Service", "GitHub v3"
Folders: Group by resource or feature: "Users", "Payments", "Reports"
Requests: Start with the action: "Get User Profile", "Create Invoice", "Delete Comment"

Group by Feature, Not HTTP Method

Instead of organizing by GET/POST/PUT/DELETE, organize by feature or API resource. This reflects real-world workflows better.

Good Structure User Management ├── Get User by ID ├── Create User ├── Update User └── Delete User Avoid This GET Requests ├── Get User ├── Get Order POST Requests ├── Create User ├── Create Order

Use Environment Variables for Base URLs

Instead of hardcoding https://api.example.com in every request, use an environment variable like {{baseUrl}}. This makes switching between development, staging, and production environments effortless.

Example // Instead of: https://api.production.example.com/users // Use: {{baseUrl}}/users // Then switch environments to change baseUrl

Keep Collections Focused

Avoid creating one massive collection with hundreds of requests. Instead, create separate collections for distinct projects, API versions, or microservices. This improves performance and makes navigation easier.

Document with Descriptions

Use the description field in collections and requests to document:

Authentication requirements
Rate limits or usage constraints
Expected response formats
Prerequisites (e.g., "Run 'Get Auth Token' first")

Version Control Your Collections

Export collections regularly and commit them to your project's Git repository. This provides version history and makes collections accessible to your entire team.

Use Pre-Request Scripts for Setup

Automate repetitive setup tasks with pre-request scripts:

Generate timestamps or random data
Calculate authentication signatures
Set dynamic headers based on conditions

Example Pre-Request Script // Auto-generate a timestamp for the request pm.collectionVariables.set('timestamp', Date.now()); // Create a random transaction ID const txId = 'tx_' + Math.random().toString(36).substring(7); pm.collectionVariables.set('transactionId', txId);

Ready to learn more? Explore Environments to manage variables across collections, or dive into Scripting to automate workflows with JavaScript.