canonical: https://jentic.com/apis/pipelines.dev/pipelines-dev

# Pipelines.dev API

Pipelines.dev provides cloud-native CI/CD pipeline orchestration with declarative YAML configuration, container-based builds, artifact management, and deployment automation. The API exposes full control over pipeline definitions, build triggers, execution monitoring, secret management, artifact storage, and deployment targets. Built for platform teams creating internal developer platforms, DevOps automation tools, and CI/CD-as-a-service offerings.

## For AI agents

Manage CI/CD pipelines with build configuration, execution triggers, artifact storage, and deployment automation. Supports 55 endpoints for pipeline orchestration, build monitoring, and DevOps workflows.

## Scope

Does not provide source code hosting, issue tracking, or infrastructure provisioning - use for CI/CD pipeline orchestration, build execution, and deployment automation only.

## Capabilities

- Define and manage pipelines with stages, jobs, and container-based execution environments
- Trigger builds from git commits, pull requests, tags, or API calls with custom parameters
- Store and retrieve build artifacts with versioning and retention policies
- Manage secrets and environment variables scoped to pipelines or organizations
- Monitor pipeline executions with real-time logs, status updates, and performance metrics
- Configure deployment targets including Kubernetes clusters, serverless platforms, and VMs
- Set up approval gates and manual intervention steps for production deployments

## Use cases

### AI Agent DevOps Automation

Enable AI agents to orchestrate CI/CD workflows, diagnose build failures, and automate deployment processes. Agents can create pipelines programmatically, trigger builds in response to events, retrieve execution logs to diagnose failures, and manage deployment approvals. For example, an agent tasked with 'deploy the latest staging branch to production' can verify tests passed, trigger the deployment pipeline, wait for approval, and monitor deployment status.

Example prompt: Create a pipeline with test, build, and deploy stages for a Node.js app, configure it to trigger on main branch commits, set up approval gate before production deployment, then trigger initial build and monitor execution until completion

### Multi-Environment Deployment Orchestration

Manage deployments across multiple environments (dev, staging, production) with different approval workflows and configuration. The API supports defining deployment targets, configuring environment-specific variables, and setting up approval gates. Teams can automate promotion between environments while maintaining control over production releases.

Example prompt: Create deployment pipeline with three stages: (1) auto-deploy to dev on commit, (2) deploy to staging on tag with smoke tests, (3) deploy to production with manual approval gate and rollback capability

### Build Artifact Management

Store, version, and retrieve build artifacts including Docker images, compiled binaries, npm packages, and deployment bundles. The API provides artifact upload/download, versioning with semantic tags, retention policies, and usage tracking. DevOps teams can implement artifact promotion workflows where artifacts built in CI are promoted through environments without rebuilding.

Example prompt: After successful build, upload Docker image as artifact with semantic version tag, store build metadata (commit SHA, timestamp, test results), then retrieve artifact in staging deployment pipeline by version tag

### Pipeline Execution Monitoring and Analytics

Track pipeline execution metrics including build duration, success rates, failure patterns, and resource usage. The API provides execution history, detailed logs, and aggregate analytics. Engineering teams can build dashboards showing build health, identify slow stages for optimization, and detect flaky tests or recurring failures.

Example prompt: Query all pipeline executions for the last 30 days, calculate average build duration per pipeline, identify executions that failed during test stage, and generate report with top failure reasons and affected branches

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/v1/pipelines` | Create a new pipeline |
| POST | `/v1/pipelines/{pipelineId}/executions` | Trigger pipeline execution |
| GET | `/v1/executions/{executionId}` | Get execution status and details |
| GET | `/v1/executions/{executionId}/logs` | Retrieve execution logs |
| POST | `/v1/artifacts` | Upload build artifact |
| GET | `/v1/artifacts/{artifactId}` | Download artifact |
| POST | `/v1/secrets` | Create encrypted secret |

## Key resources

- **Pipelines** — Define and manage pipeline configurations with stages and jobs
- **Executions** — Track pipeline runs with logs, status, and execution history
- **Artifacts** — Store and retrieve build artifacts with versioning
- **Secrets** — Manage encrypted secrets and environment variables
- **Triggers** — Configure build triggers from git events or API calls
- **Deployments** — Define deployment targets and promotion workflows
- **Approvals** — Manage manual approval gates for deployments

## Why Jentic

- **Setup:** Wiring Pipelines.dev by hand means managing its bearer token, coordinating pipeline, execution, and artifact calls, and handling retries yourself. Through Jentic you install once, import Pipelines.dev from the API Directory, store the token once, and your agent calls it.
- **Permission scoping:** Pipelines.dev puts the pipeline id and execution id in the URL path (`/v1/pipelines/{pipelineId}/executions`, `/v1/executions/{executionId}`), so a rule can pin your agent to one pipeline and its runs. You choose the operations it may call, so writing secrets is not included unless you add it.
- **Credential handling:** Your Pipelines.dev bearer token is stored once, encrypted, by your own Jentic One instance and injected as an Authorization header at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'trigger a pipeline build' or 'fetch execution logs', and Jentic returns the matching Pipelines.dev operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **GitHub Actions API** — Native GitHub CI/CD with YAML workflows and tight repository integration
- **CircleCI API** — Cloud CI/CD platform with YAML config and extensive integration marketplace
- **GitLab CI/CD API** — Integrated DevOps platform with CI/CD, container registry, and deployment features

## FAQ

### What authentication does the Pipelines.dev API use?

The API uses bearer token authentication with API tokens generated in the dashboard under Settings > API Tokens. Each request includes an Authorization: Bearer {token} header. Through Jentic, bearer tokens are stored encrypted and injected automatically - they never appear in agent prompts or execution logs.

### Can I trigger builds with custom parameters?

Yes. POST `/v1/pipelines/{pipelineId}/executions` accepts a parameters object with custom key-value pairs that are injected as environment variables during execution. This enables parameterized builds for different deployment targets, feature flags, or test suites.

### How do I retrieve build logs?

GET `/v1/executions/{executionId}/logs` returns logs for the entire execution or specific stages/jobs using query parameters. Logs are streamed in real-time during execution and persisted for 30 days. Log retention can be extended on enterprise plans.

### What artifact storage is included?

Free tier includes 5GB artifact storage with 30-day retention. Paid plans include 100GB-1TB with customizable retention up to 1 year. Artifacts are stored in regional cloud storage with global CDN for fast retrieval. Common artifact types include Docker images, npm/Maven packages, and deployment bundles.

### Can I deploy to my own infrastructure?

Yes. Pipelines.dev supports deploying to Kubernetes clusters (via kubectl), VMs (via SSH), serverless platforms (AWS Lambda, Google Cloud Functions, Vercel), and container registries. You configure deployment targets with credentials stored as secrets, then reference them in pipeline deploy stages.

### What are the execution limits?

Free tier includes 500 build minutes per month with 2 concurrent builds. Paid plans start at $29/month for 3,000 minutes and scale to unlimited builds. Individual build timeout is 60 minutes on standard plans, configurable up to 4 hours on enterprise plans.

### Can I limit what my agent is allowed to do with the Pipelines.dev API?

Yes. Because you run Jentic One yourself, your own rules decide which Pipelines.dev operations the agent may call and which credentials it may use. Since the pipeline id and execution id live in the URL path (`/v1/pipelines/{pipelineId}/executions` and `/v1/executions/{executionId}`), you can pin the agent to a single pipeline and its runs, and allow only read operations like fetching execution status or logs. Write operations such as creating secrets via POST `/v1/secrets` are included only if you explicitly grant them.