Cerbos vs Amazon Verified Permissions

AAlex OlivierNovember 15, 202614 min read
Cerbos vs Amazon Verified Permissions

If you are comparing Cerbos with Amazon Verified Permissions, you are probably building on AWS. Verified Permissions, AWS's managed authorization service, looks like the obvious choice. It is already in your account, it is billed per request, and one application can be using it within a day. The comparison usually starts later, when the second or third application arrives, a product team asks for a list of everything a person can see, a business unit runs on another cloud, or an auditor asks which rule allowed a particular request last March.

Verified Permissions and Cerbos both take authorization out of application code and evaluate policy at runtime. They differ in where decisions run, how much data your application assembles for every check, how you answer "what can this person see", what evidence you keep, and how far one set of policies reaches across your applications, gateways, data platforms and AI agents. Verified Permissions policies are written in Cedar, and Cerbos vs Cedar compares the language itself.

cerbos-vs-amazon-verified-permissions-at-a-glance-comparison.png

Cerbos vs Amazon Verified Permissions at a glance

Question Cerbos Amazon Verified Permissions
What it is An authorization management platform. Decision points run next to every workload, Cerbos Hub manages policy, testing and audit, and Cerbos Synapse brings in context and connects gateways, data platforms and AI agents. A managed AWS service that evaluates Cedar policies stored in AWS policy stores.
Where decisions run Wherever the workload runs, on AWS (Lambda, ECS, EKS, EC2), another cloud, on-premise or a hybrid mix, under one set of policies. In an AWS Region, through the IsAuthorized API. Local evaluation exists only as open source Rust libraries labeled experimental.
Data on each request The application sends what it has, and Cerbos Synapse fetches the rest from the system that owns it, Amazon Cognito included. Every principal, resource, parent and attribute the policies need travels in the request, up to 1 MB. The service fetches nothing.
"What can this person see" Query plans return the policy as a filter your database applies, with adapters for Prisma, Drizzle, Mongoose, SQLAlchemy and others. To check records you already hold, one CheckResources call takes up to 50 resources by default. BatchIsAuthorized returns up to 30 decisions per call, for one principal or one resource. No filter is returned.
Decision logs Collected by Cerbos Hub from every decision point, linked to the policy version behind each decision, searchable and exportable. Recorded only if you turn on CloudTrail data events, AWS's per-request audit records, which are off by default. The record shows the decision but not the policies behind it.
Tenants One set of policies, with scoped policies where a tenant needs different rules. One shared policy store, or one store per tenant with every shared policy change replicated to each store.
Testing Test suites in Git that run in any CI system, and Cerbos Hub only builds a deployment when they pass. A test bench in the AWS console.
Standards Cerbos PDP and Cerbos Synapse both implement the AuthZEN Authorization API. AWS publishes a sample Lambda function that translates AuthZEN requests into Verified Permissions calls. The service API is its own.
Pricing Published, by monthly active principals. $0 proof of concept, Development from $25 a month, Production from $933 a month, Enterprise custom. Per request. $5 per million single checks since June 2025, batch and policy management priced separately.

Where Cerbos and Amazon Verified Permissions run authorization decisions

Authorization sits in the path of every request, so where it runs decides your latency, your resilience and which clouds you can use.

Verified Permissions runs in AWS. Your application calls IsAuthorized in a Region, the service evaluates the policies in your policy store, and returns allow or deny. AWS lists it in 34 commercial Regions and two GovCloud Regions (October 2026), and it is fully managed, with nothing to install. Every decision is a network call to AWS, though, and every application that needs one has to reach an AWS endpoint. Two open source Rust libraries evaluate Cedar locally. Both are labeled experimental and have had no release since April 2025, and the Verified Permissions one still pulls policy from the service (both read in October 2026).

Cerbos decision points run where the workload does, as a service, a sidecar, a Kubernetes DaemonSet, a serverless function or in the browser through WebAssembly. On AWS that means inside Lambda next to your function, or on ECS and EKS, so the decision is a local call. The same decision points run on Azure, Google Cloud or on-premise, governed by the same policies. Cerbos Hub builds, tests and distributes policy to all of them, hosted or on-premise for regulated teams. If Hub is unreachable, running decision points keep serving the last policy they received. You can also buy Cerbos through AWS Marketplace, so the spend can count toward your AWS commitment.

Staying on AWS does not settle this. The choice is whether authorization should depend on one cloud's API, or run next to each workload under one set of policies.

Decision-time data in Cerbos and Amazon Verified Permissions

Fine-grained decisions depend on facts such as who owns the record, which tenant it belongs to, which team the person is on today, which folders sit above a document. Somebody has to gather those facts for every decision.

With Verified Permissions, that is your application. Every principal, resource and parent the policies read goes into the request as an entity list, up to 1 MB (October 2026), and the service fetches nothing itself. AWS also caps parents at 100 per entity, a limit it marks as not adjustable (October 2026). For a document three folders deep in a shared drive, or a user in many groups, your code assembles the hierarchy before every call.

In Cerbos, the application sends what it already has, and Cerbos Synapse fetches the rest at decision time from the system that owns it, with caching set to how often each value changes. That includes Amazon Cognito groups and attributes, directories, databases and internal APIs, as we show in looking up identity attributes at decision time. Synapse is also what Envoy, Istio, Kafka and Trino call for their decisions, so the layer that gathers facts for an application is the same one your gateways and data platforms use.

The difference shows up in code reviews. With Verified Permissions, every new attribute is a change to the code that builds the entity list in each application that calls it. With Cerbos, it is a change to the policy and, where needed, one data source.

Listing what a person can access with Cerbos and Amazon Verified Permissions

Most applications do not only ask "can Ana open this invoice". They ask "show Ana every invoice she can open, sorted, 50 to a page".

Verified Permissions answers one decision at a time, or up to 30 in a BatchIsAuthorized call for a single principal or resource (October 2026). To build a list, you load candidate records and check them in batches, which breaks pagination and total counts once most of what you loaded is filtered out. Cedar has an experimental partial evaluation feature in its library, and Verified Permissions does not expose it.

Cerbos query plans return the policy itself as a filter, "owner is Ana, or the invoice is shared with her team and not archived", and an adapter turns it into the WHERE clause of the query you already run. The database returns only the rows Ana may see, already sorted and paginated. Adapters cover Prisma, Drizzle, Mongoose, Convex, SQLAlchemy and LangChain with ChromaDB, and the plan is plain enough to translate for anything else.

ACES, a Tokyo AI company, put Verified Permissions, OpenFGA and Cerbos side by side for its AI meeting product and wrote up the decision (in Japanese). Verified Permissions kept authorization data in the application, which they wanted, and lost on lists. The 30-item batch limit and the lack of a returned filter were the constraint, alongside the 100-parent limit and a strong dependence on AWS. They chose Cerbos and translated its query plans into Elasticsearch queries for their meeting search.

Where authorization policy lives in Cerbos and Amazon Verified Permissions

Security approves the rules, identity teams govern them, and engineers ship them. Each needs to read the policy, see what changed and know it was tested.

Verified Permissions keeps policies in policy stores, one per application or one per tenant, with a schema that checks them on the way in and a test bench in the AWS console that runs one request at a time. Versioning, review and promotion between environments come from whatever you build around it, usually CloudFormation or CDK in your own pipeline. The language is Cedar, and its rules, limits and error handling are compared with Cerbos policy in Cerbos vs Cedar.

A Cerbos policy is a short YAML file with conditions in CEL, also used in Kubernetes, and a schema checks attributes before the policy runs. Policies live in Git or Cerbos Hub policy stores, and every change can go through the pull request review your organization already uses. Test suites sit next to the policies and run in any CI system, and Cerbos Hub only builds a deployment when they pass. People who do not write YAML use the Cerbos Hub playground, where a permissions matrix shows who can do what before a change is proposed.

The difference is the work around the rule. With Verified Permissions, your team builds the review, the test pipeline and the promotion from staging to production. With Cerbos, they come with the platform, and the same build reaches every decision point, in every account and cloud.

Multi-tenant authorization in Cerbos and Amazon Verified Permissions

B2B products need the same rules for every customer, plus the exceptions one customer negotiated.

AWS's own guidance offers two designs. One shared policy store holds every tenant's policies, or each tenant gets its own store, isolated, with every shared policy change replicated to every store, which AWS rates as high effort. Policy store aliases, added in April 2026, make per-tenant stores easier to address. Shared policies are still copied into each one.

Cerbos keeps one set of policies. Scoped policies let a tenant narrow or extend the shared rules for its own resources, and a change to the shared rule applies to every tenant in the next build. Per-person grants stay data, a list of editors on the document, where Cedar's own guidance creates a separate policy from a template for every share. Our guide to multitenant authorization walks through the patterns.

cerbos-vs-amazon-verified-permissions-multi-tenant-authorization-one-policy-set.png

Cerbos and Amazon Verified Permissions across applications, gateways, data platforms and AI agents

Verified Permissions answers the applications that call it, with an Express integration and a documented Lambda authorizer for Amazon API Gateway. AWS's agent product, Policy in Amazon Bedrock AgentCore, is a separate service that also uses Cedar, generally available since March 2026, and it checks only the tool calls that pass through the AgentCore gateway.

Cerbos covers each of these layers from one set of policies and one decision log.

  • Applications call Cerbos through an SDK in eight languages, one call in place of permission checks scattered through the code.
  • API gateways and service meshes use Cerbos at Amazon API Gateway, Kong and Apigee, and Cerbos Synapse is the external authorization service for Envoy and Istio.
  • Data platforms get Cerbos answering Trino's authorization calls, so a query returns only the rows and columns a person may see, and Kafka's, so only approved services read or write a topic.
  • AI agents have every tool call checked against policy before it runs, down to its arguments, wherever you enforce it, in the agent through hooks, in the harness such as Claude Code, at an MCP gateway, or in the MCP server itself. The agent's token and the person's token travel in the same request, so a policy can require both.

Agents follow access, not instructions, so a prompt is never the control. You can put Cerbos in front of an agent's tool calls before writing any policy, with audit logging on, so every call passes through and is logged with the person behind it, the tool and its arguments. Write the policy from that record, then narrow it, read-only on payment systems or no deletes in production, and each change applies on the next call without taking the agent offline.

cerbos-vs-amazon-verified-permissions - one policy set, every enforcement point (1).png

Audit logs and compliance evidence in Cerbos and Amazon Verified Permissions

A security team needs a fast answer to "show me the policy that was in effect at the time", for any decision, months later.

Verified Permissions returns the policies that determined each decision in the API response, to your application. Keeping that record is a separate step. IsAuthorized calls are CloudTrail data events, AWS's per-request audit records, which it does not log by default, and a logged event records the request and the decision, without the determining policies (AWS documentation, October 2026). Keeping evidence means turning on a trail that records data events, paying for them, and joining them to the policy history yourself.

A Cerbos decision log records the request inputs and the outcome of every decision, linked to the policy version behind it. Cerbos Hub collects those logs from every decision point, on AWS or anywhere else, into one searchable trail filtered by person, resource, action or outcome, and you can export them for your own archive. Each decision point can also write its log to a file or Kafka, for your SIEM to collect. With the Git history of every policy change alongside, the answer to an auditor comes from a search.

Cerbos holds a SOC 2 Type II attestation. The decision records and policy history are what give your own SOC 2, ISO 27001, HIPAA, PCI DSS or DORA audits their evidence.

Standards, portability and lock-in with Cerbos and Amazon Verified Permissions

Cedar, the language Verified Permissions runs, is open source, so the policies themselves can leave AWS. The service around them cannot, and running Cedar elsewhere means building the distribution, the testing pipeline and the decision logs yourself, as our guide to Cedar alternatives explains. Within AWS, every policy store in an account runs the same Cedar version, and AWS sets the upgrade timetable. Stores still on Cedar 2 lost their authorization APIs from April 2026 (AWS documentation, October 2026).

Cerbos PDP, the decision engine inside the Cerbos platform, is open source under Apache 2.0, so the component in your request path can be inspected line by line. On the request side, Cerbos PDP and Cerbos Synapse both implement AuthZEN, the OpenID Foundation's Authorization API for how enforcement points ask for decisions. For Verified Permissions, AWS publishes a sample Lambda function that translates AuthZEN requests into its own API. Alex Olivier, our cofounder and CPO, co-chairs the AuthZEN Working Group, so read our view on it with that in mind. A standard request format means your enforcement points do not have to change if your decision service does.

Cerbos and Amazon Verified Permissions pricing

Verified Permissions charges per request, listed on AWS's pricing page in October 2026 as $5 per million single authorization checks, after AWS announced a cut of up to 97% in June 2025. Batch checks are $150 per million requests for the first 40 million a month, each covering up to 30 decisions, and policy management calls are $40 per million. There is no free tier. The check itself is cheap. The cost to count is what sits around it, the code that assembles entity data for every call, the CloudTrail data events if you keep decision logs, the per-tenant stores, and the list filtering you build on top of batch checks.

Cerbos publishes its pricing, based on monthly active principals, the people and services that get an authorization decision in a month, with no charge per decision.

  • Proof of concept. $0, with a week of decision logs.
  • Development. From $25 a month, with three months of decision logs.
  • Production. From $933 a month, with unlimited workspaces, decision points and tenants, and a year of decision logs.
  • Enterprise. Custom, adding SSO, self-hosted Cerbos Hub, custom log retention and phone support.

A busy service costs the same as a quiet one, because the bill follows principals, not checks.

Cerbos at enterprise scale

The Cerbos platform answers more than 2 billion authorization checks a month, on AWS and everywhere else our customers run. Utility Warehouse, which serves more than 814,000 UK households, uses it across more than 4,500 services and thousands of non-human identities, with millions of access decisions a day.

Industry analysts cover us as well. Cerbos is recognized in the AuthZEN category of the Gartner® Hype Cycle™ for Digital Identity, 2026, and is included in several KuppingerCole Leadership Compass reports, among them policy based access management, API security and management and generative AI defense.

cerbos-vs-amazon-verified-permissions-cerbos-at-enterprise-scale.png

When Amazon Verified Permissions may still fit

If one AWS application needs a handful of rules, its entity data is small and already in hand, nobody needs lists filtered by permission, and nothing outside AWS needs the same rules, Verified Permissions does that job inside your account. When the second application, the first list or the first non-AWS workload arrives, the migration guide shows how to move one service at a time.

Choosing between Cerbos and Amazon Verified Permissions

For an organization that wants authorization as a shared service across applications, gateways, data platforms and AI agents, on AWS and beyond it, Cerbos is the stronger choice. Decisions run next to each workload, facts come from the systems that own them, lists come back as database filters, and decisions from every decision point sit on one trail, linked to the policy behind them.

As Steve High, Staff Engineer at Complex, put it, "With Cerbos, we have one repo of policies. That's all you have to worry about."


Try Cerbos with the policies from your busiest policy store. Your engineers stop assembling entity data before every call, your identity team sees the same rules applied in every AWS account and every other cloud, and your security team can show the policy behind any past decision without joining CloudTrail records to policy history.

To plan the move from Amazon Verified Permissions, book a call with our team and leave with a plan for which application moves first, and the evidence your auditors will see.

Go deeper:

FAQ

Tagged in

Free policy workshop

Get your first Cerbos policy written by our team.

Book a session to talk through your requirements and walk away with a working policy.

Book a session