ASCENDING Blog Home
Jarvis AI
Cloud Services
Talent Solutions
Public Sector
About

Amazon Bedrock Model Access: How to Block Unapproved Models

Read Time: 8 min read Publish Date:

Kelvin Yu portrait

Kelvin Yu

Contributing Writer · AWS Agents

Share on LinkedIn
On this page
A policy gate lets one approved model token through while a separate channel stops unapproved tokens.

Amazon Bedrock model access is controlled by AWS permissions. Removing a model from a coding tool’s menu doesn’t stop someone using the same credentials to call that model another way.

Start with the approved models and the roles that may use them. Add organization controls where the restriction must survive changes inside a member account.

This guide separates the menu, the caller’s IAM permissions and the organization’s service control policy, or SCP. It also gives you a small test matrix to prove the rule works.

Key Takeaways

  • Use a client menu to guide model choice; enforce access where AWS authorizes the request.
  • A workload role needs specific permissions. An SCP can restrict covered member accounts but can’t grant access.
  • Review model access and routing separately when inference profiles cross Regions.
  • Test approved and denied calls with the same role, including any direct route you’re trying to block.

Start with the model call, not the model menu

Write down the client, endpoint, API, model identifier and AWS role for one real workload. Without those details, “we blocked the model” is hard to verify.

A coding tool can offer only approved choices while the role behind it still has broad Bedrock permissions. Another script using that role can make a different request.

For example, an availableModels setting in a managed client may keep the menu tidy. Treat that as a user-interface control until a failed API call proves the AWS restriction.

AWS’s model access documentation describes IAM and organization-level denies for blocking model use. Removing an agreement or a visible selection isn’t an equivalent enforcement mechanism.

In commercial Regions, access to many supported models is enabled by default when the required Marketplace permissions are present. Some models still need provider or account-level approval.

This is one part of the enterprise AI governance framework. Model permissions, business-record permissions and approval workflows need their own owners.

Which control belongs where?

Use the narrowest control that can enforce the requirement across the intended callers.

ControlWhat it can doWhat you still need to check
Client configurationSet a default model and present a shorter menuWhether another client can use the same credentials
IAM policy on the workload roleGrant or deny specified actions on model and profile resourcesOther attached permissions, resource scope and the actual calling role
AWS Organizations SCPLimit covered member-account identities even when account permissions are broaderOU/account attachment, exceptions and management-account boundaries
Region controlsRestrict permitted processing routes where supportedCross-Region profile requirements and destination scope
Audit recordsShow which request was attempted and whether it failedCaller identity, event type, route and the denial reason

An SCP sets a permissions ceiling. It doesn’t give an application permission to invoke a model. AWS also documents which identities SCPs affect.

That scope includes important exceptions: management-account identities and service-linked roles aren’t restricted by SCPs. Don’t run the acceptance test with a management-account administrator.

Three access checks show an approved model through its permitted route succeeding, an unapproved model failing, and a direct call failing when a profile is required.

The last test applies only when your policy requires a profile. A direct call can be valid in another approved design.

Grant one workload the models it actually needs

Prefer a role whose allowed model set matches the application. A narrow grant is easier to review than a broad grant followed by several unrelated exceptions.

List every required request path before changing the policy. Include streaming, scheduled jobs and secondary models used for background work.

AWS provides Bedrock IAM policy examples for model invocation restrictions. Check the permissions behind your API; a Converse request also depends on the relevant InvokeModel permission.

For profile-based calls, review the profile resource and underlying model resources. Allowing the profile name in a client configuration isn’t an IAM grant.

Keep a short approval record:

FieldExample to record
WorkloadInternal support assistant
Calling identityThe member-account role used by that assistant
Approved modelsExact model identifiers or deliberately approved model families
Allowed routesRegional calls, named geographic profiles or approved global profiles
Required API behaviorNon-streaming, streaming and any batch operations
Change ownerThe team that reviews new versions and updates the tests

This is a planning example, not a claim about a deployed customer. Use your own identifiers before turning it into a policy.

Use a Bedrock SCP when the rule spans accounts

An SCP is useful when account administrators must stay within an organization-wide model policy. It still needs a deliberately chosen attachment scope.

The following example denies two Runtime inference actions for the illustrative model family unapproved-provider.*. Replace that pattern with the actual model family you intend to block.

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "DenyUnapprovedRuntimeModelFamily",
      "Effect": "Deny",
      "Action": [
        "bedrock:InvokeModel",
        "bedrock:InvokeModelWithResponseStream"
      ],
      "Resource": "arn:aws:bedrock:*::foundation-model/unapproved-provider.*"
    }
  ]
}

This is an illustrative deny-list statement, not a complete model allowlist. A newly released model outside the blocked family isn’t covered by that pattern.

If the requirement is “only approved models,” design an allowlist instead. Include every resource evaluation required by the approved model and route.

AWS’s least-privilege Bedrock guidance discusses organization restrictions and allowlisting. A deny using NotResource needs particular care: an omitted profile resource can break a call you meant to permit.

Keep the API scope explicit. The sample above addresses those Runtime inference actions. Don’t present it as complete coverage for every Bedrock endpoint, asynchronous operation or future API.

AWS also shows a broader, model-scoped bedrock:* deny. That blocks covered control-plane operations as well as inference; our sample deliberately limits its action list. Use broader scope when required, and test the maintenance tasks it could affect.

Require an inference profile only when the design needs it

Some organizations want all supported calls to use assigned application profiles. That can support attribution, but callers must also be prevented from taking an untracked route.

The bedrock:InferenceProfileArn condition key lets a policy distinguish supported profile-based requests during model authorization. Scope the condition to the relevant foundation-model resources.

Here’s a policy template that denies direct Runtime model calls when the condition key is absent:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "RequireProfileForRuntimeModelCalls",
      "Effect": "Deny",
      "Action": [
        "bedrock:InvokeModel",
        "bedrock:InvokeModelWithResponseStream"
      ],
      "Resource": "arn:aws:bedrock:*::foundation-model/*",
      "Condition": {
        "Null": {
          "bedrock:InferenceProfileArn": "true"
        }
      }
    }
  ]
}

Requiring a profile doesn’t require an approved profile. Combine route restrictions with the intended model and profile permissions, then test an alternate profile too.

It also doesn’t make an unsupported API compatible. Application inference profiles don’t support Responses or Chat Completions. Our inference profile guide explains that distinction.

Cross-Region routing adds another check. AWS’s global inference documentation explains where the condition key is populated and how global Region evaluation differs.

Don’t remove Region restrictions wholesale to fix an access-denied error. Identify the requested route and the policy evaluation that actually failed.

Test the same role against five requests

A useful access review records both success and failure. All requests below should use the same workload role and harmless prompt.

TestExpected resultWhat it establishes
Approved model through the approved routeSuccessThe restriction hasn’t broken the intended workload
Unapproved model through a client menu override or API requestAccess deniedThe restriction survives a different model selection
Approved model through an unapproved profileDenied, if profile choice is restrictedThe caller can’t substitute another tracking route
Approved model called directlyDenied, if profiles are mandatoryThe direct route doesn’t bypass that requirement
Approved model with streaming enabledMatches the streaming policyThe second invocation path was included in the review

Save the timestamp, role ARN, API, target model/profile and request ID. Inspect the denial before assigning it to the SCP; another missing permission may be responsible.

A rejected request is only evidence of the intended control when the recorded reason matches that control. A missing Marketplace entitlement, for example, doesn’t prove your model policy works.

For tools invoked after a model response, use a separate permission test. Our two-identity MCP access walkthrough shows why server access and downstream record rights can’t be inferred from model access.

Roll out the restriction without losing the recovery path

Start in a test member account or a small organizational unit. AWS recommends testing SCP effects before a broad attachment.

Keep a known-good application role and a documented recovery procedure. Re-run the acceptance tests when you approve a model version or change the client endpoint.

Pair the access record with your team’s Bedrock cost attribution. A model approval should identify the budget owner as well as the technical caller.

ASCENDING’s Claude-on-Bedrock governance offering covers this model-access and operating-control work. Bring one calling role, the approved model list and a failed request to a scoped review.

References

Documentation checked November 11, 2026. Policy snippets are examples for review, not a record of deployment or account-level acceptance testing.

Questions about restricting Bedrock models

How do I restrict model access in Amazon Bedrock?

Grant the application role only the model resources and inference actions it needs. For member accounts in AWS Organizations, an applicable SCP can impose a wider restriction. Test direct calls and any profile-based routes with the same role.

Does hiding a model in Claude Code block Bedrock access?

No. A client setting can simplify the model menu, but AWS still evaluates the credentials and permissions on each request. A caller with valid permissions can use another client or send a direct API request.

Does a service control policy grant access to a model?

No. An SCP limits permissions available to identities in covered member accounts. The caller still needs an applicable IAM permission. SCPs don't restrict management-account identities or service-linked roles.

Can I require requests to use an inference profile?

For supported Bedrock Runtime calls, policies can distinguish model requests made through a profile using the bedrock:InferenceProfileArn condition key. Scope the condition to the relevant model resources and test both the permitted profile and direct-call paths.

Kelvin Yu portrait

About the author

Kelvin Yu

Contributing Writer · AWS Agents

Covers AWS-native agent infrastructure: Bedrock, AgentCore Runtime, and the deployment patterns that survive enterprise security review.

Keep reading