Postman Collection Runner Restrictions: What Changed and How to Work Around It

TL;DR

Postman restricted Collection Runner access on its free tier, breaking automated test execution for teams that haven’t upgraded. This affects local test runs, CI/CD pipelines, and any workflow that used Runner for bulk request execution. This article explains what changed, what it breaks in practice, and how Apidog’s runner works without restrictions on any plan.

Introduction

Postman’s Collection Runner was one of its most used features. You’d build a collection of 50 API requests, hit “Run Collection,” and watch Postman execute them in sequence, with variable passing between requests, test assertions on each response, and a summary report at the end. For developers testing complex multi-step flows, it was essential.

Then came the 2026 restrictions. As part of the free tier reduction, Postman limited Collection Runner access. Free accounts can no longer run collections beyond a certain number of requests per month, and some Runner features are now paywalled entirely.

The impact showed up quickly in developer workflows. Teams that had CI pipelines relying on Newman (Postman’s CLI runner) started hitting limits. Developers running pre-deployment smoke tests in Collection Runner found the feature grayed out or throttled.

What Postman changed in Collection Runner

Postman’s free tier now restricts Collection Runner in two main ways:

Monthly run limits. Free accounts have a cap on how many Collection Runner executions they can perform per month. Postman has not published the exact number clearly, but community reports put it around 25 runs per month. For developers running tests multiple times per day, this limit is hit within days.

Newman CLI restrictions. Newman, the open-source CLI tool that lets you run Postman collections in terminal and CI environments, previously worked with any Postman collection export without hitting plan limits. Post-2026, some Newman features tie back to your Postman account’s plan tier when using cloud-synced collections.

No-code test execution. The visual Collection Runner, accessible from the sidebar, shows a paywalled state on free accounts after the run limit is reached.

What’s not restricted: running individual requests manually (clicking “Send” on a single request) remains unlimited. The restrictions specifically target automated batch execution.

What breaks in practice

Pre-commit and pre-deployment smoke tests

Many teams run a Collection Runner pass before merging a PR or deploying to staging. If you had 30 requests in your smoke test collection, a team of three developers each running it twice a day would exhaust Postman’s free monthly limit in about two days.

CI/CD pipelines

Newman-based CI pipelines are the most affected. A GitHub Actions workflow like this:

- name: Run API tests
  run: newman run ./collections/api-tests.json -e ./environments/staging.json

Will start failing or hitting rate errors once the account limit is reached. This is especially damaging for teams with multiple pipelines triggering on every push.

End-to-end test suites

Some teams built multi-step API workflows in Postman that chain requests together, passing the output of one request (like an auth token) into the next. Collection Runner handles this through the pm.environment.set() pattern. With Runner restricted, these workflows can only be tested by manually stepping through requests one at a time.

Load and performance testing

Postman’s Collection Runner has a “delay” and “iterations” option that lets you run a collection multiple times in sequence, useful for basic load testing. With run limits in place, this use case is effectively gone on the free tier.

Immediate workarounds within Postman

If you’re not ready to switch tools yet, a few workarounds exist within the Postman ecosystem.

Export to Newman and run locally. Newman runs against a locally exported collection JSON file without requiring a Postman account login, as long as you don’t use features that phone home. Export your collection and environment, then run Newman completely offline:

newman run collection.json -e environment.json

This bypasses the Postman account run limit because Newman is reading a local file. The limitation is that you lose sync with your live Postman workspace, so you need to re-export every time the collection changes.

Break large collections into smaller chunks. If you’re close to the monthly limit, splitting a 100-request collection into four 25-request collections means each uses a separate run counter. This is a workaround, not a solution, and it breaks the logical flow of multi-step tests.

Upgrade selectively. If only one team member runs the CI pipeline, having that one account on a paid plan while others stay free is cheaper than upgrading everyone. The paid account runs Newman without limits; others use manual testing.

How Apidog’s Collection Runner works differently

Apidog’s runner, called “Test Scenarios” or accessible through the “Run” button on any collection, has no monthly run limits on any plan. This includes the free tier.

Here’s how it compares to what Postman restricted:

The Apidog CLI runner (apidog-cli) integrates with CI/CD the same way Newman does. The command structure is similar:

apidog run {project-id} --collection {collection-id} --environment {env-id}

You can also export a collection from Apidog and run it offline, similar to the Newman local-file approach, but without needing to worry about account-based restrictions.

Setting up Apidog runner in your CI pipeline

If you’re migrating a Newman-based pipeline to Apidog, here’s what the transition looks like in GitHub Actions.

Before (Newman):

- name: Install Newman
  run: npm install -g newman

- name: Run API tests
  run: newman run ./collections/api-tests.json -e ./environments/staging.json --reporters cli,json --reporter-json-export results.json

After (Apidog CLI):

- name: Install Apidog CLI
  run: npm install -g apidog-cli

- name: Run API tests
  run: apidog run --project {project-id} --env {env-id} --output results.json
  env:
    APIDOG_ACCESS_TOKEN: ${{ secrets.APIDOG_ACCESS_TOKEN }}

The main differences are the authentication mechanism (Apidog uses an access token rather than a Postman API key) and the project-based reference instead of a local file path. Both support JSON output for test result reporting.

Alternatively, if you prefer to keep using Newman’s familiar interface, you can export an Apidog collection as a Postman-compatible JSON and continue running Newman against it. This gives you the offline, no-account-required approach while working out of Apidog day-to-day.

Advanced runner features in Apidog

Beyond matching Postman’s restricted feature set, Apidog’s runner adds a few capabilities worth knowing.

Data-driven testing. Import a CSV or JSON file into a test run to execute the same collection with different data sets. Each row becomes one iteration. This is equivalent to Postman’s data file feature, which is also paywalled in higher Postman tiers.

Custom iteration counts. Set a specific number of iterations for a test run without worrying about a monthly counter. Run your collection 500 times for a basic stress test if needed.

Smart Mock integration. While the runner is executing, it can interact with Apidog’s built-in mock server. This means you can run tests against mocked endpoints without spinning up a separate server, useful when testing client code against an API that isn’t built yet.

Scheduled runs. Set up automatic test runs on a schedule (hourly, daily, etc.) directly in Apidog without needing external cron jobs or CI triggers. The results appear in your project’s test history.

Postman’s Collection Runner restrictions are a practical blocker for teams that built CI pipelines and automated test workflows on the free tier. The most direct path forward is switching to a runner without usage limits. Apidog’s runner covers all the use cases Postman’s free tier restricted, and the CLI integration works in existing pipeline setups with a small configuration change.