CacheFlow vs Vercel Remote Cache for Turborepo

As of

Vercel Remote Cache is the managed remote cache Turborepo ships with. It is free on all Vercel plans under fair-use limits, and authenticates CI with OIDC or a team-scoped token. CacheFlow serves the same Turborepo remote cache protocol from your own Cloudflare account, next to its GitHub Actions cache and artifact services.

Both let GitHub Actions jobs authenticate with a short-lived OIDC credential instead of a stored secret. The difference is who operates the cache and where the bytes live: Vercel runs it for you, CacheFlow runs on your Cloudflare account. CacheFlow makes no speed claim over Vercel.

At a glance

Aspect Vercel Remote CacheCacheFlow
Cost [1] Free on all plans, subject to fair use: uploads of 100 GB/month (Hobby), 1 TB/month (Pro) or 4 TB/month (Enterprise). Runs on your Cloudflare account; the resources it uses are on your Cloudflare bill.
Who operates it [1] Vercel. You, on your Cloudflare account (R2, D1, KV, Durable Objects).
CI authentication [2] OIDC: vercel/setup-turborepo-remote-cache-action exchanges a GitHub OIDC token for a short-lived Turborepo token. Other providers can exchange their own OIDC token. A team-scoped personal access token is the fallback. In GitHub Actions, setup-cacheflow mints a GitHub OIDC token (no stored secret) and exports TURBO_API, TURBO_TOKEN and TURBO_TEAM. Elsewhere, an operator-issued token.
Developer laptops [1] Each developer runs turbo login and turbo link. An operator-issued token.
Sharing scope [1] The Vercel team: artifacts are shared with all of the team’s projects and members. The GitHub organization: default-branch artifacts are read by every repository and branch of the owner. Other branches read and write only within their own repository.
Who can write Not covered in the cited references. The first write to a hash wins; later writes leave it unchanged. On the OIDC path a job on any other branch writes only to that branch, in its own repository, so a pull request cannot change what main replays. Default-branch pushes write to a scope shared by all of the owner’s repositories, so any of them can seed what the others replay. Events outsiders can trigger, such as pull_request_target or issue_comment, write to a quarantined scope. Operator-issued tokens are read-only unless issued writable.
Retention [1] Uploaded artifacts expire automatically after 7 days. Team owners can clear the cache at any time. Artifacts expire 7 days after last access (sliding: each hit extends it; configurable with TURBO_ARTIFACT_TTL_DAYS). A full namespace evicts its least recently used artifacts instead of refusing the upload.
Rate limits [1] Fair-use artifact requests: 100/minute (Hobby), 10,000/minute (Pro and Enterprise). Not published.
Build tools [1] Turborepo natively; Nx and Rush through Vercel’s Remote Cache SDK plugins. Turborepo only. No Nx, Bazel or Gradle remote-cache protocol.
Usage insight [1] Artifact counts, sizes and a “time saved” metric. Turborepo downloads and uploads are recorded with bytes; batch-lookup misses are not. Turborepo content hashes are recorded as-is, by design. A per-repository summary is operator-only; there is no tenant view yet.
Beyond Turborepo Not compared. The same deployment serves the GitHub Actions cache and artifact services, and a CLI and Python SDK for generic caching.

Where CacheFlow is the better fit

  • You want Turborepo artifacts in a Cloudflare account you own rather than with a third party.
  • You also want the GitHub Actions cache and artifacts served by the same deployment, with their operations recorded in the same place.
  • You do not otherwise use Vercel and prefer not to add a Vercel team just for the cache.
  • Pull requests and forks must not be able to change what main replays: CacheFlow scopes writes to the job’s branch and repository, keeps the first write to each hash, and quarantines untrusted events.

Where Vercel Remote Cache is the better fit

  • You want a free, fully managed cache and nothing to operate.
  • You already deploy on Vercel: Remote Caching is enabled automatically for turbo commands during Vercel builds.
  • Developers link their laptops themselves with turbo login and turbo link; CacheFlow needs an operator to issue a token.
  • You use Nx or Rush, which Vercel supports through its Remote Cache SDK and CacheFlow does not.
  • Your CI is not GitHub Actions: Vercel documents OIDC token exchange for other providers, while CacheFlow’s OIDC path is GitHub-only and other CI uses an operator-issued token.
  • You want a “time saved” view today; CacheFlow has no time-saved figure, and its per-repository summary is operator-only.

How to switch

Replace vercel/setup-turborepo-remote-cache-action (or the TURBO_TOKEN secret) with setup-cacheflow. It exports TURBO_API, TURBO_TOKEN and TURBO_TEAM, so turbo itself needs no change. The job needs id-token: write.

permissions:
  contents: read
  id-token: write

jobs:
  build:
    runs-on: ${{ vars.CI_RUNNER_LARGE || vars.CI_RUNNER_DEFAULT }}
    steps:
      - uses: actions/checkout@v4
      # exports TURBO_API, TURBO_TOKEN and TURBO_TEAM
      - uses: CaptainEmpower/cacheflow/.github/actions/setup-cacheflow@v1
        with:
          api-url: ${{ vars.CACHEFLOW_TURBO_API }}
          install-cli: 'false'
      - run: pnpm install --frozen-lockfile
      - run: pnpm turbo run build

Sources

Claims about other products come from their public documentation, retrieved on . Claims about CacheFlow describe what ships today; planned work is marked as planned.

  1. Vercel Docs: Remote Caching: https://vercel.com/docs/monorepos/remote-caching (retrieved 2026-09-28)
  2. Vercel Docs: Use Remote Caching from External CI/CD: https://vercel.com/docs/monorepos/remote-caching/external-ci-cd (retrieved 2026-09-28)
  3. Turborepo Docs: Remote Caching: https://turborepo.dev/docs/core-concepts/remote-caching (retrieved 2026-09-28)