Apidog Docs
🇺🇸 English
  • 🇺🇸 English
  • 🇯🇵 日本語
  • 🇪🇸 Español
  • 🇰🇷 한국인
  • 🇨🇳 简体中文
  • 🇵🇹 Português (Portugal)
  • 🇮🇩 Bahasa Indonesia
  • 🇧🇷 Português (Brasil)
  • 🇻🇳 Tiếng Việt
  • 🇨🇳 繁體中文
🇺🇸 English
  • 🇺🇸 English
  • 🇯🇵 日本語
  • 🇪🇸 Español
  • 🇰🇷 한국인
  • 🇨🇳 简体中文
  • 🇵🇹 Português (Portugal)
  • 🇮🇩 Bahasa Indonesia
  • 🇧🇷 Português (Brasil)
  • 🇻🇳 Tiếng Việt
  • 🇨🇳 繁體中文
🇺🇸 English
  • 🇺🇸 English
  • 🇯🇵 日本語
  • 🇪🇸 Español
  • 🇰🇷 한국인
  • 🇨🇳 简体中文
  • 🇵🇹 Português (Portugal)
  • 🇮🇩 Bahasa Indonesia
  • 🇧🇷 Português (Brasil)
  • 🇻🇳 Tiếng Việt
  • 🇨🇳 繁體中文
HomeLearning Center
Support CenterAPI ReferencesDownloadChangelog
HomeLearning Center
Support CenterAPI ReferencesDownloadChangelog
  1. Import From
  • Apidog Learning Center
  • Getting Started
    • Introduction to Apidog
    • Basic Concepts in Apidog
    • Navigating Apidog
    • Quick Start
      • Overview
      • Creating an Endpoint
      • Making a Request
      • Adding an Assertion
      • Creating Test Scenarios
      • Sharing API Documentation
      • Explore More
    • Migration to Apidog
      • Overview
      • Manual Import
      • Scheduled Import (Bind Data Sources)
      • Import Options
      • Export Data
      • Import From
        • Import from Postman
        • Import OpenAPI Spec
        • Import cURL
        • Import Markdowns
        • Import from Insomnia
        • Import from apiDoc
        • Import .har File
        • Import WSDL
  • Design APIs
    • Overview
    • Create a New API Project
    • Endpoint Basics
    • APl Design Guidelines
    • Module
    • Configure Multiple Request Body Examples
    • Components
    • Common Fields
    • Global Parameters
    • Endpoint Change History
    • Comments
    • Batch Endpoint Management
    • Custom Protocol API
    • Spec-first Mode (Beta)
    • Schemas
      • Overview
      • Create a New Schema
      • Build a Schema
      • Generate Schemas from JSON Etc
      • oneOf, allOf, anyOf
      • Using Discriminator
    • Security Schemes
      • Overview
      • Create a Security Scheme
      • Use the Security Scheme
      • Security Scheme in Online Documentation
    • Advanced Features
      • Custom Endpoint Fields
      • Associated Test Scenarios
      • Endpoint Status
      • Appearance of Parameter Lists
      • Endpoint Unique Identification
  • Develop and Debug APIs
    • Overview
    • Generating Requests
    • Sending Requests
    • Debugging Cases
    • Test Cases
    • Dynamic Values
    • Validating Responses
    • Design-First vs Request-First
    • Generating Code
    • API Debugging
      • AI Agent Debugger
      • A2A Debugger
    • Environments & Variables
      • Overview
      • Using Variables
      • Environment Management
    • Vault Secrets
      • Overview
      • HashiCorp Vault
      • Azure Key Vault
      • AWS Secrets Manager
    • Pre and Post Processors
      • Overview
      • Assertion
      • Extract Variable
      • Wait
      • Security
      • Database Operations
        • Overview
        • MySQL
        • MongoDB
        • Redis
        • Oracle Client
      • Using Scripts
        • Overview
        • Pre Processor Scripts
        • Post Processor Scripts
        • Public Scripts
        • Postman Scripts Reference
        • Calling Other Programming Languages
        • Using JS Libraries
        • Visualizing Responses
        • Script Examples
          • Assertion Scripts
          • Using Variables
          • Modifying Requests
          • Other Examples
    • Dynamic Values Modules
  • Mock API Data
    • Overview
    • Smart Mock
    • Custom Mock
    • Mock Priority Sequence
    • Mock Scripts
    • Cloud Mock
    • Self-Hosted Runner Mock
    • Mock Language (Locales)
  • API Testing
    • Overview
    • Test Scenarios
      • Create a Test Scenario
      • Pass Data Between Requests
      • Flow Control Conditions
      • Sync Data from Endpoints and Endpoint Cases
      • Import Endpoints and Endpoint Cases from Other Projects
      • Export Test Scenarios
    • Run Test Scenarios
      • Run a Test Scenario
      • Run Test Scenarios in Batch
      • Data-Driven Testing
      • Shared Test Data
      • Scheduled Tasks
      • Manage Runtime Environment of APIs from Other Projects
    • Test Suite
      • Overview
      • Create A Test Suite
      • Orchestrate Test Suite
      • Run Test Suites Locally
      • Run Test Suites Via CLI
      • Scheduled tasks
    • Test Reports
      • Test Reports
    • Test APIs
      • Integration Testing
      • Performance Testing
      • End-to-End Testing
      • Regression Testing
      • Contract Testing
    • Apidog CLI
      • Overview
      • Installing and Running Apidog CLI
      • Apidog CLI Options
    • CI CD
      • Overview
      • Integrate with Github Actions
      • Integrate with Gitlab
      • Integrate with Jenkins
      • Trigger Test by Git Commit
  • Publish API Docs
    • Overview
    • API Technologies Supported
    • Quick Share
    • Viewing API Documentation
    • Markdown Documentation
    • Publishing Documentation Sites
    • Custom Login Page
    • Custom Layouts
    • Custom CSS, JavaScript, HTML
    • Custom Domain
    • AI Features
    • SEO Settings
    • Advanced Settings
      • Documentation Search
      • CORS Proxy
      • Integrating Google Analytics
      • Folder Tree Settings
      • Visibility Settings
      • Embedding Values in Document URLs
    • API Versions
      • Overview
      • Creating API Versions
      • Publishing API Versions
      • Sharing Endpoints with API Versions
  • Send Requests
    • Overview
    • SSE Debugging
    • MCP Client
    • Socket.IO
    • WebSocket
    • Webhook
    • SOAP or WebService
    • GraphQL
    • gRPC
    • Use Request Proxy Agents for Debugging
    • Create Requests
      • Request History
      • Request Basics
      • Parameters and Body
      • Request Headers
      • Request Settings
      • Debug Requests
      • Saving Requests as Endpoints
      • HTTP/2
    • Response and Cookies
      • Viewing API Responses
      • Managing Cookies
      • Overview
    • Authentication and Authorization
      • Overview
      • CA and Client Certificates
      • Authorization Types
      • Digest Auth
      • OAuth 1.0
      • OAuth 2.0
      • Hawk Authentication
      • Kerberos
      • NTLM
      • Akamai EdgeGrid
  • Branches
    • Overview
    • Creating a Sprint Branch
    • Testing APIs in a Branch
    • Designing APIs in a Branch
    • Merging Sprint Branches
    • Managing Sprint Branches
    • AI Branch (Beta)
  • AI Features
    • Overview
    • Enabling AI Features
    • Generating Test Cases
    • Modifying Schemas with AI
    • Endpoint Compliance Check
    • API Documentation Completeness Check
    • AI-Powered Field Naming
    • FAQs
  • Apidog MCP Server
    • Overview
    • Connect Apidog Project to AI
    • Connect Published Documentation to AI
    • Connect OpenAPI Files to AI
  • Best Practices
    • Handling API Signatures
    • Accessing OAuth 2.0 Protected APIs
    • Collaboration Workflow
    • Managing Authentication State
  • Offline Space
    • Overview
  • Administration
    • Onboarding Checklist
      • Basic Concepts
      • Onboarding Guide
    • Managing Projects
      • Managing Projects
      • Notification Settings
      • Managing Project Members
      • Project Resources
        • Database Connection
        • Git Connection
    • Managing Teams
      • Managing Teams
      • Managing Team Members
      • Team Activities
      • Team Roles & Permissions
      • Team Resources
        • General Runner
        • Team Variables
        • Request Proxy Agent
      • Real-time Collaborations
        • Team Collaboration
    • Managing Organization
      • Managing Organization
      • Organization Role & Permissions
      • Single Sign-On (SSO)
        • SSO Overview
        • Configuring Microsoft Entra ID
        • Configuring Okta
        • Configuring SSO for an Organization
        • Managing User Accounts
        • Mapping Groups to Teams
      • SCIM Provisioning
        • Introduction to SCIM Provisioning
        • Microsoft Entra ID
        • Okta
      • Plans Management
        • Billing Managers in Organizations
      • Organization Resources
        • Self-Hosted Runner
  • Billing
    • Overview
    • Credits
    • Upgrading Your Plan
    • Alternative Payment Methods
    • Managing Subscriptions
    • Moving Paid Teams to Organizations
  • Data & Security
    • Data Storage and Security
    • User Data Privacy and Security
    • Request Routing and Data Security
  • Add-ons
    • API Hub
    • Apidog Intellij IDEA Plugin
    • Browser Extension
      • Chrome
      • Microsoft Edge
    • Request Proxy
      • Request Proxy in Web
      • Request Proxy in Shared Docs
      • Request Proxy in Client
  • Account & Preferences
    • Account Settings
    • Generating OpenAPI Access Token
    • Notification
    • Language Settings
    • Hot Keys
    • Network Proxy Configuration
    • Backing Up Data
    • Updating Apidog
    • Deleting Account
    • Experimental Features
  • References
    • API Design-First Approach
    • Apidog OpenAPI Specificaiton Extensions
    • JSONPath
    • XPath
    • Regular Expressions
    • JSON Schema
    • CSV File Format
    • Installing Java Environment
    • Runner Deployment Environment
    • Apidog Markdown Syntax
    • Apidog Swagger Extensions
      • Overview
      • x-apidog-folder
      • x-apidog-status
      • x-apidog-name
      • x-apidog-maintainer
    • Apidog JSON Schema Extensions
      • Overview
      • x-apidog-mock
      • x-apidog-orders
      • x-apidog-enum
  • Apidog Europe
    • Apidog Europe
  • Support Center
  1. Import From

Import from Postman

For a detailed feature-by-feature comparison of Apidog and Postman, see Apidog vs. Postman.
Video Tutorial
What You Can Import from Postman
Conceptual Map

Import Methods#

Apidog supports two ways to migrate Postman data.
1.
Import via the Postman API
2.
Import using files

Import via the Postman API#

Use this method when you want to migrate data directly from your Postman account by using the Postman API key.
This is recommended when:
You need to migrate multiple workspaces or collections.
You want Apidog to fetch collections and environments automatically.
You want to create Apidog projects from selected Postman workspaces.
Postman API import may be affected by Postman's official API rate limits. If you are importing many collections, the process may take longer.
1
Choose an entry point based on where you want to import the Postman data.
GoalEntry PointImport Methods
Create your first projectEmpty team page > Import Postman collectionUpload files/folder, Postman API
Create a new projectTeam Page > Import Project > PostmanUpload files/folder, Postman API
2
Create a New Project
image.png
3
After selecting Postman
choose the Postman API method
Enter a Postman API key,
then select Workspaces, Collections, and Environments to import.
To create a Postman API key, open Postman and go to Settings > API Keys.

Import Using Files#

If you are importing using files, export your data from Postman first.
1
Export a Collection
1.
Open Collections in the Postman sidebar.
2.
Click the ... icon next to the collection.
3.
Select Export under More.
4.
Choose Collection v2.1. This format is recommended.
5.
Save the JSON file.
Batch Export Multiple Collections
You can also export multiple Postman collections in one package.
1.
Click your account avatar in the top-right corner of Postman.
2.
Select Settings.
3.
Under Account Settings, click Export Data.
4.
Create a new export request.
5.
Select Collections and Environments as needed.
6.
Download the exported file from the email Postman sends you.
2
Export an Environment (Optional but Recommended)
If your collection uses environment variables, export the related environment too.
1.
Open Environments in the Postman sidebar.
2.
Click the ... icon next to the environment.
3.
Select Export.
4.
Save the JSON file.
3
Import into Apidog
1.
Open Settings > Import Data in your Apidog project or click on Import Project button on the Team Page.
image.png
2.
Select Postman and upload your Collection JSON file (or folder, if you have both collection and environment files). If you have many files, you can upload the containing folder to Apidog.
Match the Environment Variables
If you imported an Environment JSON along with the Collection:
1.
On the Import Preview screen, choose whether or not baseURL should be included with endpoint urls.
2.
If baseURL is not included in endpoint urls, make sure the environment baseURL is set properly.

Import Options#

During import, Apidog may show options that control how your Postman data is converted and merged.

Keep or Remove Base URLs#

You can choose whether Apidog should keep the full request URL or remove the base URL from endpoints.
Import using FilesImport via Postman API
image.pngBase URL option when importing Postman data via the Postman API
Keep full URLs: Apidog keeps the original request URL as much as possible. Use this if you want the imported endpoints to stay close to the original Postman requests.
Remove base URLs: Apidog tries to detect the base URL from Postman URLs and variables, then stores it in environment or base URL settings. Use this if you want cleaner endpoint paths such as /users instead of https://api.example.com/users.
For long-term API management, removing base URLs is usually easier to maintain. It lets you switch environments without changing endpoint paths.
image.png

Other Import Options#

OptionDescription
EnvironmentsIf your requests use variables, import the related Postman environments. For example, if your request URL is {{baseUrl}}/users, Apidog needs the environment, collection variable, or global variable that defines baseUrl.
Examples or API CasesPostman saved examples and responses can be imported as response examples or API cases in Apidog. Enable this option if you want to preserve example responses for documentation, testing, or debugging.
Overwrite Existing DataCommon choices include: Overwrite existing data, Merge with existing data, Keep existing data, Create new resources
Sync Folder StructureEnable folder sync if you want Apidog to preserve or update the folder structure from your Postman collection. This is useful when your Postman folders represent product areas, services, or API groups.
Authorization SettingsApidog can map supported Postman authorization settings from the collection, folder, or request level. After import, review inherited auth settings to make sure they match your expected request behavior.

How Apidog Handles Base URLs#

Base URL handling is one of the most important parts of a Postman migration.
In Postman, requests often use URLs such as:
https://api.example.com/v1/users
{{baseUrl}}/v1/users
{{host}}/users
In Apidog, API endpoints are easier to manage when the endpoint path and environment base URL are separated.
For example:
Postman URLPossible Apidog Result
https://api.example.com/v1/usersBase URL: https://api.example.com, endpoint path: /v1/users
{{baseUrl}}/usersBase URL variable from environment/collection, endpoint path: /users
/usersEndpoint path: /users
For best results:
Import collections together with their environments and globals.
Make sure variables such as baseUrl, host, token, or api_url exist in the imported files.
Review the import preview before confirming.
After import, select the correct Apidog environment and send a test request.
If Apidog cannot determine the base URL confidently, it may keep more of the original URL in the endpoint path. You can adjust the endpoint path or environment base URL after import.

Verify the Migration#

After the import is complete, review the imported project before using it in production workflows.
Recommended checks:
Confirm that collections, folders, and requests were imported.
Select the correct environment in Apidog.
Check that variables such as {{baseUrl}} and {{token}} resolve correctly.
Review request methods, paths, parameters, headers, and bodies.
Check authorization settings at the project, module, folder, and endpoint levels.
Review imported examples or API cases.
Run important requests to confirm they work as expected.
Review pre-processors and post-processors if your Postman collection uses scripts.
Postman import is designed to preserve as much useful API data as possible, but some items may require manual review after migration.

FAQ#

Why are my endpoint URLs different after import?
Apidog may remove the base URL from endpoint paths and store it in environment or base URL settings. This makes endpoints easier to reuse across environments.
If you want to preserve the original full URLs, choose the option to keep full endpoint URLs during import.
Why are some variables unresolved?
Should I import Postman environments and globals?
Can I import multiple collections at once?
Are Postman scripts fully supported?
Why did my import fail?

Detailed Guide
For a deeper dive into complex migration scenarios, see How to Migrate Postman Collections to Apidog.
Modified at 2026-06-10 09:28:34
Previous
Export Data
Next
Import OpenAPI Spec
Built with