- BFSIBanking, Financial Services & Insurance
- HealthcareComing soon
- ManufacturingComing soon
- Retail & E-CommerceComing soon
Postman
The world’s leading API platform — the API client that grew into a full API lifecycle platform (collaborate, test, design, govern), AI-forward with Postbot, and an India-origin success story (Bangalore, 2014). This hub is your complete intel file.
Buy through TechBag
Same software. Better outcome — at no extra cost.
Free, vendor-neutral, 30 minutes
The company, at a glance
Quick answer
Five intel pages. One API platform.
The complete Postman platform — every linked card is a full intel page, from the API client to enterprise governance.
API Client
Build, send & debug any API request.
The core — the standard API client millions of developers use to build, send, inspect and debug API requests across every protocol (HTTP, GraphQL, gRPC, WebSocket, SOAP), with easy authentication (OAuth 2.0, keys, tokens), variables and environments, scripts and code snippets. The fastest way to explore any API — and the on-ramp to the whole platform.
Workspaces & Collections
Organise & collaborate on APIs.
Postman's moat — Collections (organise requests into runnable, shareable, documentable groups) and Workspaces (shared spaces where a team's APIs, collections, environments and docs live, with roles and real-time collaboration), plus the public API Network (one of the largest public API hubs, where the world's APIs are published and discovered). Where team API work lives.
API Testing & Automation
Automated tests, monitors, CI/CD.
Turn saved requests into automated test suites — pre-request and test scripts (JavaScript assertions), the Collection Runner, running in CI/CD via the CLI (Newman), scheduled Monitors (uptime/health), data-driven and contract testing, and integrations (Jenkins, GitHub Actions). And Postbot writes tests for you. Confidence in your APIs, automated.
API Design & Documentation
Design-first APIs & living docs.
Design-first API development — design APIs with OpenAPI (the API Builder/Spec Hub), auto-generate documentation that stays in sync, spin up mock servers (test an API before it's built), version, and publish docs to the public API Network. The full design → mock → build → test → document → publish workflow, in one platform. (Honest: SwaggerHub/Stoplight are focused design-first specialists.)
Governance & Security
Govern & secure your API program.
Enterprise governance and security — enforce API design rules and standards across all your APIs (shift-left governance), get an API catalog/visibility of every API, secret scanning (catch leaked tokens/keys), and enterprise admin & access control (RBAC, SSO/SAML, SCIM, audit logs). At scale: consistency, security and control over your whole API program. (Honest: dev-time governance + admin — not a runtime API gateway like Apigee/Kong.)
AI — Postbot & building/testing AI agents
Platform & enginePostman is AI-forward: Postbot (an AI assistant in the client that writes tests, generates documentation, and helps debug and build requests from natural language), an AI Agent Builder (build AI agents that use APIs/tools), and tooling to build and TEST AI agents — working with LLM APIs and the emerging MCP (Model Context Protocol) — so you build, test and debug AI-agent integrations the same way you test any API. Postman sits right at the API×AI intersection. (AI capabilities evolve fast and vary by plan — validate for your use case.)
The API lifecycle — all in one platform
Platform & enginePostman spans the whole API lifecycle: client (send requests) → collections & workspaces (organise & collaborate) → design & mock (OpenAPI, mock servers) → test & monitor (automated tests, CI/CD, monitors) → document & publish (living docs, the API Network) → govern & secure (standards, secret scanning, RBAC). One platform, from a single request to an enterprise API program — on per-user plans (Free/Solo/Team/Enterprise).
Why “the client that became the platform” is the whole story
Calling APIs by hand is slow, and API work is scattered across teams. Postman bet onone platform for the whole API lifecycle, and collaboration as the moat— the standard API client that grew into a full API lifecycle platform (collaborate, test, design, govern), with Workspaces + the public API Network as the moat, and AI-forward (Postbot) doubled down on it.
The API Client
Where it all starts — the standard, most complete API client: build, send, inspect and debug requests across every protocol, with easy auth, variables/environments, scripts and snippets. The daily workhorse tens of millions of developers use, and the on-ramp to everything else.
Collaboration & the API Network
Postman's real moat — Workspaces (shared, live spaces where team APIs, collections and docs live) and the public API Network (where the world's APIs are published and discovered). It's where a huge share of the world's API work already happens — network effects and one source of truth.
The Full Lifecycle
Not just a client — a complete API lifecycle platform: design (OpenAPI) and mock, automated testing and monitors (CI/CD), living documentation, and enterprise governance and security. One integrated platform that scales from a solo developer to a Fortune 500 API program.
AI-Forward
Postbot (AI assistant — writes tests, docs, debugs), an AI Agent Builder, and tooling to build and TEST AI agents (LLM/MCP) — putting Postman at the API×AI intersection, where every AI agent talks to APIs and tools.
India-origin — Local via TechBag
Postman was founded in Bangalore in 2014 — a genuine India-origin success story — and retains major R&D there. It bills globally in USD; TechBag (Bengaluru-based) adds the local layer: plan scoping (mindful of the free-tier changes), procurement, INR/GST invoicing, local support, and honest advice on alternatives (Bruno/Insomnia).
Start with the API Client (the core) — then organise into Collections & Workspaces, add automated Testing, Design & document, and Govern at scale. One platform, all five angles.
Peer & market recognition
Every claim on this hub traces to one of these public signals.
The API platform
Leader
Workspaces + API Network
Where API work lives
Tens of millions of devs
500K+ companies (their figure)
Postbot + agent tooling
API × AI
Bangalore, 2014
India-origin success story
$5.6B (2021)
last-disclosed, historical
Design → test → govern
One platform
Local via TechBag
Plan scoping, INR/GST
The company in six figures
See the platform, hear the pitch
Exploring Postbot | Postman Level Up
Postbot — the AI assistant.
Postman Beginner's Course — API Testing
A full walk-through of Postman.
Trusted by 600,000+ organisations worldwide
Where Postman sits — the grids
Two company-level views you won’t find on any vendor site — tap any dot for the rationale. The category-level grid lives on the product page.
Postman Across Its Platform
Each dot is a Postman angle: competitive position vs category momentum.
The core — build, send & debug requests.
The Platform-Breadth × Ecosystem Map
Platform breadth & ecosystem vs the field — where Postman leads the API lifecycle.
The standard client + full API lifecycle + moat + AI.
Positions are TechBag’s illustrative synthesis of public review-platform standings and vendor documentation — not a reproduction of any analyst graphic. Verify before relying on it.
New to this? Learn it properly.
Zero-jargon starting points, in reading order. Each links into the deep education on the product page.
Where should you start with Postman?
Answer three questions; we’ll point you at the right starting product. No email required — this isn’t that kind of quiz.
1. What do you most need?
2. Which sentence sounds most like you?
3. What does success look like?
What is Postman (the API client)?
The standard way to build, send, inspect and debug any API request — every protocol, easy auth — and the on-ramp to the whole platform.
Read →Workspaces, Collections & the API Network
How teams organise and collaborate on APIs — and discover the world's APIs — Postman's real moat.
Read →API testing & automation, explained
Turn requests into automated test suites, run them in CI/CD (Newman) and on monitors — confidence in your APIs.
Read →Design-first APIs (OpenAPI)
Design APIs with OpenAPI, mock them before they're built, and keep docs always in sync — the design-first workflow.
Read →API governance & security
Enforce design standards across all APIs, scan for secrets, and control access (RBAC/SSO) — at enterprise scale.
Read →Postman vs Bruno vs Insomnia
The honest matrix — the standard full platform (Postman) vs open-source/offline (Bruno) vs a lighter client (Insomnia).
Read →The acronym decoder
Every term on these pages, in one place- Postman
- The world's leading API platform — build, test, document, share and manage APIs. Founded 2014 in Bangalore; HQ San Francisco with major R&D in Bangalore.
- API client
- The tool to build, send and inspect API requests — Postman's core, and the on-ramp to the whole platform.
- Collection
- An organised, runnable, shareable group of API requests — the core unit that turns ad-hoc calls into a reusable asset.
- Workspace
- A shared, collaborative space where a team's collections, environments, APIs and docs live — with roles and real-time collaboration.
- API Network
- Postman's public hub — one of the largest — where the world's APIs (Stripe, Twilio, and many more) are published and discovered in-app.
- Postbot
- Postman's AI assistant — writes tests, generates documentation, and helps debug and build requests from natural language.
- Newman
- Postman's command-line collection runner — run collections/tests in CI/CD pipelines.
- Monitor
- A scheduled run of a collection — for uptime/health checks and ongoing API monitoring.
- OpenAPI
- The standard API specification format — Postman supports design-first development, docs and mocks around it.
- Mock server
- A simulated API that returns example responses — so you can build against an API before it exists.
- Governance
- Enforcing API design standards/rules across all your APIs (shift-left), plus catalog/visibility — Postman's enterprise dev-time governance (not a runtime gateway).
- MCP
- Model Context Protocol — an emerging standard for connecting AI agents to tools/data; Postman supports building and testing MCP/LLM integrations.
Buy it like you’ve done this before
The procurement playbook TechBag runs with IT buyers — steps, licensing cheat-sheet, and the pitfalls that cost quarters.
Scope the plan (& team size)
Free (tightened), Solo (~$9), Team (~$19) or Enterprise (~$49) per user — which fits your team size and needs? TechBag scopes it (mindful of the free-tier changes) and — honestly — flags when a lighter/open-source alternative (Bruno/Insomnia) might suit.
Start with the client
Build and send requests (every protocol, easy auth), inspect responses, and save them into collections with variables and environments (dev/staging/prod). The daily workhorse — and the on-ramp.
Collaborate & test
Share collections in Workspaces (one source of truth), add automated tests, run them in CI/CD (Newman) and on monitors, and discover APIs on the public Network. From solo to team.
Design, document & govern
Design APIs (OpenAPI) with mock servers and living docs, and — at enterprise scale — enforce governance/standards, scan for secrets, and control access (RBAC/SSO). The full lifecycle.
Add AI (Postbot & agents)
Use Postbot to write tests and docs and debug faster, and Postman's agent-building and LLM/MCP tooling to build and test AI-agent integrations. The API × AI intersection.
Buy through the channel
Postman bills in USD with global support — TechBag adds the local layer: procurement, INR/GST invoicing, plan scoping and local support.
The licensing cheat-sheet
| Product | Licensing model | How you enter | Best for |
|---|---|---|---|
| Free | Per user — tightened limits | The API client, basic collections; limited runs/team features | Individuals & light use |
| Solo (~$9/user/mo) | Per user | For individual professionals — more than free | Solo developers |
| Team (~$19/user/mo) | Per user | Shared workspaces, more collaboration, higher limits | Teams collaborating on APIs |
| Enterprise (~$49/user/mo) | Per user | Governance, security (SSO/SCIM), RBAC, admin, support | Organisations — governance & scale |
| Add-ons / AI | By plan (verify current) | Postbot, agent building, LLM/MCP testing; capabilities vary by tier | AI-forward teams |
Per-user plans (Free/Solo/Team/Enterprise) — TechBag scopes the right plan for your team size and handles INR/GST (mindful of the tightened free tier).
Five pitfalls that cost buyers quarters
Assuming the free tier is still generous
Postman's FREE TIER WAS TIGHTENED (lower limits on collection runs and team features than before). It's still useful for individuals and light use, but for teams the paid plans (Solo/Team/Enterprise, per user) add up — and the change has genuinely annoyed some long-time users. Scope the right plan for your team size up front. TechBag scopes it honestly (and flags when a lighter/open-source alternative fits).
Overlooking the cloud-first / offline question
Postman is CLOUD-FIRST — it retired the offline 'Scratch Pad' (around 2023) — which raised data-residency and offline-workflow concerns for some teams. That's exactly what has driven interest in Bruno (open-source, offline, Git-friendly), Insomnia and Hoppscotch. If offline/open-source/data-residency matter to you, weigh those honestly. TechBag advises candidly — and can compare.
Treating Postman's governance as a runtime API gateway
Postman's Governance & Security is DEV-TIME governance (enforce design standards across your APIs, secret scanning, catalog/visibility) plus enterprise admin (RBAC, SSO/SCIM). It is NOT a runtime API GATEWAY (traffic management, rate-limiting, runtime security) — that's Apigee, Kong, AWS API Gateway. They're complementary layers. Don't expect Postman to replace a gateway. TechBag clarifies the scope.
Expecting a design-first specialist's depth
Postman does API design and documentation (OpenAPI, mocks, living docs) well — integrated into the full platform — but for the very deepest, pure design-first/OpenAPI workflows, focused specialists (SwaggerHub, Stoplight) go deeper. For most teams Postman's integrated design is the right trade (design → test → publish in one place); for a design-only shop, weigh a specialist. TechBag is honest about the fit.
Forgetting the India / billing layer
Postman is India-origin (Bangalore) but a global product — it bills in USD with global support, and there's no India-specific pricing. For Indian teams the practical gap is procurement, INR/GST invoicing, plan scoping and local support. That's exactly what TechBag (Bengaluru-based) adds — so you get the world's leading (and India-origin) API platform, locally scoped and supported.
The evaluation kit
The flagship intel page carries an 8-question vendor checklist and an automation-savings calculator:
Skip the homework entirely
Bring your device counts and current tool bills — a TechBag advisor models the whole decision for you.
Book a discovery call →The forces shaping this market
Six trends with momentum scores (TechBag’s read of analyst and market signals) — and what each means for your next decision.
Category momentum — estimated market growth
Illustrative CAGR synthesis**Directionally consistent with public analyst forecasts; verify exact figures before quoting. The takeaway: AI × APIs (agents, MCP) compounds fastest — exactly where Postman (Postbot + agent/LLM/MCP tooling) is placed.
API-first development
Software is increasingly built API-first — APIs are the product and the integration surface — so teams need tooling for the whole API lifecycle, not just one step.
What it means for you
Postman spans the whole lifecycle — client, collaboration, testing, design, documentation and governance — in one platform, which is exactly what API-first teams need.
AI × APIs (agents & MCP)
AI agents increasingly call APIs and tools (via LLM APIs and the emerging MCP), and developers want AI to help with API work — the API and AI worlds are converging.
What it means for you
Postman is AI-forward — Postbot assists API work, and its agent-building and LLM/MCP tooling let you build and test AI-agent integrations — right at the API×AI intersection.
Collaboration & internal API platforms
APIs are a team activity — organisations build internal API platforms and need a shared, governed place for their APIs, not scattered copies.
What it means for you
Postman's moat is exactly this — Workspaces (a shared source of truth) and the public API Network (discovery) — where team API work lives.
Shift-left testing & governance
Teams push testing and governance earlier (shift-left) — automated tests in CI/CD and design-standard enforcement before problems ship.
What it means for you
Postman supports automated testing in CI/CD (Newman) and monitors, plus dev-time governance (enforce design standards across all APIs) — shift-left, in one platform.
Open-source & offline pushback
Some developers push back on cloud-first, per-seat SaaS tooling — wanting open-source, offline-first, Git-friendly alternatives (a real trend behind Bruno's rise).
What it means for you
Postman is cloud-first with a tightened free tier — a genuine consideration; TechBag advises honestly and can compare Bruno/Insomnia/Hoppscotch where they fit.
India as a software-product powerhouse
India-origin software products are increasingly global leaders — Postman (Bangalore, 2014) is a flagship example, and Indian teams build API-first products at scale.
What it means for you
Postman's India origin and Bangalore R&D give it strong local relevance — and TechBag adds the local scoping, procurement and INR/GST layer for Indian teams.
Questions buyers ask about Postman
Ready to shortlist Postman?
Open any of the five intel pages for the deep dive, or let a TechBag advisor build the case with you — plan scoping (mindful of the free-tier changes), procurement, INR/GST invoicing and honest alternative advice (Bruno/Insomnia) included.
Stats, positions and figures are illustrative syntheses of public materials; verify before purchase.