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
  • 🇨🇳 繁體中文
Learning Center
HomeSupport CenterAPI ReferencesDownloadChangelog
Learning Center
HomeSupport CenterAPI ReferencesDownloadChangelog
  1. Enterprise Onboarding
  • 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 from Stoplight
        • 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
    • AI 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
        • Script Library
        • 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
    • Test Reports
      • Test Reports
    • 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 APIs
      • Integration Testing
      • Performance Testing
      • End-to-End Testing
      • Regression Testing
      • Contract Testing
    • Test Suite
      • Overview
      • Create A Test Suite
      • Orchestrate Test Suite
      • Run Test Suites Locally
      • Scheduled Tasks
  • Apidog CLI
    • Overview
    • Installing and Running Apidog CLI
    • Run Test Suites Via CLI
    • Apidog CLI Commands & Options
    • Use Apidog CLI with an AI Agent
    • CI CD
      • Overview
      • Trigger Test by Git Commit
      • Integrate with Github Actions
      • Integrate with Gitlab
      • Integrate with Jenkins
  • 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
    • Basic Concepts
    • Enterprise Onboarding
      • Enterprise Onboarding Journey
      • Set Up Secure Enterprise Access
      • Migrate and Validate Your API Data
      • Establish Your Team’s Apidog Workflow
    • Managing Projects
      • Notification Settings
      • Managing Projects
      • Managing Project Members
      • Project Resources
        • Database Connection
        • Git Connection
    • Managing Teams
      • Managing Teams
      • Managing Team Members
      • Team Roles & Permissions
      • Team Activities
      • Team Resources
        • General Runner
        • Team Variables
        • Request Proxy Agent
      • Real-time Collaborations
        • Team Collaboration
    • Managing Organization
      • Managing Organization
      • Managing Teams in an Organization
      • Organization Role & Permissions
      • Audit Logs
      • Enterprise Policies
      • Single Sign-On (SSO)
        • SSO Overview
        • Configuring Microsoft Entra ID
        • Configuring Okta
        • Configuring SSO for an Organization
        • Managing User Accounts
        • Mapping Groups to Teams
        • Configuring JumpCloud SSO
      • SCIM Provisioning
        • Introduction to SCIM Provisioning
        • Microsoft Entra ID
        • Okta
      • Plans Management
        • Billing Managers in Organizations
      • Organization Resources
        • Self-Hosted Runner
        • GitHub Enterprise Cloud
  • 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
    • Secret Scanner
  • 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. Enterprise Onboarding

Migrate and Validate Your API Data

Import one representative API asset and confirm that the team can find and use it in Apidog. Choose a Postman route, an OpenAPI or Swagger route, or another supported source; all routes finish with the same Project-validation checkpoint.
Journey: Enterprise Onboarding Journey → Set Up Secure Enterprise Access → Migrate and Validate Your API Data → Establish Your Team's Apidog Workflow

Prepare the pilot migration#

Do not begin by importing the entire API catalog. Prepare only what is required for one representative Project:
Identify the current source and one representative API asset.
Select the target Team and Project owner.
Confirm General Mode or Spec-first Mode before creating the Project.
Identify the environments, authorization, secrets, local files, and scripts required to use the pilot APIs.
Record who will validate the imported content and own any migration gaps.
Confirm the deployment using the Enterprise Onboarding Journey. For Apidog On-Premises, verify feature availability and navigation before following SaaS-specific steps.

Create one pilot Project#

Choose the Project mode before creation
Project mode cannot be switched after the Project is created. Confirm the working source of truth before creating the pilot Project.
DecisionChoose whenValidate
General ModeApidog's structured Project data will become the working source.Confirm how imported definitions and future updates will be managed in Apidog.
Spec-first ModeAn OpenAPI specification will remain the source of truth.Confirm how the specification will be maintained and synchronized.
Pilot scopeOne Team, one Project, and one representative API asset are enough to test the migration route.Do not expand to the full catalog until the pilot passes validation.
Use Create a New API Project, Spec-first Mode, and the Migration Guide Overview while preparing the Project.

Choose the source route#

RouteUse whenPrimary owner
PostmanCollections, environments, examples, or related Postman assets are the working source.Migration lead and Postman workspace or Collection owner
OpenAPI or SwaggerAn OpenAPI 3.0 or 3.1 or Swagger 2.0 document is the portable source of API definitions.Migration lead or specification owner
Another supported sourceThe APIs use another supported format, already exist in Apidog, or will be created directly.Migration lead and Team or Project owner

Route A: Import from Postman#

Choose one representative Collection and the environments required to resolve its variables.

Choose an import method#

MethodUse when
Postman APIApidog should fetch selected workspaces, Collections, and environments from Postman. This is suitable when migrating multiple assets.
Exported filesThe migration will use exported Collection v2.1 JSON and environment files. A folder can be uploaded when it contains the related files.
1.
Select the Collection and required environments for the pilot.
2.
Import through the approved Postman API or exported-file method.
3.
Review the import preview and base URL handling before confirming.
4.
Select the correct Apidog environment and send representative requests.
5.
Review the imported structure, variables, authorization, examples, and scripts.
Local form-data file references can be imported, but the local files are not uploaded automatically. Confirm those files separately before the team relies on the imported requests.
Use Import from Postman, Manual Import, and Import Options for the detailed procedure.

Route B: Import OpenAPI or Swagger#

Use this route when an OpenAPI or Swagger document is the portable API source.
1.
Confirm whether the specification will remain the source of truth.
2.
Import a JSON or YAML file, paste the specification content, or provide a raw specification URL.
3.
Preview the parsed endpoints and select the content to import.
4.
Choose the duplicate strategy for matching endpoints: Overwrite, Merge, Keep Both, Ignore, or Overwrite Selected.
5.
Validate paths, methods, schemas, examples, security definitions, and representative requests.
An OpenAPI document does not necessarily include the team's automated tests, secret values, local files, database or proxy settings, runner configuration, notifications, or collaboration settings. Record required items that must be configured separately.
Use Import OpenAPI Spec, Spec-first Mode, and Import Options for the detailed procedure.

Route C: Use another supported source#

Use this route when the pilot APIs come from another supported format, already exist in an Apidog Project, or will be created directly.
1.
Identify the current source format and the APIs the team must use first.
2.
Confirm the supported import route or whether the endpoints should be created directly.
3.
Bring only the representative APIs into the pilot Project.
4.
Record what was imported, what must be recreated, and who owns each gap.
Use the Migration Guide Overview, Manual Import, and Create a New API Project to select the appropriate route.

Validate the Project#

All source routes finish with the same validation.
CheckExpected resultValidation
Pilot assetThe intended Collection, specification, or source APIs are present.Representative users can find the first real APIs without a walkthrough.
StructureThe required folders, requests, paths, methods, schemas, and examples are available.Compare a representative set with the source.
Request executionRepresentative requests run in the intended environment.A user with the intended role can send at least one real request.
Variables and authorizationRequired environments, variables, and authorization resolve.Run a request that depends on those values.
Scripts and testsRequired supported scripts, examples, API cases, or tests are present or recorded as gaps.Run or review the items used by the pilot workflow.
Local dependenciesLocal files, secrets, integrations, and tool-specific settings have been reviewed.Every required gap has an owner.
Use Environment Management, Authentication and Authorization in Apidog, and Making a Request during validation.
Import is a conversion
Do not assume that an import transfers every secret, local value, test, script, integration, or tool-specific setting. Review the import preview, record gaps, and keep a recovery copy before using overwrite options or removing resources that are missing from the source.
Do not configure Scheduled Import until the manual pilot import has been accepted.

Complete the migration phase#

The pilot Project was created in the approved mode.
The representative asset was imported through the selected route.
Representative users can find and open the first real APIs.
A representative request runs, or the blocking gap has a named owner.
Required environments, variables, and authorization have been validated.
Secrets, local files, scripts, tests, and other migration gaps have been recorded.
The import route can be repeated for the next asset.
This phase is complete when a representative Project has been imported and validated and the organization can repeat the selected route for the next asset.
Modified at 2026-08-21 08:45:31
Previous
Set Up Secure Enterprise Access
Next
Establish Your Team’s Apidog Workflow
Built with