Apidog Docs
πŸ‡ΊπŸ‡Έ English
  • πŸ‡ΊπŸ‡Έ English
  • πŸ‡―πŸ‡΅ ζ—₯本θͺž
HomeLearning CenterSupport CenterAPI References
HomeLearning CenterSupport CenterAPI References
Discord Community
Slack Community
X / Twitter
πŸ‡ΊπŸ‡Έ English
  • πŸ‡ΊπŸ‡Έ English
  • πŸ‡―πŸ‡΅ ζ—₯本θͺž
  1. Create requests
  • Apidog Learning Center
  • Get started
    • Introduce Apidog
    • Basic concepts in Apidog
    • Navigating Apidog
    • Quick Start
      • Overview
      • Specify a new endpoint
      • Make a request to the endpoint
      • Add an assertion
      • Create a test scenario
      • Share your API documentation
      • Explore more
      • Send a request and save as an endpoint
    • Migration
      • Overview
      • Manual import
      • Scheduled import
      • Import options
      • Export data
      • Import from...
        • Import from Postman
        • Import OpenAPI (Swagger) spec
        • Import cURL
        • Import Markdowns
        • Import from Insomnia
        • Import from apiDoc
        • Import .har file
        • Import WSDL
  • Design APIs
    • Overview
    • Create a new API project
    • Endpoint basics
    • Components
    • Common fields
    • Global parameters
    • Endpoint change history
    • Batch endpoint management
    • Configure multiple request body examples
    • Schemas
      • Overview
      • Generate Schemas from JSON etc.
      • Build a schema
      • Create a new schema
    • Security schemes
      • Overview
      • Create a security scheme
      • Use the security scheme
      • Security scheme in online documentation
    • Advanced features
      • Custom endpoint fields
      • Import endpoints as test steps
      • Endpoint status
      • Appearance of parameter lists
      • Endpoint unique idenfication
  • Develop and Debug APIs
    • Overview
    • Generate requests
    • Send requests
    • Endpoint cases
    • Dynamic values
    • Validate responses
    • Design-first Mode & Request-first Mode
    • Generate code
    • Environments & variables
      • Overview
      • Using variables
      • Environments & services
    • Vault secrets
      • Overview
      • HashiCorp Vault
      • Azure Key Vault
      • AWS Secrets Manager
    • Pre/Post processors
      • Overview
      • Assertion
      • Extract variable
      • Wait
      • Database operations
        • Overview
        • MongoDB
        • Redis
        • Oracle Client
      • Using scripts
        • Overview
        • Postman scripts reference
        • Pre processor scripts
        • Post processor scripts
        • Public scripts
        • Calling other programming languages
        • Using JS libraries
        • Visualizing responses
        • Script examples
          • Assertion scripts
          • Using variables in scripts
          • Using scripts to modify request messages
          • Other examples
    • Dynamic values Modules
  • Mock API data
    • Overview
    • Smart mock
    • Custom mock
    • Mock priority sequence
    • Mock scripts
    • Cloud mock
    • Self-hosted runner mock
    • Mock language (Locales)
  • Automated tests
    • Overview
    • Test reports
    • Test scenarios
      • Create a test scenario
      • Pass data between requests
      • Flow control conditions
      • Import endpoints/endpoint cases from other projects
      • Sync data from endpoints/endpoint cases
      • Export test scenarios
    • Run test scenarios
      • Run a test scenario
      • Data-driven testing
      • Run test scenarios in batch
      • Scheduled tasks
      • Manage the runtime environment of APIs from other projects
    • Test APIs
      • Integration testing
      • Performance testing
      • End-to-end testing
      • Regression testing
    • Apidog CLI
      • Overview
      • Installing and running Apidog CLI
      • Apidog CLI Options
    • CI/CD
      • Overview
      • Integrate with Jenkins
      • Integration with Gitlab
  • Publish API Docs
    • Overview
    • API Technologies Supported
    • Quick share
    • View the API documentation
    • Publish docs sites
    • Folder tree settings
    • Custom layouts
    • Visibility settings
    • Endpoint SEO settings
    • Custom domain
    • Embedding values in document URLs
    • Documentation Search
    • Integrating Google Analytics with Doc Sites
    • CORS Proxy
    • API Versions
      • Overview
      • Create API versions
      • Publish API versions
      • Share endpoints with API versions
  • Send requests
    • Overview
    • gRPC
    • Use request proxy agents for debugging
    • SOAP/WebService
    • GraphQL
    • WebSocket
    • Socket.IO
    • SSE debugging
    • Create requests
      • Request History
      • Request basics
      • Parameters and body
      • Request headers
      • Request settings
      • HTTP/2
    • Authentication and authorization
      • Overview
      • CA and client certificates
      • Authorization types supported by Apidog
      • Digest Auth
      • OAuth 1.0
      • OAuth 2.0
      • Hawk Authentication
      • Kerberos
      • NTLM
      • Akamai EdgeGrid
    • Response and cookies
      • Overview
      • API response in Apidog
      • Create and send cookies
      • Debug requests
      • Save the request as an endpoint
  • Branches
    • Overview
    • Create a new sprint branch
    • Test APIs in a branch
    • Design API in a branch
    • Merge sprint branches
    • Manage sprint branches
  • Apidog MCP Server
    • Overview
    • Conntect API Specification within Apidog Project to AI via Apidog MCP Server
    • Conntect Online API Documentation Published by Apidog to AI via Apidog MCP Server
    • Conntect OpenAPI Files to AI via Apidog MCP Server
  • Best practices
    • How to handle API signatures
    • How to access OAuth 2.0 protected APIs
    • Apidog collaboration workflow
    • Managing authentication state in Apidog
  • Administration
    • Onboarding Checklist
      • Basic Concepts
      • Onboarding Guide
    • Managing Teams
      • Managing Teams
      • Managing Team Members
      • Member Roles & Permission Settings
      • Team Activities
      • Team Resources
        • General Runner
        • Team Variables
        • Request Proxy Agent
      • Real-time Collaborations
        • Team Collaboration
    • Managing Projects
      • Managing Projects
      • Managing Project Members
      • Notification Settings
      • Project Resources
        • Database Connection
    • Managing Organizations
      • Single Sign-On (SSO)
        • SSO Overview
        • Configure Microsoft Entra ID
        • Configure Okta
        • Configure SSO for an Organization
        • Managing user accounts
        • Mapping Groups to Teams
      • SCIM Provisioning
        • Intro to SCIM Provisioning
        • Microsoft Entra ID
        • Okta
      • Organization Resources
        • Self-hosted Runner
  • Billing
    • Overview
    • Credits
    • Unable to use credit cards?
    • Managing subscriptions
    • Upgrade plan
  • Data & Security
    • Where is Apidog's data stored, and how is data security ensured?
    • How is user data stored? Will this data be public? Or will it be private? Will all data be stored in the cloud?
    • When sending requests, do they go through the Apidog server? Is data security ensured?
  • Add-ons
    • API Hub
    • Apidog Intellij IDEA plugin
    • Browser Extension
      • Chrome
      • Microsoft Edge
    • Request Proxy
      • Request proxy in Apidog web
      • Request proxy in shared docs
      • Request proxy in Apidog client
  • Account & preferences
    • Language settings
    • Data backup
    • Network proxy configuration
    • Hot keys
    • Updating Apidog
    • Generate OpenAPI access token
    • Deleting account
    • Account settings
  • References
    • API-Design First Approach
    • Apidog OpenAPI/Swagger Specificaiton Extensions
    • JSONPath
    • XPath
    • Regular Expressions
    • JSON Schema
    • CSV File Format
    • Install Java Environment
    • Runner deployment environment
    • Apidog flavored Markdown
  • Apidog Europe
    • Apidog Europe
  • Support Center
  1. Create requests

Parameters and body

When working with APIs, it's essential to understand how to send various types of data with your requests. Apidog provides a user-friendly interface to help you construct and send API requests with different parameters and body data types.

Parameters#

Parameters allow you to send additional information to the server. Apidog supports two main types of parameters: Query params and Path params.

Query params#

Query parameters are appended to the end of the URL after a question mark (?) and are separated by ampersands (&). They are used to send optional or additional data to the server. In Apidog, you can easily add and manage query parameters for your API requests.
In Apidog, you have two convenient ways to add query parameters to your API requests:
1.
Directly in the URL: You can append query parameters directly to the end of the URL in the address bar. For example:
https://api.example.com/users?page=1&limit=10
2.
Using the Query Params section: Apidog provides a dedicated Query Params section below the URL input field. Here, you can add, edit, and remove query parameters using a user-friendly interface. The parameters you add in this section will be automatically appended to the request URL.

Equal sign in query params#

In some special cases, query parameters may not appear as key-value pairs. For example, a request URL might be like
https://api.example.com/users?available
In this case, available can serve as a parameter with an empty value. When the value is empty, Apidog automatically omits the equal sign between the key and value.
image.png
If you don't want to omit this equal sign, you can manually change it to "Add an equal sign".

Path params#

Path parameters are part of the URL path itself and are typically used to identify a specific resource. They are denoted by placeholders in the URL, usually enclosed in curly braces {}.
Example:
https://api.example.com/users/{userId}
In Apidog, you can define path parameters in the API URL as shown above, and they will appear in the path parameter section below. You can fill in the values for path parameters in the path parameter section, and when the request is sent, {param} will be replaced with the actual value. This feature is particularly useful when testing RESTful APIs that use resource identifiers in the URL.
image.png
If you need to use variables in path parameters, the recommended way is to first use {param} in the URL, and then use {{variable}} in the value of the param.

Body#

The request body is used to send data to the server as part of a POST, PUT, or PATCH request. Apidog supports various body data formats to accommodate different API requirements.

form-data#

Form-data is a way to send key-value pairs, similar to submitting an HTML form. This format is particularly useful when you need to upload files along with other data.
image.png
The form-data type body will be displayed as multipart/form-data in the request. For each parameter in the body, you can choose its type, such as string, integer, etc.
If you need to send a JSON in form-data, you need to set the parameter type to string, and then fill in the JSON in the string field.
If you need to send a file in the request, select the type as file, then click "Upload" to choose a local file.
Apidog only sends the file in the request but does not save the file in the cloud. Therefore, during team collaboration, others can see this request but cannot directly send this file. You need to transfer this file to your colleagues through other means for them to be able to send it.

x-www-form-urlencoded#

This format is similar to query parameters but sent in the request body. It's commonly used for submitting simple forms without file uploads. In Apidog, you can easily add and edit x-www-form-urlencoded data using a key-value interface.

JSON#

JSON (JavaScript Object Notation) is a popular data format for API requests and responses. Apidog offers a JSON editor with syntax highlighting and validation, making it easy to construct and edit JSON payloads for your API requests.
If you wish to add comments in JSON, you can enable "JSON with comments support" in Settings - General settings - Feature settings - Advanced settings. When sending JSON, these comments will be automatically removed.

XML#

XML (eXtensible Markup Language) is another common data format used in API communications. Apidog supports XML payloads, allowing you to send structured data in XML format with your API requests.

raw#

The raw option allows you to send any custom data format in the request body. This is useful when working with APIs that expect specific data structures or formats not covered by the other options.

binary#

Binary data can be sent using this option, which is particularly useful when uploading files or working with APIs that expect binary payloads. Apidog allows you to select and send binary files as part of your API requests.

GraphQL#

For APIs using GraphQL, Apidog provides a dedicated GraphQL editor. This feature allows you to construct and send GraphQL queries and mutations, complete with syntax highlighting and autocompletion.
Check out GraphQL in Apidog for more information on GraphQL.

msgpack#

MessagePack (msgpack) is a binary serialization format that's more compact and faster than JSON. Apidog supports sending msgpack data, which is beneficial when working with APIs optimized for performance and reduced data transfer.
Previous
Request basics
Next
Request headers
Built with