Integrate your test suite with the Application Inventory

Postman’s Application Inventory integrates with your existing UI test suite to validate API interactions and discover dependencies automatically. This guide walks through setting up your first application and running tests with network capture.

The exact integration flow depends on whether you’re connecting your workspace or linking an application to an existing workspace. The key difference is that for new workspace connections, the setup process is guided and happens automatically when you link your repository.

For existing workspace connections, you need to create an application from the Application Inventory and initialize your application using postman app init to complete the setup. To access the Application Inventory, click Home in the Postman sidebar and select Application Inventory.

Step 1: Link your application to a workspace

To connect your application repository to a Postman workspace, do the following:

1. Navigate to your Postman workspace.
2. If not already linked, connect your repository. From the Postman sidebar, click Files > Open folder. See Connect your Git project to your workspace for more details on Postman’s Git integration.
3. Complete the repository linking process.

If Postman detects Playwright tests in your code during the linking process, it automatically adds the application workspace tag to the Application Inventory.

Step 2: Install the Postman CLI

Install the latest version of the Postman CLI if you don’t already have it:

$
npm install -D postman-cli

Step 3: (Optional) Add API tests to your workspace

If you already have Postman Collections that represent your API contracts, add them to your workspace. To learn more about writing tests in Postman, see Write scripts to test API response data in Postman.

Step 4: Set up the capture plugin

Install the Postman Playwright plugin:

$
npm install -D postman-playwright

You can enable network capture in one of two ways. Postman recommends using withPostman because it requires only a one-time configuration change and works across all pages, contexts, and fixtures.

Recommended: Enable capture in your Playwright config

Add withPostman to your Playwright configuration:

1
// playwright.config.ts
2
import { defineConfig } from '@playwright/test';
3
import { withPostman } from 'postman-playwright';
4
5
export default withPostman(defineConfig({
6
  // Your existing Playwright configuration
7
}));

The withPostman function enables Playwright’s built-in JSON reporter and trace recording. The Postman CLI reads these artifacts (playwright-report.json and trace.zip) to analyze network traffic. No changes to your test code or custom data pipeline are required.

This approach requires only a one-time configuration change and provides broader capture coverage. However, test runs might take longer because Playwright must generate and store JSON reports and trace data.

Alternative: Enable capture in test files

You can also enable capture by wrapping Playwright’s test object with attachNetworkCapture:

1
import { test as baseTest, expect } from '@playwright/test';
2
import { attachNetworkCapture } from 'postman-playwright';
3
4
const test = attachNetworkCapture(baseTest);
5
6
test('has title', async ({ page }) => {
7
  await page.goto('https://playwright.dev/');
8
  await expect(page).toHaveTitle(/Playwright/);
9
});

This approach has lower runtime overhead because it doesn’t rely on Playwright trace artifacts. However, it requires updating each test file or creating a shared wrapper that re-exports the wrapped test object.

The attachNetworkCapture function only captures traffic from Playwright’s built-in page object. The function won’t capture traffic from pages created manually inside a test, such as pages created with browser.newContext() and context.newPage().

For example, network traffic from this manually created page won’t be captured by attachNetworkCapture:

1
test('creates a page manually', async ({ browser }) => {
2
  const context = await browser.newContext({
3
    recordVideo: { dir: './videos/' },
4
  });
5
6
  const page = await context.newPage();
7
});

Step 5: Initialize and run your application tests

Initialize your project as an Application Inventory application and run your tests.

Initialize your application

Run the initialization command to set up your project:

$
postman app init

This command does the following:

• Analyzes your project’s file structure.
• Allows you to select your test command, collections, and environment for your default target.
• Creates a postman.config.cjs file that links your application to Postman.
• Declares the UI test command, available targets, and filter rules for captured traffic.

Review the generated postman.config.cjs to ensure the configuration matches your project structure.

Filter out irrelevant traffic

To exclude irrelevant URLs, methods, and headers, update the filters configuration in postman.config.cjs:

1
filters: {
2
  urlPatterns: ['fonts.googleapis.com', 'localhost:3007', 'fonts.gstatic.com'],
3
  methods: [],
4
  headers: {},
5
},

Run the tests

Run your UI tests using the Postman CLI:

$
postman app test

For local testing, append CI=true to capture test results in the Application Inventory:

$
CI=true postman app test

Collections and environments are selected from the targets defined in postman.config.cjs. You can override them at runtime using the --target, --target-environment, and --target-collection options.

Results appear in the terminal. If you are logged in and the workspace has been added to the Application Inventory, results are also pushed to the Application Inventory.

(Optional) Bootstrap collections from captured traffic

If you don’t have existing API tests, you can generate collections from observed network traffic:

$
postman app test --capture-only

This workflow:

• Captures traffic during UI test runs.
• Generates a draft Postman Collection from observed requests.
• Uses AI to help create assertions from captured responses.
• Allows you to refine the tests and reuse them in future runs.

The same UI traffic that validates your APIs can become the foundation for a comprehensive API contract suite.

Next steps

You can view your test results and discovered dependencies in the Application Inventory. Click Home in the Postman sidebar and select Application Inventory.