Apidog Docs
πŸ‡ΊπŸ‡Έ English
  • πŸ‡ΊπŸ‡Έ English
  • πŸ‡―πŸ‡΅ ζ—₯本θͺž
HomeLearning Center
Support CenterAPI ReferencesDownloadChangelog
HomeLearning Center
Support CenterAPI ReferencesDownloadChangelog
Discord Community
Slack Community
X / Twitter
πŸ‡ΊπŸ‡Έ English
  • πŸ‡ΊπŸ‡Έ English
  • πŸ‡―πŸ‡΅ ζ—₯本θͺž
πŸ‡ΊπŸ‡Έ English
  • πŸ‡ΊπŸ‡Έ English
  • πŸ‡―πŸ‡΅ ζ—₯本θͺž
  1. Team Resources
  • Apidog Learning Center
  • Getting Started
    • Introduction to Apidog
    • Basic Concepts in Apidog
    • Navigating Apidog
    • Quick Start
      • Overview
      • Creating an Endpoint
      • Making a Request
      • Adding an Assertion
      • Creating Test Scenarios
      • Sharing API Documentation
      • Explore More
    • Migration to Apidog
      • Overview
      • Manual Import
      • Scheduled Import (Bind Data Sources)
      • Import Options
      • Export Data
      • Import From
        • Import from Postman
        • Import OpenAPI 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
    • APl Design Guidelines
    • Module
    • Configure Multiple Request Body Examples
    • Components
    • Common Fields
    • Global Parameters
    • Endpoint Change History
    • Comments
    • Batch Endpoint Management
    • Custom Protocol API
    • Schemas
      • Overview
      • Create a New Schema
      • Build a Schema
      • Generate Schemas from JSON Etc
      • oneOf, allOf, anyOf
      • Using Discriminator
    • Security Schemes
      • Overview
      • Create a Security Scheme
      • Use the Security Scheme
      • Security Scheme in Online Documentation
    • Advanced Features
      • Custom Endpoint Fields
      • Associated Test Scenarios
      • Endpoint Status
      • Appearance of Parameter Lists
      • Endpoint Unique Identification
  • Develop and Debug APIs
    • Overview
    • Generating Requests
    • Sending Requests
    • Debugging Cases
    • Test Cases
    • Dynamic Values
    • Validating Responses
    • Design-First vs Request-First
    • Generating Code
    • Environments & Variables
      • Overview
      • Environment Management
      • Using Variables
    • Vault Secrets
      • Overview
      • HashiCorp Vault
      • Azure Key Vault
      • AWS Secrets Manager
    • Pre and Post Processors
      • Assertion
      • Extract Variable
      • Wait
      • Overview
      • Using Scripts
        • Overview
        • Pre Processor Scripts
        • Post Processor Scripts
        • Public Scripts
        • Postman Scripts Reference
        • Calling Other Programming Languages
        • Using JS Libraries
        • Visualizing Responses
        • Script Examples
          • Assertion Scripts
          • Using Variables
          • Modifying Requests
          • Other Examples
      • Database Operations
        • Overview
        • MySQL
        • MongoDB
        • Redis
        • Oracle Client
    • 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)
  • API Testing
    • Overview
    • Test Scenarios
      • Create a Test Scenario
      • Pass Data Between Requests
      • Flow Control Conditions
      • Sync Data from Endpoints and Endpoint Cases
      • Import Endpoints and Endpoint Cases from Other Projects
      • Export Test Scenarios
    • Run Test Scenarios
      • Run a Test Scenario
      • Run Test Scenarios in Batch
      • Manage Runtime Environment of APIs from Other Projects
      • Data-Driven Testing
      • Scheduled Tasks
    • Test Suite
      • Overview
      • Create A Test Suite
      • Orchestrate Test Suite
      • Run Test Suites Locally
      • Run Test Suites Via CLI
      • Scheduled tasks
    • Test Reports
      • Test Reports
    • Test APIs
      • Integration Testing
      • Performance Testing
      • End-to-End Testing
      • Regression Testing
      • Contract Testing
    • Apidog CLI
      • Overview
      • Installing and Running Apidog CLI
      • Apidog CLI Options
    • CI CD
      • Overview
      • Integrate with Gitlab
      • Integrate with Jenkins
      • Trigger Test by Git Commit
      • Integrate with Github Actions
  • Publish API Docs
    • Overview
    • API Technologies Supported
    • Quick Share
    • Viewing API Documentation
    • Markdown Documentation
    • Publishing Documentation Sites
    • Custom Login Page
    • Custom Layouts
    • Custom CSS, JavaScript, HTML
    • Custom Domain
    • LLM-Friendly Features
    • SEO Settings
    • Advanced Settings
      • Documentation Search
      • CORS Proxy
      • Integrating Google Analytics with Doc Sites
      • Folder Tree Settings
      • Visibility Settings
      • Embedding Values in Document URLs
    • API Versions
      • Overview
      • Creating API Versions
      • Publishing API Versions
      • Sharing Endpoints with API Versions
  • Send Requests
    • Overview
    • SSE Debugging
    • MCP Client
    • Socket.IO
    • WebSocket
    • Webhook
    • SOAP or WebService
    • GraphQL
    • gRPC
    • Use Request Proxy Agents for Debugging
    • Create Requests
      • Request History
      • Request Basics
      • Parameters and Body
      • Request Headers
      • Request Settings
      • Debug Requests
      • Saving Requests as Endpoints
      • HTTP/2
    • Response and Cookies
      • Viewing API Responses
      • Managing Cookies
      • Overview
    • Authentication and Authorization
      • Overview
      • CA and Client Certificates
      • Authorization Types
      • Digest Auth
      • OAuth 1.0
      • OAuth 2.0
      • Hawk Authentication
      • Kerberos
      • NTLM
      • Akamai EdgeGrid
  • Branches
    • Overview
    • Creating a Sprint Branch
    • Testing APIs in a Branch
    • Designing APIs in a Branch
    • Merging Sprint Branches
    • Managing Sprint Branches
  • AI Features
    • Overview
    • Enabling AI Features
    • Generating Test Cases
    • Modifying Schemas with AI
    • Endpoint Compliance Check
    • API Documentation Completeness Check
    • AI-Powered Field Naming
    • FAQs
  • Apidog MCP Server
    • Overview
    • Connect Apidog Project to AI
    • Connect Published Documentation to AI
    • Connect OpenAPI Files to AI
  • Best Practices
    • Handling API Signatures
    • Accessing OAuth 2.0 Protected APIs
    • Collaboration Workflow
    • Managing Authentication State
  • Offline Space
    • Overview
  • Administration
    • 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
    • Onboarding Checklist
      • Basic Concepts
      • Onboarding Guide
    • Managing Projects
      • Managing Projects
      • Managing Project Members
      • Notification Settings
      • Project Resources
        • Database Connection
        • Git Connection
    • Managing Organization
      • Managing Organization
      • Single Sign-On (SSO)
        • SSO Overview
        • Configuring Microsoft Entra ID
        • Configuring Okta
        • Configuring SSO for an Organization
        • Managing User Accounts
        • Mapping Groups to Teams
      • SCIM Provisioning
        • Introduction to SCIM Provisioning
        • Microsoft Entra ID
        • Okta
      • Plans Management
        • Billing Managers in Organizations
      • Organization Resources
        • Self-Hosted Runner
  • Billing
    • Overview
    • Credits
    • Alternative Payment Methods
    • Managing Subscriptions
    • Upgrading Your Plan
    • Moving Paid Teams to Organizations
  • Data & Security
    • Data Storage and Security
    • User Data Privacy and Security
    • Request Routing and Data Security
  • Add-ons
    • API Hub
    • Apidog Intellij IDEA Plugin
    • Browser Extension
      • Chrome
      • Microsoft Edge
    • Request Proxy
      • Request Proxy in Web
      • Request Proxy in Shared Docs
      • Request Proxy in Client
  • Account & Preferences
    • Account Settings
    • Generating OpenAPI Access Token
    • Notification
    • Language Settings
    • Hot Keys
    • Network Proxy Configuration
    • Backing Up Data
    • Updating Apidog
    • Deleting Account
    • Experimental Features
  • References
    • API Design-First Approach
    • Apidog OpenAPI Specificaiton Extensions
    • JSONPath
    • XPath
    • Regular Expressions
    • JSON Schema
    • CSV File Format
    • Installing Java Environment
    • Runner Deployment Environment
    • Apidog flavored Markdown
  • Apidog Europe
    • Apidog Europe
  • Support Center
HomeLearning Center
Support CenterAPI ReferencesDownloadChangelog
HomeLearning Center
Support CenterAPI ReferencesDownloadChangelog
Discord Community
Slack Community
X / Twitter
πŸ‡ΊπŸ‡Έ English
  • πŸ‡ΊπŸ‡Έ English
  • πŸ‡―πŸ‡΅ ζ—₯本θͺž
πŸ‡ΊπŸ‡Έ English
  • πŸ‡ΊπŸ‡Έ English
  • πŸ‡―πŸ‡΅ ζ—₯本θͺž
  1. Team Resources

General Runner

The Apidog Self-hosted Runner can be understood as an automated program that can be hosted on a standalone server. It can execute tasks within Apidog, such as scheduled automated tests, scheduled API document imports, and returning mock response results.

Preparation#

The host machine (server or local PC) must have Docker installed.
The minimum required Docker version is 20.10.0, version 20.10.13 is recommended.

Quick Start#

This section will guide you on how to deploy General Runner on your server.

1. Deploy General Runner#

Navigate to the Apidog Home page, select your desired team, and then click on Resources on the right. From there, click on Deploy General Runner to get started.
πŸ“· Visual Reference
team-resources-general-runner.png

2. Get the Runner Deployment Command#

Upon clicking the Deploy General Runner, copy the deployment command for the General Runner from the pop-up window. You can customize the command as needed, supporting custom server OS, exposed ports, mount data directory, and more. Below is a detailed explanation of these settings:
Server OS: Specifies the operating system for the Docker container. This includes Linux, macOS, and Windows. Selecting the correct operating system is crucial for ensuring that the Docker container operates properly.
Docker Image: Three versions are available: General, Slim, and Custom. If your "custom script" needs to call external programs, choose the appropriate image for installation based on the required environment:
General: Contains all features of the Runner and comes pre-installed with the following language environments: Node.js 18, Java 21, Python 3, and PHP 8.
Slim: Contains all features of the Runner but only pre-installs Node.js 18.
Custom: Contains all features of the Runner and supports custom language environments for external programs. You can create your own Dockerfile to add or remove environments as needed.
Exposed Port: By default, Docker containers do not expose internal ports for external access. Using the -p parameter, you can map an internal port of the container to a port on the host machine, allowing external access to services provided by the container. For example, -p 80:4524 maps the container's internal port 4524 to port 80 on the host machine.
Mount Data Directory: The -v parameter allows you to mount directories from the host machine to the container, enabling the container to access and manipulate files on the host (e.g., database configurations or external programs). For example, -v "/opt/runner":/opt/runner mounts the host's /opt/runner directory to the container's /opt/runner directory.
πŸ“· Visual Reference
image.png
TIP
The deployment command contains token information and will be displayed only once for data security reasons. A new command will be generated each time you click Deploy General Runner.
Please save the command locally, as you can use it for future Runner upgrades.

3. Deploy Runner on the Server#

Paste the copied deployment command into the server's terminal, and the Runner installation will start automatically.
TIP
You can modify the deployment properties of the Runner through environment variables to better match your actual usage scenarios. Read runner deployment environment for more information.
πŸ“· Deployment Steps
After the installation is complete, the terminal will print relevant information. If there is an error, you can troubleshoot it based on the error details. If you still can't solve it, please contact us and provide feedback.

4. View Runner Status on the Server#

You can view the running status of the container through the Docker client.
πŸ“· Visual Reference
You can also use the docker ps command in the terminal to view the running status of the container.
πŸ“· Visual Reference

5. View Deployed General Runner at Apidog#

After confirming that the Runner container on the server has been deployed and enabled, return to Apidog. You can see that the Runner has been deployed and connected to Apidog in Team Resources β†’ General Runner.
INFO
If the General Runner has been successfully deployed on the server, but it is not displayed in the Apidog client, please click the refresh button on the right side of "General Runner" to refresh the page and check again.
You can rename, add descriptions, and delete the Runner so that your team members can better use this Runner; you can also stop/restart the Runner.
The suspended Runner will no longer execute the specified scheduled tasks, nor will it be able to create new related tasks and specify this Runner to execute.
πŸ“· Visual Reference
Refer to the table below for the status explanation of the Runner:
StatusDescription
StartedThe Runner is enabled normally in the container on the server, maintains communication with Apidog, and can handle related tasks issued by Apidog.
StoppedThe Runner is manually stopped in Apidog but continues to run normally in the container on the server and maintains communication. It will not process tasks issued by Apidog, and new tasks cannot specify a stopped Runner for execution. You can manually enable it at Apidog to restore the Runner to the started state.
OfflineThe Runner is disconnected from Apidog and cannot process tasks. This may be due to the Runner container stopping on the server or communication issues between the server and Apidog. To restore the Runner, ensure the Runner container is running and there are no communication problems with Apidog, allowing the Runner to restore to the started state.
You can deploy multiple General Runners within a team. When creating tasks that require self-hosted Runners, team members can choose from the available Runners.

Saving Files in Runner#

When using Runner to execute tasks such as endpoint requests, test scenarios, and scheduled tasks, certain local files may be required to support task execution. Examples include:
Calling other programming languages in custom scripts
Using database connections in Pre/Post Processors
Using SSL certificate when sending a request
To accommodate this, save the necessary files in the specified directory within the Docker container. When the Runner executes related tasks, it will read the file content from the specified directory according to the task requirements to ensure successful completion.
Refer to the following table to place files with the appropriate formats and content into the specified directory for use:
Use ContentSpecified Directory Path (or File Name)Example Docker Command
Other Programming Languages/app/external-programs/-v /Users/xxx/runner/packages/api-test/external-programs:/app/externalPrograms
Database Connection Configuration File/app/database/database-connections.json-v /Users/xxx/runner/packages/api-test/database/database-connections.json:/app/database/database-connections.json
SSL Certificate List File/app/ssl/ssl-client-cert-list.json-v /Users/xxx/runner/packages/api-test/ssl/ssl-client-cert-list.json:/app/ssl/ssl-client-cert-list.json
INFO
You can refer to here to see how to export the configuration file from the Apidog client.

Upgrading & Redeploying the Runner#

Upgrading the Runner#

When a new version of the Runner is released, an upgrade icon will appear in the desktop Runner UI. Click the icon to install the latest version provided by Apidog.
πŸ“· Visual Reference
runner-user-interface.png
Clicking on Upgrade will prompt you to stop the currently running Runner container. Please note that once the container is stopped, scheduled tasks and any tasks sent to this Runner from the client will no longer be executed.
πŸ“· Visual Reference
update-prompt.png
After you confirm the upgrade, Apidog will automatically stop the current Runner container and provide a command to deploy the new version. Follow the initial deployment steps to redeploy the Runner. Once the deployment is successful, you'll be using the latest version. Note: Existing scheduled tasks in the client will remain unaffected and do not need to be reassigned.
πŸ“· Visual Reference
update-general-runner.png

Redeploying the Runner#

If the Runner encounters an issue and you can't find a resolution in the Q&A section, or the instructions don't help, consider redeploying the Runner. To do this, navigate to the More Actions section for the specific Runner and click on Redeploy.
πŸ“· Visual Reference
redeploy-the-runner.png
The redeployment process is the same as upgrading one above. Note: Redeploying will also stop the Runner container.

Q&A#

1. How to Check Runner Logs to Diagnose an Issue?
Use the docker ps command to locate the problematic Runner.
Use the following commands to view the logs:
2. My Runner is Down/Disconnected or Can't Execute Tasks. What Should I Do?
Step 1: Gather information to diagnose the issue:
Look for error patterns or operational details
Open developer tools (Alt+7+8), send a test scenario to the problematic Runner, and record the endpoint details
Review Runner logs to look for any error messages or clues
Step 2: Resolve the issue:
If you can identify the problem and it's not caused by an Apidog bug, fix it yourself
If you can't pinpoint the issue, contact the Apidog community for further assistance
3. Why Didn't I Receive Notifications After the Runner Completed the Scheduled Task?
Step 1: Verify Task Completion:
Check if a test report for the scheduled task is available in the Apidog client
Review the Runner logs for any issues
Step 2: Check notification configuration:
Ensure the notification settings are saved within the scheduled task
Double-check that the conditions and recipients are correctly configured
Try manually triggering the task to confirm if the notifications are sent properly
4. What Does "No Runner Privilege" Error Mean and How to Fix It?
There are two possible causes for this error:
The Deployment Command Was Regenerated: If you generated the command, closed the popup, and then clicked again, a new token could invalidate the previous one. To fix this:
Switch to another team at the top-left corner, then return to the team where the Runner deployment is needed
Regenerate the deployment command, copy it, and run it. Ensure you don't click to regenerate again until the process completes.
ID Data Error with teamId Variable: This is a known bug that has been fixed in the latest version. If the issue persists:
Switch to another team at the top-left corner, then return to the team where the Runner deployment is needed
Regenerate the deployment command, copy it, and run it. Ensure you don't click to regenerate again until the process completes.
Modified atΒ 2026-01-26 08:50:58
Previous
Team Activities
Next
Team Variables
Built with