We use cookies to understand how people use Depot.
Depot
Sign InGet started
GitHub Actions

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 are 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 usage tracking
  • 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
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.
Analytics and metrics
  • Job performance analytics with CPU/memory utilization tracking and automated runner sizing recommendations.
  • Step-level timing breakdowns, failure rate tracking, and live runner status.
  • Learn more about GitHub Actions metrics and analytics.

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:

  1. Receives the webhook event from GitHub indicating a new job needs to run.
  2. Assigns a fresh EC2 instance from a pre-provisioned standby pool matching your requested runner type (for example, depot-ubuntu-24.04).
  3. Registers the runner in your GitHub organization's default runner group.
  4. Runs the entire job using GitHub's standard runner image on the instance.
  5. 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

Runners usage is tracked by the second, with no one-minute minimum per run. We calculate total minutes used at the end of the billing period.

Developer planStartup planBusiness plan
Plan cost$20/month$200/monthCustom
GitHub Actions minutes2,000 included20,000 included
+ $0.004/minute after		Custom
Cache25 GB included
+ $0.20/GB/month after		250 GB included
+ $0.20/GB/month after		Custom
Runner typesLinux, WindowsLinux, Windows, macOSLinux, Windows, macOS

Plans also include container build minutes. See Pricing for more about plan features and costs.

Runner pricing by type and size

Larger runners consume your included GitHub Actions minutes faster (via multipliers) and cost more per minute. For per-minute pricing, see GitHub Actions runner types.

Additional GitHub Actions minutes

Startup and Business plan customers can pay for additional GitHub Actions minutes on a per-minute basis. For per-minute pricing, see GitHub Actions runner types.

Estimate your cost savings

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

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:

  1. Connect your GitHub organization to Depot.
  2. 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.

Next steps