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.

{
  "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.

{
  "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

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

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

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:

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):

{
  "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.