Permify moves permission checks into a service, and prices the visibility separately
An open-source authorization as a service inspired by Google Zanzibar, designed to build and manage fine-grained and scalable authorization systems for any application. — Permify is now part of FusionAuth 🎉
At a glance
- What is it?
- Permify answers access control questions at runtime over a policy language compatible with RBAC, ReBAC, and ABAC. What the self-hosted edition does not carry is the observability and data synchronization layer that the cloud offering keeps behind a paywall.
- Who is it for?
- Permify is worth a look for teams that already have permission logic smeared across services and want one place to reason about it, and it is a poor fit for anyone who needs the dashboards on day one, because the free edition leaves those out on purpose.
- Can I use it commercially?
- Yes, with strict conditions. AGPL-3.0 is a network copyleft licence: if people use a modified version over a network, for example as a hosted service, you must offer them its source code under the same licence.
- Is it still maintained?
- Yes. The repository received new commits within the last day.
- What is it written in?
- Mainly Go, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- Permify/permify5,973 ★ · +17
| Repository | 2026-09-23 | 2026-11-15 |
|---|---|---|
| Permify/permify | 6k | 6k |
17 Stars in the last 53 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
Permission checks move out of your code and into a service
The pitch is separation. Authorization logic is pulled out of application code and treated as its own entity that you can reason about, test, and debug on its own, which is how the project describes its central benefit. What arrives at the other end is a runtime service answering questions of the shape can user X view document Y, or which posts can members of team Y edit, from any app that can reach it, in tens of milliseconds. There is a Playground at play.permify.co for building logic and testing it against sample data before it touches production, and an API reference at docs.permify.co/api-reference. Integration samples live in the sdk/ directory of the same repository rather than in a separate package index. The trade is that a check is no longer a function call inside your process, it is a request to a service you now run.
One policy language covers RBAC, ReBAC, and ABAC
You write permissions in a domain specific language, and the same language is stated to be compatible with RBAC, ReBAC, and ABAC, so role grants, relationship graphs, and attributes can be expressed side by side instead of through three separate systems. Granularity is described as resource specific, hierarchical, and context aware, which means the unit of permission is the object rather than the action type. Tenants get their own paragraph: isolated authorization logic and custom permissions per vendor or organization, all managed in one place. The modeling guide at docs.permify.co/getting-started/modeling is where the grammar lives.
The Community Edition lands four times a year
There are two editions and the release schedule is where they diverge first. The cloud service is described as continuously developed, with new features and updates multiple times per week. The Community Edition is a long term release published four times per year, and the project is explicit about the cost: the newest features and improvements will not be immediately available. The tags tell a milder version of the same story. v1.7.3 shipped on 2026-08-17, v1.7.4 on 2026-09-10, and v1.7.5 on 2026-10-09, three patch level releases in about two months. The last push to master is dated 2026-11-02, so work in the tree is current even when the packaged release is not. Release plumbing sits at the top of the repository in .goreleaser.yml, nightly.goreleaser.yml, and Dockerfile.release.
Observability dashboards and data sync stay on the cloud side
The premium feature row is blunt about the intent. Selected features, named as observability dashboards and data synchronization, are absent from the free edition in order to keep a protective barrier around the cloud offering. Everything above that line shifts onto your side of the ledger: you need a server, and you are responsible for installation, maintenance, upgrades, server capacity, uptime, backup, security, stability, consistency, and latency. In exchange the cloud side hands you high availability, backups, and maintenance, region choice across AWS, GCP, or Azure, disaster recovery zones, and SLAs. The privacy row claims SOC2 and GDPR compliance for the hosted service with a Trust Center link. Hosting freedom is the other trade: the self-hosted instance runs on any server in any country, personal hardware included.
docker compose starts Postgres with the password secret
The compose file is the fastest path to a running service and it is unusually honest about its rough edges. The permify service builds from Dockerfile.local rather than the release image, restarts always, mounts the working tree into the container, and publishes two ports. Postgres comes up beside it on 5432 with a password literal in the file:
services:
permify:
build:
context: .
dockerfile: Dockerfile.local
restart: "always"
ports:
- "3476:3476"
- "3478:3478"
healthcheck:
test: ["CMD", "grpc_health_probe", "-addr", "localhost:3478"]
interval: 10s
retries: 10
start_period: 60s
database:
image: "postgres"
ports:
- "5432:5432"
environment:
- "POSTGRES_PASSWORD=secret"
- "POSTGRES_DB=permify"The health gate probes port 3478 only, so a healthy container tells you nothing about 3476. The declared pg-data volume is not attached to either service, which means this file is a development harness, not a durable deployment.
The Dockerfile and go.mod name different Go versions
Building from source goes through the Makefile, and the module declares go 1.26.0 while the container image is golang:1.27.2-alpine pinned to a digest. Three targets cover the whole loop from a clean checkout to a running stack:
go mod download
go build -o ./permify ./cmd/permify
docker-compose up --buildThe build stage sets CGO_ENABLED=0 and mounts caches for /root/.cache/go-build and /go/pkg/mod, so a rebuild only recompiles what changed. A second stage clones grpc-health-probe and installs it with GOTOOLCHAIN=local, -tags netgo, and -ldflags=-w, which is where the image's grpc_health_probe binary comes from. The final image is cgr.dev/chainguard/static, also digest pinned, holding two files: the probe and the service. Entrypoint is permify and the default command is serve, so the container takes no arguments.
The protobuf toolchain ships as pinned Go tools
Everything a contributor needs is declared inside go.mod rather than installed globally, which is why the lint and format targets read go tool instead of a bare binary name. Eight tools sit in that block:
github.com/golangci/golangci-lint/v2/cmd/golangci-lint
github.com/grpc-ecosystem/grpc-gateway/v2/protoc-gen-grpc-gateway
github.com/grpc-ecosystem/grpc-gateway/v2/protoc-gen-openapiv2
github.com/planetscale/vtprotobuf/cmd/protoc-gen-go-vtproto
github.com/securego/gosec/v2/cmd/gosec
google.golang.org/grpc/cmd/protoc-gen-go-grpc
google.golang.org/protobuf/cmd/protoc-gen-go
mvdan.cc/gofumptThe gateway generators alongside the protobuf and grpc ones match a proto/ directory at the top level and buf.gen.yaml, so the API surface is generated rather than handwritten. Tests are run with the race detector across every package under cmd, pkg, and internal that holds a test file, with a ten minute timeout and coverage written to coverage.txt. Integration tests have their own target and their own service in the compose file. Formatting goes through gofumpt in extra mode, and Dockerfile linting pipes every Dockerfile through hadolint while tolerating failure.
AGPL-3.0, a governance file set, and a new corporate owner
The license is AGPL-3.0, which is the obligation to look at first, because Permify is infrastructure you would otherwise only see from outside. Thirty-eight entries sit at the top of the repository, and a good number of them are process rather than code: LICENSE, NOTICE, CLA.md, CODE_OF_CONDUCT.md, CONTRIBUTING.md, and SECURITY.md. Default branch is master. The badge row points at a Discord, a Go Report Card page, the release workflow, Scrutinizer running on master, Codecov, and GuruBase, so the continuous integration signals are all published. The banner at the top of the README says Permify has been acquired by FusionAuth, with links to a Permify blog post and a FusionAuth press release, and the project description now ends with the same note. The README banner does not say what that changes for the roadmap or the four times a year release promise.
Editorial conclusion
Permify is worth a look for teams that already have permission logic smeared across services and want one place to reason about it, and it is a poor fit for anyone who needs the dashboards on day one, because the free edition leaves those out on purpose. Before committing, check whether your access model fits RBAC, ReBAC, or ABAC rather than something custom, budget for the Postgres instance you will own yourself, and read what the acquisition by FusionAuth means for the release cadence, since the four times a year schedule is a promise the roadmap has to keep.
Frequently asked questions
What is authorization as a service in Permify's terms?
It means authorization logic leaves your application code and lives in a service that answers checks at runtime, such as can user X view document Y, in tens of milliseconds. Permify presents this as centralizing authorization so it can be reasoned about, tested, and debugged as one entity.
Which permission models can Permify express?
The policy language is stated to be compatible with RBAC, ReBAC, and ABAC. Permissions can be resource specific, hierarchical, and context aware, and each tenant or vendor can be given isolated authorization logic in the same place.
What should Permify be compared against?
The system the README names is Zanzibar, the paper the project says inspired its design, linked both as a PDF and as an explanatory article.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/permify-permify)Star history chart for your README
[](https://hysenlabs.com/projects/permify-permify)Was this useful?