# Protorip vs buf.build (Buf Schema Registry)

## Same `buf` CLI workflow, dependencies, and remote plugins

```yaml
version: v2
modules:
  - path: proto
    name: protos.rip/acme/orderapis
deps:
  - protos.rip/googleapis/googleapis
  - protos.rip/bufbuild/protovalidate
```

```yaml
version: v2
plugins:
  - remote: protos.rip/protocolbuffers/go
    out: gen
    opt: paths=source_relative
  - remote: protos.rip/connectrpc/es
    out: web/src/gen
```

```bash
buf registry login protos.rip
buf dep update
buf generate
buf push --label v1.0.0
```

• >Community remote generation plugins: Protorip mirrors the community remote plugins maintained by Buf on `buf.build` (such as `protocolbuffers/go`, `connectrpc/es`, `grpc/go`, `protocolbuffers/python`, and `protocolbuffers/java`). `buf generate` runs remote plugins without requiring local `protoc` toolchains.
• >Standard upstream public modules: Because the `buf` CLI requires every dependency in a workspace graph to resolve from a single registry, Protorip mirrors the upstream public modules that Buf maintains on `buf.build` (`googleapis/googleapis`, `bufbuild/protovalidate`, `envoyproxy/protoc-gen-validate`, `grpc-ecosystem/grpc-gateway`, and `protocolbuffers/wellknowntypes`) under the same paths.

## Flat pricing vs per-type metering

• >Free ($0): Unlimited public modules and 1 private module (with no type limit) 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): Unlimited public modules and members for eligible projects ([OSS terms](/oss)).

## Where `buf.build` goes further (and when to choose it)

• >Generated SDK package registries and custom plugins: `buf.build` can compile schemas on push and publish packages directly to hosted npm, Go, Maven, PyPI, Cargo, and Swift registries ([generated SDKs](https://buf.build/docs/bsr/generated-sdks/)), and can host custom plugins. With Protorip, consumers either run `buf generate` against our mirrored community plugins (or local plugins) or consume generated code committed by your CI pipeline.
• >Server-enforced schema checks and review flows: With Protorip, teams run `buf lint` and `buf breaking` in CI on pull requests before merging and pushing from their protected branch. `buf.build` offers [server-side checks](https://buf.build/docs/bsr/checks/) that quarantine non-compliant pushes at the registry until an administrator approves them.
• >Granular repository permissions, SSO, and private instances: Protorip uses an organisation-wide access model where members of an organisation can read and write its private modules, paired with API keys for CI. `buf.build` supports [per-repository roles](https://buf.build/docs/bsr/repositories/#access-and-ownership), SAML SSO, SCIM provisioning, audit logs, and dedicated single-tenant BSR deployments.
• >Rendered documentation portals: Protorip provides a source and symbol browser covering files, packages, services, methods, messages, and enums. `buf.build` renders [rich documentation pages](https://buf.build/docs/bsr/documentation/) from READMEs, proto comments, and custom options.

## What about open-source tools or Git submodules?

• >No open-source registry implements the `buf` CLI protocol. Alternative open-source Protobuf managers (such as `buffrs` or `protodep`) require abandoning `buf.yaml`, `buf.lock`, and remote plugins in favour of bespoke manifests and CLIs.
• >Self-hosting or maintaining Git glue costs more than a flat utility tier. Running a private registry server or debugging submodule drift and diamond dependency conflicts across repos takes far more engineering time than a $9 or $49/month managed registry.

## Choosing a registry