Depot GitHub Actions runners

Depot GitHub Actions runners are a drop-in replacement for your existing runners in any GitHub Actions job. Our runners are up to 3x faster than a GitHub-hosted runner. Depot runners are integrated into our cache orchestration system, so you also get 10x faster caching without having to change anything in your jobs.

To use Depot runners, your repository must be owned by a GitHub organization (not a personal account).

Switching to Depot

After you connect your Depot organization to your GitHub repository, switching to Depot is a one-line change to your runner label in your GitHub actions workflow file. For example:

jobs:
  build:
    name: Build
-    runs-on: ubuntu-24.04
+    runs-on: depot-ubuntu-24.04
    steps:
      ...

For a step-by-step guide, see the quickstart.

Feature summary


Single tenant infrastructure	Builds run on ephemeral EC2 instances that are never reused. GitHub Actions runners launch on-demand in response to webhook events from your organization.
Accelerated caching	Runners are automatically integrated into our distributed cache architecture for upload and download speeds up to 1000 MiB/s on 12.5 Gbps of network throughput. Uses the same cache orchestration system as our Docker image builds for 10x faster caching in GitHub Actions jobs. Zero configuration required to benefit from faster caching.
High-performance compute	Portion of memory reserved for disk to maximize performance. Intel runners (x86 architecture) use 4th Gen AMD EPYC Genoa CPUs. Arm runners use AWS Graviton4 CPUs.
No limits	No concurrency limits, cache size limits, or network limits. Run as many jobs as you want in parallel.
Flexible cache isolation	Cache isn't isolated by branch. Cache entries from `main` and other branches contribute to the same namespace, making them accessible to all jobs. Control your cache isolation based on how you format your cache keys.
Cache scoped by repository	We scope cache entries stored in the Depot GitHub Actions cache by repository. Cache entries accessible only by the same repository that saved them. Repositories don't have key collisions when using the same cache key. One repository can't unexpectedly read cache entries from another repository of a different trust level (for example, a public repository reading from or writing to a private repository).
Per second billing	We track builds by the second and bill for whole minutes used at the end of the month. No one minute minimum enforced.
Self-hostable	Run optimized runners in our cloud or your AWS account for additional security and compliance. Support for dedicated infrastructure and VPC peering options for custom configurations.
Custom runner images	For Business plan customers, we can create custom runner AMIs with pre-installed software tailored to your specific requirements. Useful for specific tools, dependencies, or configurations not included in our standard runner images. Contact us at contact@depot.dev to discuss your needs.
Egress filtering	Control which external services your GitHub Actions runners can connect to with configurable allow and deny rules for IPs, CIDRs, or hostnames. For details, see Apply egress filters to GitHub Actions runners.
Docker image builds integration	If you use Depot for faster Docker image builds via our remote container builds, your BuildKit builder runs right next to your managed GitHub Action runner. Minimizes network latency and data transfer for faster CI builds.
Dagger Cloud integration	Connect with Dagger Cloud and run your Dagger Engine builds on our GitHub Actions runners with our accelerated cache enabled.

How Depot GitHub Actions runners work

Depot GitHub Actions runners use a webhook-driven architecture that launches ephemeral, single-tenant EC2 instances in response to your GitHub workflow jobs. When you run a GitHub Actions job with a Depot label (like runs-on: depot-ubuntu-latest), the job runs on a Depot runner.

When you start a workflow run in GitHub, the platform sends workflow_job webhook events to Depot's control plane. For each new job, Depot:

Receives the webhook event from GitHub indicating a new job needs to run.
Assigns a fresh EC2 instance from a pre-provisioned standby pool matching your requested runner type (for example, depot-ubuntu-24.04).
Registers the runner in your GitHub organization's default runner group.
Runs the entire job using GitHub's standard runner image on the instance.
Terminates the instance when the job completes.

Integration with Docker image builds

Depot GitHub Actions runners and Depot's remote container builds run in the same private network. If you use Depot for Docker image builds (via depot build), your BuildKit builders run right next to your GitHub Actions runners, minimizing network latency and accelerating workflows that build images and load them back into the job for testing.

Cache storage

When you use Depot GitHub Actions runners, we store the cache entries in a distributed storage system optimized for high throughput and low latency. The cache storage is encrypted at rest and in transit. To learn more and to configure the cache retention policy, see the Depot Cache overview.

Pricing

Depot-managed GitHub Action Runners are available on all of our pricing plans. Each plan includes a bucket of both Docker build minutes and GitHub Actions minutes. Business plan customers can contact us for custom plans.

Feature	Developer Plan	Startup Plan	Business Plan
Cost	$20/month	$200/month	Custom
Users	1	Unlimited	Unlimited
Docker Build Minutes	500 included	5,000 included + $0.04/minute after	Custom
GitHub Actions Minutes	2,000 included	20,000 included + $0.004/minute after	Custom
Cache storage	25 GB included	250 GB included + $0.20/GB/month after	Custom
Support	Discord Community	Email support	Slack Connect support
Unlimited concurrency
Multi-platform builds
US & EU regions
Depot Registry
Build Insights
API Access
Tailscale integration
Windows GitHub Actions Runners
macOS M2 GitHub Actions Runners	×
Usage caps	×
SSO & SCIM add-on	×
Volume discounts	×	×
GPU enabled builds	×	×
Docker build autoscaling	×	×
Dedicated infrastructure	×	×
Static outbound IPs	×	×
Deploy to your own AWS account	×	×
AWS Marketplace	×	×
Invoice / ACH payment	×	×

You can try out Depot on any plan free for 7 days, no credit card required →

Estimate your cost savings

To estimate the potential cost savings by switching to Depot GitHub Action runners, enter in your current usage by runner type on our GitHub Actions Price calculator.

Additional usage pricing for GitHub Actions minutes

Startup and Business plans have the option to pay for additional GitHub Actions minutes on a per-minute basis. See the runner type list for the per-minute pricing for each runner type.

Next steps

FAQ

What are the benefits of using Depot's GitHub Actions runners?

Depot's GitHub Actions runners offer several advantages:

Faster compute: Up to 3x faster than standard GitHub-hosted runners.
Up to 10x faster caching: Integrated with Depot's cache orchestration system.
Cost-effective: Half the cost of GitHub-hosted runners, billed by the second.
Variety of runner types: Support for Intel (x86), ARM, macOS, Windows, and GPU-enabled runners (Business plan only).
No concurrency limits: Run as many jobs as you want in parallel.

How do I start using Depot's GitHub Actions runners?

To use Depot's GitHub Actions runners, you need to:

Connect your GitHub organization to Depot.
Use the Depot label in your workflow file.

For example, change:

runs-on: ubuntu-24.04

to:

runs-on: depot-ubuntu-24.04

See Quickstart for GitHub Actions runners.

What runner types does Depot offer?

We offer a variety of runner types, including:

Ubuntu (from 2 vCPUs/2 GB RAM to 64 vCPUs/256 GB RAM)
macOS
ARM
Intel (x86)
Windows
GPU-enabled runners (available on the Business plan)

See GitHub Actions runner types.

How does Depot's pricing work for GitHub Actions?

Depot runners are half the cost of GitHub-hosted runners. Each plan comes with a set of included minutes as follows:

Developer plan: 2,000 minutes included
Startup plan: 20,000 minutes included, $0.004/minute after
Business plan: Custom minute allocation

Pricing is based on a per-minute basis, tracked per second, with no enforced one-minute minimum. See Pricing.

Can I use Depot's GitHub Actions runners with my existing workflows?

Yes, you can integrate our runners into your existing GitHub Actions workflows. You'll need to connect a GitHub organization-owned repository to Depot. Then change the runs-on label in your workflow file to use a Depot runner. See Quickstart for GitHub Actions runners.

How does Depot's caching system work with GitHub Actions?

Our high-performance caching system is automatically integrated with our GitHub Actions runners. It provides up to 10x faster caching speeds compared to standard GitHub-hosted runners, with no need to change anything in your jobs. See Use GitHub Actions cache with Depot Cache.

How can I track usage of Depot's GitHub Actions runners?

We provide detailed usage analytics for GitHub Actions on your organization's usage page and on the GitHub analytics page. You can track minutes used, job duration, and other metrics.

Can I use custom runner images with pre-installed software?

Yes, custom runner AMIs with pre-installed software are available on the Business plan. This is useful if you need specific tools, dependencies, or configurations that aren't included in our standard runner images.

With a custom runner AMI, we maintain a separate image specifically for your organization with your required software pre-installed. This can significantly reduce workflow execution time for dependencies that take time to install.

To request a custom runner AMI, contact us with details about your requirements.