DEV Community

Cover image for How to Migrate from ReadyAPI to Apidog
Hassann
Hassann

Posted on • Originally published at apidog.com

How to Migrate from ReadyAPI to Apidog

#api #testing #tooling #tutorial

TL;DR

Migrating from ReadyAPI to Apidog is efficient for REST-heavy test suites. Export your ReadyAPI project, import as much as possible via OpenAPI, and manually convert Groovy scripts to JavaScript. SOAP test cases require the most manual work. Use a phased migration to maintain continuous testing coverage.

Try Apidog today

đź’ˇApidog is a free, all-in-one API development platform that imports OpenAPI specs and Postman collections and runs test pipelines with JavaScript scripts. Try Apidog free, no credit card required.

Introduction

Migrating API testing infrastructure can be complex due to years of accumulated ReadyAPI test cases, custom Groovy scripts, data files, environments, and test suite structures. To move everything to Apidog, you need to know what imports automatically, what requires manual conversion, and what to deprioritize.

This guide details each migration step: ReadyAPI project export, inventory audit, importing to Apidog, Groovy-to-JavaScript conversion, CI/CD setup, and managing the transition period with both tools running in parallel.

Step 1: Audit Your ReadyAPI Project

Before exporting, analyze your ReadyAPI project to estimate migration effort and focus:

  • Count test suites, cases, and steps: Use the Navigator panel to get totals. Larger projects require more planning.
  • REST vs SOAP cases: REST cases migrate more cleanly; SOAP cases need more manual work.
  • Groovy scripting: Identify test cases with Script steps—each custom Groovy block must be rewritten in JavaScript.
  • Data-driven tests: If using DataSource steps, note which ones rely on CSV, Excel, or XML. Apidog uses CSV/JSON for data-driven testing.
  • Properties & Property Transfer: Heavy use of these steps will shift to variables and environment variables in Apidog.
  • LoadUI Pro integration: LoadUI Pro tests do not migrate; plan to use k6 or another load testing tool for those cases.

Document audit results in a spreadsheet: test name, type (REST/SOAP), uses Groovy (yes/no), complexity (simple/medium/complex). This gives a concrete migration estimate.

Step 2: Export Your ReadyAPI Project

Export your ReadyAPI project for migration:

  1. Open ReadyAPI and your project.
  2. Go to File > Save As to save as a standalone XML file.
  3. Save external data files (CSV, Excel, XML) referenced by tests.
  4. Note environment configurations under the Environments section.

The XML will include all test suites, cases, steps, scripts, and configuration—a complete project snapshot.

Step 3: Extract Your API Definitions

For REST APIs, migrate via OpenAPI spec (not directly from XML):

  • Option A: In ReadyAPI, right-click a REST service and export/generate OpenAPI (Swagger) if available.
  • Option B: Download your backend's OpenAPI spec from its /openapi.json or similar endpoint.
  • Option C: If no spec exists, manually document endpoints, request/response details, headers, etc., using your ReadyAPI REST requests as reference.

Step 4: Import into Apidog

With your OpenAPI spec:

  1. Open Apidog and create a new project.
  2. Go to APIs > Import and choose the format (OpenAPI 3.0, Swagger 2.0, etc.).
  3. Upload the file or paste the URL.
  4. Apidog parses the spec and creates API definitions for all endpoints.

You now have structured API definitions as the foundation for your Apidog test cases.

If you have Postman collections, import via File > Import > Postman.

Step 5: Recreate Test Cases for REST Endpoints

For each REST test case:

  1. Open the ReadyAPI REST test case.
  2. Identify requests, assertions, and data sources.
  3. Create a matching test case in Apidog by selecting the API endpoint and adding test steps.

Assertion mapping:

  • Contains assertion 
  pm.test('contains value', () => {
    pm.expect(pm.response.text()).to.include('expected string');
  });
Enter fullscreen mode Exit fullscreen mode
  • Status code assertion 
  pm.test('status 200', () => {
    pm.response.to.have.status(200);
  });
Enter fullscreen mode Exit fullscreen mode
  • JSONPath assertion 
  pm.test('field value', () => {
    pm.expect(pm.response.json().fieldName).to.equal('expected');
  });
Enter fullscreen mode Exit fullscreen mode

Simple GET/POST cases without Groovy can be migrated in 15–30 minutes.

Step 6: Convert Groovy Scripts to JavaScript

Manual script conversion is required for all custom Groovy logic.

Common patterns:

  • Reading a response value 
  // Groovy (ReadyAPI)
  def response = context.expand('${TestStep#Response}')
  def json = new groovy.json.JsonSlurper().parseText(response)
  def value = json.fieldName
Enter fullscreen mode Exit fullscreen mode 
  // JavaScript (Apidog)
  const response = pm.response.json();
  const value = response.fieldName;
Enter fullscreen mode Exit fullscreen mode
  • Setting a variable 
  // Groovy
  testRunner.testCase.setPropertyValue('myVariable', someValue)
Enter fullscreen mode Exit fullscreen mode 
  // JavaScript
  pm.variables.set('myVariable', someValue);
Enter fullscreen mode Exit fullscreen mode
  • Conditional assertion 
  // Groovy
  if (statusCode == 200) {
    assert responseBody.contains("success")
  }
Enter fullscreen mode Exit fullscreen mode 
  // JavaScript
  if (pm.response.code === 200) {
    pm.test('response contains success', () => {
      pm.expect(pm.response.text()).to.include('success');
    });
  }
Enter fullscreen mode Exit fullscreen mode
  • Date formatting 
  // Groovy
  def now = new Date()
  def formatted = now.format('yyyy-MM-dd')
Enter fullscreen mode Exit fullscreen mode 
  // JavaScript
  const now = new Date();
  const formatted = now.toISOString().split('T')[0];
Enter fullscreen mode Exit fullscreen mode

For complex scripts with Java library imports or advanced logic, review and rewrite each manually—do not automate this step.

Step 7: Handle SOAP Test Cases

SOAP test cases need special handling:

  • If REST alternatives exist: Migrate tests to REST endpoints and drop SOAP.
  • If SOAP-only:
    • Option 1: Keep ReadyAPI for SOAP tests, run in parallel with Apidog for REST.
    • Option 2: Use SoapUI Open Source for basic SOAP functional testing (free, less feature-rich than ReadyAPI).

Pay extra attention to WS-Security and complex assertion logic in SOAP cases.

Step 8: Set Up Environments and Variables

Map ReadyAPI environments to Apidog environments:

  1. In Apidog, go to Settings > Environments and create environments matching those in ReadyAPI.
  2. Add variables (base URLs, tokens, headers, etc.).
  3. Ensure test cases reference variables using the Apidog syntax: {{variableName}} in URLs and request bodies.

Step 9: Configure CI/CD

Replace ReadyAPI’s testrunner with Apidog CLI:

  • Install CLI: 
  npm install -g apidog-cli
Enter fullscreen mode Exit fullscreen mode
  • Run a test collection: 
  apidog run "path/to/collection.json" -e "environment-id"
Enter fullscreen mode Exit fullscreen mode
  • GitHub Actions example: 
  - name: Run API tests
    run: apidog run collection.json --environment staging
Enter fullscreen mode Exit fullscreen mode
  • Jenkins: Add a shell step to call the Apidog CLI.

Update CI config to replace ReadyAPI references once Apidog runs validate successfully.

Step 10: Run Both Tools in Parallel During Transition

Maintain both ReadyAPI and Apidog in CI through at least one release cycle:

  • Run ReadyAPI tests as the main test gate.
  • Run Apidog tests in parallel and compare results.
  • Investigate Apidog failures not seen in ReadyAPI.
  • Add new test cases only in Apidog.

Once Apidog consistently matches ReadyAPI results, remove ReadyAPI from CI but keep it available for fallback.

FAQ

How long does migration take?

REST-only projects with minimal Groovy can migrate in 1–3 days. Large projects with complex scripting, SOAP, and test structures can take 2–6 weeks. Use your Step 1 audit for a realistic estimate.

Will my ReadyAPI test data files work in Apidog?

CSV files are compatible. Excel files must be converted to CSV. XML data may need restructuring.

Can I run ReadyAPI and Apidog in the same CI pipeline?

Yes. Add Apidog CLI steps alongside ReadyAPI testrunner. Compare results during migration.

Do I need to recreate environments manually?

Yes, there's no automated import for ReadyAPI environments. Recreate them by referencing your ReadyAPI setup.

What about ReadyAPI tests with no REST equivalent?

Maintain ReadyAPI (possibly with fewer licenses) for those tests, use SoapUI Open Source, or accept a gap if the service is legacy and low-risk.

Does Apidog support all ReadyAPI assertion types?

Apidog supports JavaScript assertions, covering most REST testing needs. ReadyAPI-specific types (SOAP Fault, WS-Security) have no direct equivalent.

Migrating from ReadyAPI to Apidog is a significant project. Teams that begin with a thorough audit, migrate REST test cases first, and run both tools in parallel ensure a smooth transition without losing test coverage.

Top comments (0)