Early access

One private registry for every package your teams ship.

Artify is a multi-tenant artifact registry that runs entirely on Cloudflare's edge. Point npm, pip, cargo, Maven, NuGet, Go, Helm and more at your own tenant, verify signatures on the way in, and stop operating registry servers.

  • 16 package ecosystems, each on its native protocol
  • Sigstore signature policies: audit, warn or block
  • Served by Cloudflare Workers, no origin servers
Your existing clients, a new registry URL
# .npmrc
registry=https://npm.artify.monster/
$ npm install @acme/design-system

Ecosystems

Every package format behind one tenant

Each ecosystem is a dedicated service that speaks the protocol its clients already use. We label maturity honestly, from the same validation results we track internally.

  • npm

    npm, pnpm, Yarn

    Available
  • Terraform

    Registry Protocol v1

    Available
  • Go modules

    GOPROXY

    Available
  • Helm

    helm repo

    Available
  • NuGet

    dotnet, nuget, Chocolatey

    Available
  • Conda

    conda, mamba

    Available
  • Generic

    Any file, REST API

    Available
  • PyPI

    pip, uv, twine

    Beta
  • Cargo

    cargo (sparse index)

    Beta
  • Maven

    mvn, Gradle

    Beta
  • RubyGems

    gem, Bundler

    Beta
  • Packagist

    Composer

    Beta
  • CocoaPods

    pod

    Beta
  • Conan

    conan

    Beta
  • Hugging Face

    Models and datasets

    Beta
  • Docker / OCI

    docker, podman, oras

    In development
Available
around 90% or better in our protocol validation suite
Beta
core flows work; known gaps are tracked in the open
In development
not ready for your builds yet

Supply-chain security

Know what you install, and who published it

A registry is part of your supply chain. Artify checks provenance at the door and keeps every tenant's packages to itself.

Signature verification policies

Verify Sigstore signatures against the certificate identities you trust, with Rekor transparency-log lookups. Run each policy in audit, warn or block mode so you can measure before you enforce.

Trusted publishing from GitHub Actions

Bind a GitHub repository to your tenant and let its workflows authenticate with GitHub's short-lived OIDC identity instead of a long-lived publish token. Clients that need an opaque token can exchange it for a short-lived one.

Tenant isolation

Every request is resolved to a tenant at the gateway before it reaches a registry service. Packages, tokens and access rules are scoped per tenant, with role-based access and an audit trail.

Edge delivery

Close to every runner, with nothing to operate

Artify is built from Cloudflare primitives end to end, so there is no registry fleet to patch, scale or keep online.

Workers at the edge

Each ecosystem runs as its own Cloudflare Worker, so installs are answered on Cloudflare's network near your developers and CI runners rather than from a single region.

Content-addressed storage

Package files live in R2 under their SHA-256 digest. Identical bytes are stored once, however many versions or tenants reference them, and a file's address is its checksum.

Cached metadata

Hot metadata is cached in KV close to readers, with sensitive cached entries encrypted with AES-GCM. Queues move analytics and webhooks off the request path.

We will publish latency figures per ecosystem once they come from a benchmark you can reproduce. Until then we make no speed claim.

How it works

Three steps from invite to first install

  1. Create your tenant

    Accept your invite in the Artify console, set up your tenant and create an API token for your team.

  2. Point your clients at it

    Swap the registry URL in the config your tools already read. Nothing else in your build changes.

    npm.npmrc
    registry=https://npm.artify.monster/
    //npm.artify.monster/:_authToken=${ARTIFY_TOKEN}
    pippip.conf
    [global]
    index-url = https://pypi.artify.monster/simple/
    Cargo.cargo/config.toml
    [registries.artify]
    index = "sparse+https://cargo.artify.monster/"
  3. Publish from CI

    Trust a GitHub repository once and publish from GitHub Actions with its OIDC identity, or use a scoped token from any other CI. Turn on signature policies when you are ready to enforce them.

Early access

Request access

We invite teams in waves, by package ecosystem. Leave your work email, confirm it from the email we send, and we will be in touch when your wave opens. Already invited? Sign in.

We email you a link to confirm your address, then use it only to contact you about Artify access. See ourprivacy note or write to privacy@artify.monster.

FAQ

Questions teams ask first

Is Artify ready for production workloads?
Not yet for everyone, which is why access is by invitation. Maturity differs by ecosystem: the labels above follow the protocol validation results we publish for each one. We onboard early-access teams whose package ecosystems are ready and tell you plainly where the gaps are.
Do we have to change our build tooling?
No. Each ecosystem is served over its own native protocol, so npm, pip, cargo, dotnet, helm and the rest talk to Artify the way they talk to their public registries. You change a registry URL and a token, not your build.
How are tenants kept apart?
By design, every request is resolved to a tenant at the gateway before it reaches a registry service, and package metadata, tokens and access rules are scoped to that tenant. Each tenant gets its own registry namespace, with public or private visibility per package.
How does signature verification work?
Artify checks Sigstore signatures against the certificate identities you trust (for example your GitHub organization) and looks them up in the Rekor transparency log. Each policy runs in audit, warn or block mode, so you can measure before you enforce. Coverage is broadest for npm, PyPI and Cargo and is expanding to the other ecosystems.
Where is our data stored?
On Cloudflare: package files in R2, metadata in D1, hot paths cached in KV. Cloudflare holds the SOC 2 and ISO 27001 reports for that platform; Artify itself is not independently certified yet.
How fast is it?
Requests are served by Cloudflare Workers close to wherever your CI runs, with no origin servers in the path. We will publish per-ecosystem latency figures once we have a benchmark you can reproduce. Until then we make no speed claim.
What does it cost?
Pricing is not published yet. Join the waitlist and we will share plans with you when we open access for your team.
What happens to the email I give you?
We store your email and, if you give it, your company name, and send you one email to confirm the address is yours. Once confirmed, we use it only to contact you about Artify access. Unconfirmed requests are deleted after 30 days, every email has an unsubscribe link, and privacy@artify.monster deletes your signup on request.