- Installation and updates
- Sending your first request
- Creating the first collection
- Navigating Postman
- Keyboard Shortcuts
- Postman account
- New button
- Troubleshooting In-app Issues
- Customizing Postman
- Find and Replace
- Troubleshooting API requests
- Debugging and logs
- Authorizing requests
- Capturing HTTP requests
- Generate code snippets
- Making SOAP requests
- Working with Tabs
- Using GraphQL
- Visualize API responses
- Intro to collections
- Creating collections
- Sharing collections
- Managing collections
- Requesting access
- Using Markdown for descriptions
- Data formats
- Working with OpenAPI
- Commenting on collections
- Version Control for Collections
- Intro to scripts
- Pre-request scripts
- Test scripts
- Test examples
- Branching and looping
- Postman Sandbox
- Postman Sandbox API reference
- Intro to collection runs
- Starting a collection run
- Using environments in collection runs
- Working with data files
- Running multiple iterations
- Building workflows
- Sharing a collection run
- Debugging a collection run
- Command line integration with Newman
- Integration with Jenkins
- Integration with Travis CI
- Newman with Docker
- Documenting your API
- Viewing documentation
- Authoring your documentation
- Publishing your docs
- Custom documentation domains
- Intro to Monitoring
- Setting up a monitor
- Viewing monitor results
- Monitoring APIs and websites
- Set up integrations to receive alerts
- Pricing for monitors
- Troubleshooting monitors
- FAQs for monitors
- Intro to mock servers
- Setting up a mock server
- Mocking with examples
- Mocking with the Postman API
- Matching algorithm
- Introduction to APIs
- Managing APIs
- Sharing APIs and managing roles
- The API Workflow
- Validating Elements Against Schema
- Versioning APIs
- Reporting FAQs
- Viewing and analyzing APIs
- Intro to Workspaces
- Creating Workspaces
- Managing Workspaces
- Using Workspaces
- Sharing collections in Workspaces for version 5
- Viewing changelogs and restoring collections
- What is Postman Pro
- Purchasing Postman Pro
- Upgrading to Postman Pro from a trial team
- Team Settings
- Changing your plan
- Managing your team
- Migrating to Postman v7
- Roles and permissions
- Intro to Enterprise
- Purchasing Postman Enterprise
- Running Postman monitors using static IPs
- Intro to SSO
- Configuring SSO for a team
- Logging in to an SSO team
- Configuring Microsoft AD FS with Postman SSO
- Setting a custom SAML in Azure AD
- Setting up custom SAML in Duo
- Setting up custom SAML in GSuite
- Setting up custom SAML in Okta
- Setting up custom SAML in Onelogin
- Setting up custom SAML in Ping Identity
- Audit logs
- Publishing API documentation
The API Workflow
Once you create an API in Postman, you can link it with other elements, create/import a schema, and be able to perform many other useful tasks. For instance, you will be able to link mock servers, documentation and environments to an API and even be able to use the version tagging feature to tag elements with specific versions (except environments). You will also be able to link test suites, integration tests, and contract tests to specific versions of an API using version tagging.
This section describes the following topics:
In this section, you can define the structure of your API by creating a new schema or importing it from an existing file. You can then define and edit the schema and even change its format and language in the schema editor. You can also generate a collection from the schema. The following section describes two topics:
To create a new schema, click Add Schema and select Create New. The schema editor opens with default options selected:
The default schema format is 'Open API 3.0' and JSON the default language. To select a different schema, click the down arrow and select a format from the list.
The schema editor provides you options to beautify the content, wrap text, copy text, and search. Once you're done creating your schema, click Save. After you save the changes, the Generate Collection button is enabled, as illustrated below:
This is a powerful feature that will let you jump-start your API workflow by creating collections from a schema. You can start by creating a schema or an API in Postman (sort of API-first development approach), and then start generating collections from the schema. It is so much easier for you to start working with your Schemas in Postman and use it for different workflows (like mocking, documentation, testing and monitoring).
The Generate Collections button generates a collection which adheres to your schema and puts it in your workspace sidebar. Postman not only lets you generate a collection but it also enables you to add the collection as documentation, a test suite, and an integration or a contract test - all in one go. Once you click the Generate Collections button, the following screen appears:
People who have repetitive workflows can import their schemas in Postman and can generate collections on the run.
To import an existing schema from a file, click Add Schema and select Import file. Navigate to and select the file, then click open. The schema populates in the editor. You can now edit the schema and save your changes.
Schema formats currently supported in Postman:
- OpenAPI 3.0
- OpenAPI 2.0
- OpenAPI 1.0
- RAML 0.8
- RAML 1.0
- GraphQL SDL
Note: Multi-file variants of schemas are currently not supported.
After adding a schema, you can develop your API by using version tagging to link an element like mock servers, documentation, or environments to a specific version of your API.
Note: When you add documentation, test suites, mocks, monitors, environments, etc., only the elements in the current workspace will be visible. If they are already linked to an API, they will not be shown here.
This section describes the following topics:
- Adding documentation
- Adding an environment
You can link mock servers running on a collection to an API. From the Develop tab, you can either create a new mock server, add an existing mock server, or edit a mock server. This section describes the following topics:
From the Develop tab, click Add Mock Server.
In the above screen, select Create new mock server. The following screen appears:
Click Generate collection from schema to create a mock server on the collection you generated from your schema. Specify a name in Name your collection field and click Generate collection and continue.
From the Develop tab, click Add Mock Server.
In the above screen, select Add existing mock server. The following screen appears:
In the above screen, select a mock server in your workspace from the list and click Add Mock Server. Only available mocks will be shown in this list.
The mock server is now added to the API and appears as illustrated below:
To understand how versioning influences mock servers, refer to the section
To add a mock server to a specific version of your collection, refer to the section Setting up a mock server
You can edit existing mock servers by navigating to the API > Develop > Mock Servers Servers, then hovering on the mock you'd like to edit and selecting the pencil icon.
This will open a web page on the Postman Dashboard where you can edit the following parameters of your mock server:
- the name of the mock server
- the collection to mock
- the version tag
- the environment
You can also make the mock server private by ticking the Make this mock server private box.
Click Save changes to save your changes or Cancel if you want to cancel.
You can also copy the URL of your mock server directly to your clipboard by clicking Copy URL.
You can link the documentation generated from your collections to an API using version tagging. In the Develop tab, click Add documentation. The following screen opens:
In the above screen, select a corresponding collection from the list with the documentation you want to link and click Add Documentation. The documentation is now added to the API. Only available collections will be shown in this list.
To understand how versioning influences documentation, refer to the section Versioning an API.
To learn more about generating and viewing version-specific documentation, refer to the section Publishing version-specific documentation.
You can link specific environments in your workspaces to an API using version tagging. In the Develop tab, click Add an environment. The following screen opens:
In the above screen, select an environment from the list and click Add an environment. Only available environments will be shown in this list. The environment is now added to the API.
You can create collections to test your API by creating a collection as a test suite, integration test, or contract test. Then, those collections can be linked to a specific version of an API using version tagging. This section describes the following topics:
As testing is an integral part of API life cycle, Postman lets you link collections in your workspace as test suites to an API using version tagging.
In the Test tab, click Add a test suite if you'd like to test your API endpoints for specific behavior. The following screen opens:
In the above screen, select a corresponding collection from the list and click Add Test Suite. Only available collections will be shown in this list. The test suite attached to the collection is now added to the API.
In the Test tab, click Add integration tests to check if your endpoints work as expected when combined with other APIs or services. The following screen opens:
In the above screen, select a corresponding collection from the list and click Add Integration Test. The integration tests attached to the collection are now added to the API. Only available collections will be shown in this list.
If you're writing tests to ensure your APIs are working according to their specification, you can use Contract tests. In the Test tab, click Add contract tests. The following screen opens:
In the above screen, select a corresponding collection from the list and click Add Contract Test. The contract tests attached to the collection are now added to the API. Only available collections will be shown in this list.
You can link your monitors running on collections in your current workspace with an API. From the Observe tab, you can either create a new monitor or add an existing monitor. This section describes the following two topics:
From the Observe tab, click Create new monitor. The following screen opens:
Under Select requests to monitor, specify a name in Name your collection field and click Generate collection and continue.
You can also create a new monitor on an existing collection. To do this, choose an existing collection under the Use an existing collection tab and select a collection.
Click Select collection and continue button.
You can also add an existing monitor to the API.
In the Observe tab, click Add a monitor and select Add existing monitor.
In the above screen, select a corresponding monitor from the list and click Add Monitor. Only available monitors will be shown in this list. The monitor attached to the collection is now linked to the API.
To add a monitor to a specific version of your collection, refer to the section Setting up monitors.
For more information on APIs, see: