---

site: protos.rip

page: compare/buf

---

                                            
  _________  ____ ___  ____  ____ _________ 
 / ___/ __ \/ __ `__ \/ __ \/ __ `/ ___/ _ \
/ /__/ /_/ / / / / / / /_/ / /_/ / /  /  __/
\___/\____/_/ /_/ /_/ .___/\__,_/_/   \___/ 
                   /_/

# protorip vs buf.build (buf schema registry)

protorip (`protos.rip`) and the Buf Schema Registry (`buf.build`) both provide hosted registries for the `buf` CLI. For teams evaluating an alternative to the Buf Schema Registry (BSR), protorip implements the open [BSR protocol](https://github.com/bufbuild/registry-proto) to version, share, and generate code from Protocol Buffer schemas at a flat rate.

for day-to-day schema development (`buf push`, `buf dep update`, and `buf generate`), the core CLI workflow is identical on both registries. (for specific CLI version requirements and supported commands, see the [CLI compatibility guide](/compatibility).)

hosted feature	buf.build (`buf.build`)	protorip (`protos.rip`)
core CLI support	full `buf` CLI support	full standard developer workflow (`push`, `dep update`, `generate`)
pricing model	$0.50/type/mo on Teams, or Pro from $3,000/mo	$49/mo flat (team), $9/mo (solo), $0 (free & oss)
private type limits	100 private types on Community tier	unlimited private types on all tiers
core public modules	core public modules (`googleapis`, `protovalidate`, …)	same core public modules
remote code generation	community plugins + custom container plugins	same community remote plugins (`go`, `es`, `python`, …)
hosted package feeds	Generated SDKs (npm, Go proxy, PyPI, Maven, Cargo)	not supported (generate locally via `buf generate`)
push-time review gates	supported (optional server-side quarantine)	not supported (enforce in your own CI)
web schema/docs browser	supported	supported
access & governance	per-repo RBAC, webhooks, SAML SSO, SCIM	direct login and organisation-wide access

## public modules and remote plugins

>core public modules: `buf.build` provides core public modules (`googleapis/googleapis`, `bufbuild/protovalidate`, `envoyproxy/protoc-gen-validate`, `grpc-ecosystem/grpc-gateway`). `protos.rip` provides the same core public modules under identical registry paths.
>remote code generation: both registries run the same community remote generation plugins (Go, TypeScript/ES, Python, Java, Connect-RPC) via `buf generate`, removing the need for local compiler or plugin setups. `buf.build` also supports hosting custom plugin containers.

## package distribution and generated sdks

`buf.build` can compile schemas into language packages and host them on package feeds for npm, PyPI, Maven, Go proxy, Cargo, and Swift ([Generated SDKs](https://buf.build/docs/bsr/generated-sdks/)). downstream consumers can install generated code using standard package managers without running `buf generate`.

protorip does not host language package registries. consumers can generate client code by running `buf generate` in local or CI builds.

## review gates and ci checks

`buf.build` offers optional server-side checks that intercept a `buf push` at the registry and quarantine non-compliant schemas until approved.

protorip does not support push-time quarantine gates. teams can enforce schema governance by running `buf lint` and `buf breaking` in their own CI pipelines before push.

## schema browsing and permissions

both registries provide web-based schema browsing and documentation listings across packages, services, messages, and enums.

protorip provides organisation-wide access for team members. `buf.build` supports per-repository access roles, webhook notifications, SAML SSO, and SCIM provisioning.

## pricing

when comparing Buf Schema Registry pricing to protorip, the primary difference is how private usage is metered.

[Buf’s pricing](https://buf.build/pricing) meters private types:

>Community ($0): 1 private repository with up to 100 private types.
>Teams ($0.50 per private type/month): unlimited repositories, billing for every private message, enum, and RPC method defined in your schemas.
>Pro ($5.00 per private type/month): adds SAML SSO, audit logging, and private instances, with a $3,000 monthly minimum.

for an organisation with 300 private types, Buf Teams costs $150/month and bills scale as you expand your APIs.

[protorip’s pricing](/pricing) uses flat monthly or annual rates with no type or seat meters:

>Free ($0): unlimited public modules and 1 private module for 1 user.
>Solo ($9/mo or $84/yr): unlimited private modules for 1 user.
>Team ($49/mo or $490/yr): unlimited private modules, unlimited types, and unlimited members per organisation.
>Open source ($0): free team accounts for eligible public OSS projects ([OSS terms](/oss)).

an organisation maintaining 300 private types pays $49/month on Team, and Pro enforces a $3000 minimum whether your schemas have 300 or 3,000 types.

## switching registries

both `buf.build` and `protos.rip` implement the same open BSR protocol, so switching between them takes only a few minutes. you keep your existing Protobuf schemas intact and preserve your established developer workflows.

migration is as simple as swapping `buf.build` for `protos.rip` in your configuration files:

```diff  version: v2  modules:    - path: proto-     name: buf.build/acme/orderapis+     name: protos.rip/acme/orderapis  deps:-     - buf.build/googleapis/googleapis-     - buf.build/bufbuild/protovalidate+     - protos.rip/googleapis/googleapis+     - protos.rip/bufbuild/protovalidate  plugins:-     - remote: buf.build/protocolbuffers/go+     - remote: protos.rip/protocolbuffers/go        out: gen/go        opt: paths=source_relative-     - remote: buf.build/connectrpc/es+     - remote: protos.rip/connectrpc/es        out: web/src/gen```

with the same core public modules and community remote generation plugins available under matching paths, everyday commands (`buf dep update`, `buf generate`, and `buf push`) resolve and build schemas immediately. you can adopt `protos.rip` today, evaluate it against your current workflow, and switch back at any time without schema refactoring.

for authentication steps and supported CLI versions, see the [CLI compatibility guide](/compatibility).

## choosing a registry

>choose `buf.build` if your workflow needs hosted language package feeds (Generated SDKs), push-time registry gates, custom plugin containers, webhooks, private instances, or per-repository RBAC.
>choose protorip if you want standard BSR schema hosting, remote plugin generation, and upstream dependencies at a predictable flat rate, with checks run in your own CI.

if you want to design, expand, and version your Protobuf APIs without worrying about monthly type meters, [create a free account](/dashboard) to publish your first private module today. you can also review our [pricing plans](/pricing) to see how flat rates scale with your team, or explore the [CLI compatibility guide](/compatibility) to see supported versions and workflows.