# Postman Public API Network Scraper (`automation-lab/postman-public-api-network-scraper`) Actor

Search the Postman public API network and export collection, workspace and request cards with public URLs, publisher context, visible counters and endpoint snippets for API catalog discovery.

- **URL**: https://apify.com/automation-lab/postman-public-api-network-scraper.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.22 / 1,000 item extracteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Postman Public API Network Scraper

Refresh a public API catalog from the **Postman public API network**. Search a keyword and export visible collection, workspace and request result cards with names, public links, descriptions, publisher context, counters and request endpoint snippets.

This Actor is for API ecosystem researchers, integration teams and developer-relations analysts who need structured discovery records rather than manually copying search cards. It does not invoke APIs, export collection contents or access private workspaces.

### What you get

One dataset row is one unique public search card. Choose all supported types together or restrict discovery to collections, workspaces or requests.

- Collections include names, available summaries/descriptions, publisher and workspace context, and visible request/fork/watcher counts.
- Workspaces include names, descriptions, public links and available collection/view counts.
- Requests include the visible HTTP method and endpoint snippet, plus parent collection/workspace context where exposed.
- Every row includes the submitted search query and extraction timestamp.

All are the same search-card record format. Fields that the source does not expose are `null`; categories default to an empty array. No private API export is included.

### Who is it for?

API ecosystem analysts can refresh discovery catalogs; integration engineers can review public endpoint snippets; developer-relations teams can map publisher and workspace context. These records support manual assessment, not guaranteed API availability.

### Why use this Actor?

Build a repeatable discovery snapshot for competitor ecosystem research, integration planning or an internal API directory. Public source IDs make downstream deduplication easier, while publisher/workspace context helps distinguish similarly named APIs.

The Actor uses anonymous public search data without a login or user-supplied API key. It does not spend time downloading media or invoking discovered endpoints. A global limit and bounded pagination keep a discovery task controlled.

### Get started

1. Enter a relevant search term, such as `stripe` or `github`.
2. Keep `entityType` as `all`, or select one card type.
3. Choose a result cap. Start with 30 cards.
4. Run the Actor and inspect the dataset table.
5. Export JSON, CSV or Excel through Apify, or consume the dataset API.

```json
{
  "searchQuery": "stripe",
  "entityType": "all",
  "maxItems": 30
}
```

### Input parameters

| Parameter | Default | Meaning |
| --- | --- | --- |
| `searchQuery` | Required | Trimmed 1–200 character relevance-search text submitted to Postman. |
| `entityType` | `all` | `all`, `workspace`, `collection` or `request`. Restricts upstream indices and output card types. |
| `maxItems` | `30` | Global maximum unique saved cards, integer 1–600. Zero is invalid. |

Postman determines matching across names, descriptions and request metadata. This is not an exact-phrase, substring-only or whole-field equality filter. Case handling and ranking belong to the upstream search service. Search results can change between runs.

Unknown fields and invalid values fail explicitly. There is no URL-input route, proxy selection, login, category filter or separate endpoint invocation option.

### Postman public API network coverage

Search covers public workspace, collection and request cards only. APIs/specifications, environments, publisher-profile results and flows are not separate exported card types. Publisher information is context attached to supported cards.

Pagination requests up to 20 candidates per type per page. The source's bounded search window permits offsets 0 through 200, so each type has at most 220 candidates before deduplication and public-scope checks. A single-type query may therefore stop below a higher `maxItems` value. The all-type mode has one global cap, not a separate cap for each type.

The Actor stops at its item cap, source exhaustion, a page with no new acceptable cards, the 11-page search window, a billing limit or run timeout. It does not promise a complete mirror of Postman or exhaustive keyword coverage.

### Extracted fields

| Field | Meaning |
| --- | --- |
| `recordId`, `entityType`, `name`, `url` | Stable source identity, card kind, visible name and public Postman link. |
| `description`, `summary` | Visible text; may already be truncated by Postman. |
| `publisherName`, `publisherHandle`, `publisherUrl` | Available publisher context and profile link. |
| `isPublisherVerified` | Source publisher-verification flag, not our endorsement. |
| `workspaceId`, `workspaceName`, `workspaceUrl` | Workspace context, or the workspace card itself. |
| `collectionId`, `collectionName` | Collection identity for a collection or parent of a request. |
| `method`, `endpoint` | Public request snippet only. Other card types contain `null`. |
| `views`, `forkCount`, `watcherCount` | Source-visible counters when supplied. Missing is not zero. |
| `requestCount`, `collectionCount` | Visible child counts where available. |
| `categories` | Available string category labels; often empty. |
| `updatedAt` | Source update timestamp, unmodified; not guaranteed present or recent. |
| `searchQuery`, `scrapedAt` | Submitted trimmed query and UTC extraction timestamp. |

### Output example

The following excerpt is from a public Stripe Developers request card returned during testing; other fields follow the table above.

```json
{
  "entityType": "request",
  "name": "Create a file",
  "url": "https://www.postman.com/stripedev/workspace/stripe-developers/request/665823-1c8a66ad-8392-445a-b272-ad4aaf10e53a",
  "publisherName": "Stripe Developer APIs",
  "workspaceName": "Stripe Developers",
  "collectionName": "Stripe API [06-30-2023]",
  "method": "POST",
  "endpoint": "https://files.stripe.com/v1/files",
  "searchQuery": "stripe"
}
```

Endpoint strings may contain `{{variables}}`; they are discovery snippets, not tested URLs. The Actor never calls these endpoints or verifies their authentication requirements.

### How much does it cost to discover Postman public API cards?

Pay per event: a one-time **$0.001 start fee** plus one **item** event per unique public result card saved. A workspace, collection or request card uses the same item event; there is no extra charge for counters, publisher context or endpoint snippets.

| Apify plan | Price per card |
| --- | --- |
| Free | $0.002346 |
| Bronze | $0.00204 |
| Silver | $0.0015912 |
| Gold, Platinum, Diamond | $0.001224 |

At Bronze, 1 card costs $0.00304, 30 cards cost $0.0622, and 100 cards cost $0.205 including the start fee. A valid no-result search still incurs the start fee, but no item events. Duplicate, excluded or failed cards are not billed as results. Check the current Store pricing before scheduling recurring runs.

### Limits and failure behavior

Deduplication is by card type plus source ID within one run. A request and its parent collection are different discovery cards, not duplicates. No cross-run state or built-in historical comparison is maintained.

Transient network errors, HTTP 429 and server errors receive up to three attempts per page with short exponential backoff. Permanent authentication, forbidden, malformed-response and other client errors stop the run rather than pretending the search was empty. Saved rows from a failed or timed-out run are partial results.

The run's `SUMMARY` key-value record contains saved/scanned counts, page count, request attempts, retries, response bytes and billing-stop information. `exhausted: false` with fewer rows than requested can indicate the search-window limit rather than complete source exhaustion.

### Integrations

- Send dataset rows to a spreadsheet for an analyst-maintained API catalog.
- Schedule a query and compare exported IDs/timestamps in your own database for recurring ecosystem research. This Actor does not implement alerts or change detection itself.
- Use Make, n8n or Zapier to copy successful run output into an internal knowledge base.
- Join request snippets to parent collections using `collectionId`; use public links for manual review before adopting an integration.

Keep full exports in storage rather than pasting an entire large dataset into a language model.

### API usage

Set `APIFY_TOKEN` securely in your environment. Do not put tokens in source control.

#### cURL

```bash
curl -X POST \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  'https://api.apify.com/v2/acts/automation-lab~postman-public-api-network-scraper/runs' \
  --data '{"searchQuery":"stripe","entityType":"all","maxItems":30}'
```

This returns run metadata, not dataset rows. Follow the returned run ID until terminal; after success read its `defaultDatasetId` through the dataset API.

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/postman-public-api-network-scraper').call({
  searchQuery: 'github', entityType: 'collection', maxItems: 30,
});
if (run.status !== 'SUCCEEDED') throw new Error(`Run ${run.id}: ${run.status}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems({ limit: 30 });
console.log(items);
```

#### Python

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/postman-public-api-network-scraper').call(
    run_input={'searchQuery': 'stripe', 'entityType': 'workspace', 'maxItems': 30})
if run['status'] != 'SUCCEEDED':
    raise RuntimeError(f"Run {run['id']}: {run['status']}")
print(client.dataset(run['defaultDatasetId']).list_items(limit=30).items)
```

### MCP setup

Use a stable Actor-specific hosted endpoint:

```bash
claude mcp add --transport http apify \
  'https://mcp.apify.com?tools=automation-lab/postman-public-api-network-scraper'
```

Equivalent **Claude Desktop**, **Cursor**, and **VS Code** client configuration (complete the client's normal Apify authentication flow; each client's wrapper/configuration file can differ):

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/postman-public-api-network-scraper"
    }
  }
}
```

Example prompt: “Find 20 public Postman collection cards relevant to Stripe; summarize publisher and workspace context without invoking endpoints.”

Discover actual tool names and input schemas with `tools/list`. Actor selection also exposes run/data helpers, not exactly one tool. With authorized execution, start once and retain the returned run ID and storage IDs. These are metadata, not rows. A call waits at most 45 seconds; if pending, check the same run with 2/4/8-second backoff capped at 10 seconds and a 120-second total deadline. On client timeout recover the known run instead of blindly starting another. Report pending/failure honestly.

After success read bounded dataset pages: for example 20 rows at a time, at most 100 rows and 64 KiB of serialized UTF-8 data admitted to model context, whichever comes first. Enforce bytes host-side before model injection; disclose omitted/oversized rows, continuation offset and partial results. If the client cannot enforce byte limits, do not claim a hard guarantee or request an unbounded export. Full datasets remain in downstream storage. No universal token-savings claim is made.

### Legality and responsible use

Use public records responsibly and respect Postman's terms, applicable law and publishers' rights. Public visibility does not grant a license to redistribute API documentation or use protected endpoints. Do not submit credentials or confidential search terms. This Actor is independent and is not endorsed by Postman or the named publishers.

Failed operations send sanitized diagnostic input, exceptions and Actor/build/run IDs to our private GlitchTip service for repair. Secret fields and URL queries are removed; reports are retained for 30 days. Public search text can still be part of sanitized diagnostic input, so avoid confidential terms.

No AI model is used during extraction or to generate dataset output. Postman receives your search text and ordinary connection metadata. Apify hosts the run, logs, dataset and summary; results remain in your run storage according to your account retention settings. Delete datasets/key-value stores and runs through Apify when no longer needed; the Actor creates no independent cross-run cache. Our private GlitchTip is the only additional diagnostic recipient, with 30-day report retention. Do not include confidential terms, and review public descriptions for personal information before redistributing exports.

For support, open an issue on this Actor's Apify Store page and include the run ID, expected result and a non-secret example query.

### FAQ and troubleshooting

**Why fewer results than requested?** The cap is an upper bound. Source exhaustion, the per-type search window, deduplication and public-scope exclusions can reduce counts. Try another relevant query; do not interpret a capped snapshot as a complete inventory.

**Why is a counter or publisher missing?** The source does not expose every field on every card. `null` means unavailable, not zero or false.

**Does it download or execute collections?** No. It exports visible search-card metadata only. It never sends discovered API requests or provides private collection exports.

**Why did a run fail with partial rows?** An upstream error or unexpected response is not a legitimate empty result. Retain the run ID and inspect its log; any saved rows are incomplete. Transient retries are bounded rather than endless.

**Can I monitor changes?** Schedule runs through Apify and compare snapshots externally. Built-in history, alerts and complete change detection are not provided.

### Related discovery workflows

This is a standalone Postman corpus. For other public developer catalogs, search the automation-lab Store profile for API-directory Actors and compare their documented source scope; results from a different directory are alternative datasets, not a substitute for Postman collection exports.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/postman-public-api-network-scraper/changelog.md

# Actor input Schema

## `searchQuery` (type: `string`):

1–200 characters, trimmed before submission to Postman's public relevance search. Postman controls matching across names, descriptions and request metadata; this is not an exact-phrase or whole-field filter.

## `entityType` (type: `string`):

all searches workspace, collection and request cards together. Select one type to restrict upstream indices and exported rows. Endpoint snippets are available only on request cards; no endpoint is called.

## `maxItems` (type: `integer`):

Global cap on unique exported cards for this query, after public-scope checks and deduplication by type and ID. Default 30, range 1–600; zero is invalid. Stops earlier at source exhaustion, repeated pages, the 11-page upstream search window (at most 220 candidates per type), runtime or billing limits. Not a completeness guarantee.

## Actor input object example

```json
{
  "searchQuery": "stripe",
  "entityType": "all",
  "maxItems": 20
}
```

# Actor output Schema

## `dataset` (type: `string`):

Unique public collection, workspace and request cards.

## `summary` (type: `string`):

Search request/page counters, retries, output and stop information.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchQuery": "stripe",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/postman-public-api-network-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchQuery": "stripe",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/postman-public-api-network-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQuery": "stripe",
  "maxItems": 20
}' |
apify call automation-lab/postman-public-api-network-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/postman-public-api-network-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/HlVYETAdKk5ydma9F/builds/Rls9XtsW8Q5bF0a2t/openapi.json