API developer tools for API developers, platform engineers, and API teams who take developer experience seriously. CLI, REST API, and native CI/CD plugins for GitHub Actions, GitLab CI, and Jenkins — ship OpenAPI, AsyncAPI, and GraphQL specs from any pipeline.
$ apiportal deploy --env production
✓ Uploading OpenAPI spec... done
✓ Validating schema... passed (0 errors)
✓ Generating documentation... done
✓ Running linter checks... passed
✓ Publishing to portal... done
✓ Deployed successfully!
→ https://app.api-portal.io/docs/payment-api/v3
$
// Native CI/CD plugins
API Portal runs where your team works — straight inside the merge request. Spec validation, breaking-change detection, and automatic deployment for OpenAPI, AsyncAPI, and GraphQL — with native plugins for GitHub Actions, GitLab CI, and Jenkins.
# .github/workflows/deploy.yml
name: Deploy API Spec
on: [push]
jobs:
deploy:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: apiportal/deploy@v1
with:
file: openapi.yaml
env: production
# .gitlab-ci.yml
stages:
- deploy
deploy_api:
stage: deploy
image: apiportal/cli:latest
script:
- apiportal login --token $PAT
- apiportal push --file openapi.yaml
- apiportal deploy --env production
only:
- main
// Jenkinsfile
pipeline {
agent any
stages {
stage('Deploy API') {
steps {
sh '''
apiportal login \
--token $PAT
apiportal deploy \
--file openapi.yaml \
--env production
'''
} } } }
// Workflow
OpenAPI, AsyncAPI, or GraphQL right next to the code. No context switch, no portal upload — the spec lives where the rest of the API is built.
GitHub Actions, GitLab CI, or Jenkins run linter and breaking-change checks inside the merge request. On merge, the pipeline pushes the spec to API Portal — versioned and signed.
Usage, changes, and access flow into the audit log and API Intelligence. Full traceability from the first commit.
// Toolkit
The API Portal CLI is the central tool for managing APIs straight from the terminal — OpenAPI, AsyncAPI, and GraphQL alike. Login, upload, validation, and environment management in a single command. Built for platform engineering and DevOps teams that treat API deployments as code and take developer experience seriously.
$ apiportal login
✓ Authenticated as your@email.com
$ apiportal push --file openapi.yaml
✓ Uploading openapi.yaml... done
✓ Version v2.4.0 created
$ apiportal validate openapi.yaml
✓ Schema valid (0 errors, 0 warnings)
$ apiportal environments list
production ● active v2.4.0
staging ● active v2.5.0-beta
development ● idle v2.5.0-dev
$
The complete management API is built on OpenAPI 3.1.0 and offers programmatic access to every portal capability — catalog, versioning, access control, workflow design, and spec management for OpenAPI, AsyncAPI, and GraphQL. Perfect for custom automation, integrations, and CI/CD scripts in any language.
GET /api/management/v1/capabilities
Authorization: Bearer eyJhbGci...kpXVCJ9
X-Tenant-ID: tenant-netscale-prod
// Response 200 OK
{
"data": [
{
"id": "cap_payment_api",
"name": "Payment API",
"version": "3.1.0",
"status": "published"
}
],
"cursor": "eyJpZCI6MTB9"
}
Personal access tokens enable secure, granular authentication for the CLI, REST API, and CI/CD pipelines. Scope control, expiry dates, and instant revoke — every action auditable.
| Name | Scopes | Ablaufdatum | |
|---|---|---|---|
| CI/CD Pipeline | read write | 2026-06-15 | Widerrufen |
| Local Dev | read | 2026-04-01 | Widerrufen |
| Admin Tools | read write admin | 2026-12-31 | Widerrufen |
// Who it's for
API developer tools are built for teams that don't leave platform engineering and developer experience (DevEx) to chance — they automate them.
// Comparison
Many API teams work with Postman collections, curl scripts, or manual portal uploads. That doesn't scale — dedicated API developer tools solve three core problems.
HTTP clients for exploration, but not API lifecycle management. No CI/CD integration, no spec validation in the merge request, no versioning.
Developer tools: pipeline integration with breaking-change checks.
Fine for 5 APIs, unmaintainable at 50. No standardized auth, no shared conventions, no audit logs — every team brews its own.
Developer tools: standardized CLI with PAT and audit trail.
A developer has to log in, pick a file, and upload — for every change. No Git workflow, no review process, no automation.
Developer tools: git push → CI validates → portal deploys.
// FAQ
Short answers for platform engineers and DevOps teams.
Get in touch// Discover more
// Deep dive
CLI, pipeline integration, and spec-first methodology.
Pipeline-first API deployment — from pre-upload validation to automated version management.
Read articleHow tooling fits into a spec-first workflow.
Read articleTry-it-out, mocks, and code samples — the visible result of the tooling chain.
Read articleStart with CLI, REST API, and CI/CD integration — and take your API workflows to the next level.