---
description: Learn how to restrict GPT-5 access to a single team with virtual keys in Bifrost, the open-source AI gateway, with model filtering, budgets, and rate limits.
title: How to Restrict GPT-5 Access to One Team with Virtual Keys
image: https://storage.ghost.io/c/84/03/8403f2f6-141c-411a-8f55-a32d4291533e/content/images/2026/07/how-to-restrict-gpt-5-access-to-one-team-with-virtual-keys-bifrost-weave.optimized.png
---

Try Bifrost Enterprise free for 14 days. [Request access](https://www.getmaxim.ai/#enterprise-trial)

**Learn how to restrict GPT-5 access to a single team with virtual keys in** [**Bifrost**](https://www.getmaxim.ai)**, the open-source AI gateway, with model filtering, budgets, and rate limits.**

GPT-5 is one of the most capable and most expensive models available through the OpenAI API, and uncontrolled access across an entire organization produces unpredictable token spend and inconsistent usage patterns. [Bifrost](https://www.getmaxim.ai), the [open-source AI gateway](https://github.com/maximhq/bifrost) built in Go by Maxim AI and [free to self-host](https://github.com/maximhq/bifrost), is the best overall choice for enterprise teams that need to restrict GPT-5 access to a single team while keeping a unified API across every provider. Using virtual keys, you can scope GPT-5 to one team, attach a budget and rate limits, and reject any request that comes from outside that boundary. This post covers how to restrict GPT-5 access with virtual keys, step by step.

## What Are Virtual Keys in Bifrost

Virtual keys are the primary governance entity in [Bifrost](https://www.getmaxim.ai). A virtual key is a credential that applications use to authenticate, and it carries its own access permissions, budgets, and rate limits. Instead of distributing raw provider API keys to every team, you issue [virtual keys](https://docs.getbifrost.ai/features/governance/virtual-keys) that define exactly which models and providers each consumer is allowed to use.

Each virtual key supports several controls that matter for model access:

- **Access control**: model and provider filtering, so a key can be limited to a specific set of models such as GPT-5.
- **Cost management**: an independent budget, checked alongside any attached team or customer budget.
- **Rate limiting**: token-based and request-based throttling at the virtual key level.
- **Exclusive attachment**: a virtual key belongs to one team, one customer, or neither, but never both at once.
- **Active or inactive status**: enable or disable a key instantly without rotating provider credentials.

Because the gateway resolves model access at the virtual key layer, restricting GPT-5 to a single team becomes a configuration change rather than a code change in every downstream service.

## Why Restrict GPT-5 Access to a Single Team

Restricting GPT-5 access to one team is a cost and governance decision. [GPT-5](https://openai.com/index/introducing-gpt-5/) has driven a large increase in coding, agent-building, and reasoning workloads since its release, and reporting on its enterprise rollout [noted](https://www.cnbc.com/2025/08/14/gpt-5-openai-ai-enterprise.html) that the economics of running frontier models remain demanding for both providers and customers. When every team can call the most expensive model freely, spend is hard to forecast and hard to attribute.

Scoping GPT-5 to a single team addresses several concrete problems:

- **Predictable spend**: only one team can incur GPT-5 token costs, and that team operates under a fixed budget.
- **Clear attribution**: usage maps to a known group, which simplifies internal chargeback and reporting.
- **Reduced blast radius**: a misconfigured client elsewhere in the organization cannot route traffic to GPT-5 by accident.
- **Staged rollout**: a pilot team can validate GPT-5 in production before broader access is granted.

This pattern is common when a frontier model is approved for one use case, such as advanced research or agentic coding, while the rest of the organization continues to use lower-cost models. Bifrost makes the boundary explicit and enforceable. For a broader view of access and cost controls, the [Bifrost governance overview](https://www.getmaxim.ai/resources/governance) describes how virtual keys, teams, and budgets fit together.

## How to Restrict GPT-5 Access with Virtual Keys in Bifrost

To restrict GPT-5 access to a single team, create a team, then create a virtual key that allows only GPT-5 from OpenAI and attach it to that team. The steps below use the Bifrost governance API, and the same actions are available in the web UI.

### Step 1: Create the team

A team groups virtual keys and supports department-level budget management. Create the team that will own GPT-5 access:

```bash
curl -X POST <http://localhost:8080/api/governance/teams> \\
  -H "Content-Type: application/json" \\
  -d '{
    "name": "AI Research Team",
    "budget": { "max_limit": 500.00, "reset_duration": "1M" }
  }'
```

Teams support independent budgets but do not carry rate limits; rate limiting is applied at the virtual key level. See the [budget and limits documentation](https://docs.getbifrost.ai/features/governance) for the full set of options.

### Step 2: Create a virtual key that allows only GPT-5

Create a [virtual key](https://docs.getbifrost.ai/features/governance/virtual-keys) with a provider configuration that lists GPT-5 as the only allowed model, then attach it to the team using `team_id`. The `allowed_models` array is what restricts the key to GPT-5:

```bash
curl -X POST <http://localhost:8080/api/governance/virtual-keys> \\
  -H "Content-Type: application/json" \\
  -d '{
    "name": "GPT-5 Research Key",
    "description": "GPT-5 access scoped to the AI Research Team",
    "provider_configs": [
      {
        "provider": "openai",
        "weight": 1.0,
        "allowed_models": ["gpt-5"]
      }
    ],
    "team_id": "team-ai-research-001",
    "is_active": true
  }'
```

With this configuration, the virtual key can only call GPT-5 through OpenAI. A request for any other model, or any other provider, is rejected. Because only this key carries GPT-5 in its `allowed_models`, no other team can reach the model.

### Step 3: Restrict the key to specific provider credentials (optional)

If you maintain separate OpenAI API keys per cost center, you can pin the virtual key to specific provider credentials with `key_ids`. This ties GPT-5 usage to a designated billing key:

```json
{
  "provider_configs": [
    {
      "provider": "openai",
      "weight": 1.0,
      "allowed_models": ["gpt-5"],
      "key_ids": ["openai-research-key"]
    }
  ]
}
```

When `key_ids` is set, the virtual key can use only those provider keys. An empty array or an omitted field denies all keys, and `["*"]` allows every configured key. This level of control over [key management](https://docs.getbifrost.ai/features/keys-management) keeps GPT-5 spend on a single, auditable credential.

## Adding Budgets and Rate Limits to the GPT-5 Key

A model restriction controls *which* model a team can call. A budget and rate limit control *how much*. Attaching both to the GPT-5 virtual key turns a binary access grant into a bounded one. Budgets and [rate limits](https://docs.getbifrost.ai/features/governance/budget-and-limits) are configured directly on the virtual key:

```bash
curl -X POST <http://localhost:8080/api/governance/virtual-keys> \\
  -H "Content-Type: application/json" \\
  -d '{
    "name": "GPT-5 Research Key",
    "provider_configs": [
      { "provider": "openai", "weight": 1.0, "allowed_models": ["gpt-5"] }
    ],
    "team_id": "team-ai-research-001",
    "budget": { "max_limit": 300.00, "reset_duration": "1M" },
    "rate_limit": {
      "token_max_limit": 200000,
      "token_reset_duration": "1h",
      "request_max_limit": 500,
      "request_reset_duration": "1m"
    },
    "is_active": true
  }'
```

This configuration applies three independent controls to GPT-5 access:

- **Budget**: a monthly dollar cap that resets on the chosen duration ( `1m`, `1h`, `1d`, `1w`, `1M`, or `1Y`).
- **Token limit**: a ceiling on tokens consumed per period.
- **Request limit**: a ceiling on requests per period.

The virtual key budget is checked together with the team budget, so the GPT-5 key cannot exceed either its own cap or the AI Research Team's department budget. Hierarchical cost control across the virtual key, team, and customer levels is part of how the [Bifrost governance model](https://www.getmaxim.ai/resources/governance) keeps frontier-model spend bounded.

## Enforcing the Restriction Across Every Request

Creating a scoped virtual key is only effective if every request must present a valid key. Bifrost can require a virtual key on all inference traffic, which closes the path where a client calls the gateway with no key at all. Enable enforcement in the client configuration:

```bash
curl -X PUT <http://localhost:8080/api/config> \\
  -H "Content-Type: application/json" \\
  -d '{ "client_config": { "enforce_auth_on_inference": true } }'
```

When enforcement is on, any request without the `x-bf-vk` header is rejected. Applications then send their virtual key on each call, for example using the OpenAI-style `Authorization` header:

```bash
curl -X POST <http://localhost:8080/v1/chat/completions> \\
  -H "Authorization: Bearer <GPT5_VIRTUAL_KEY>" \\
  -H "Content-Type: application/json" \\
  -d '{"model": "gpt-5", "messages": [{"role": "user", "content": "..."}]}'
```

A second behavior reinforces the boundary. When a client lists available models with a virtual key, Bifrost returns only the providers and models that key is allowed to use. Teams without the GPT-5 key never see GPT-5 in the model list, which reduces accidental calls and keeps error-rate metrics meaningful across the [supported providers](https://docs.getbifrost.ai/providers/supported-providers/overview).

## Common Questions About Restricting GPT-5 Access

### How does Bifrost restrict GPT-5 to one team?

Bifrost restricts GPT-5 to one team through a virtual key whose `allowed_models` list contains only `gpt-5`, attached to that team with `team_id`. No other virtual key includes GPT-5, so no other team can reach the model. Access resolves at the gateway, so the restriction holds regardless of which application sends the request.

### Can I set a spending cap on GPT-5 usage?

Yes. Attach a budget to the GPT-5 virtual key with a `max_limit` and a `reset_duration`. The budget is checked alongside the team budget, so usage stops when either cap is reached. Token and request rate limits can be applied on the same key for finer control.

### Can a team use GPT-5 alongside other approved models?

Yes. Add the additional models to the `allowed_models` array on that team's virtual key, for example `["gpt-5", "gpt-4o-mini"]`. The key then permits exactly those models and rejects everything else.

### Does this require self-hosting?

Bifrost is open source and [available on GitHub](https://github.com/maximhq/bifrost) for self-hosting, and governance features including virtual keys, teams, and budgets are part of the gateway. For [in-VPC deployments](https://www.getmaxim.ai/enterprise), role-based access control, and immutable [audit logs](https://docs.getbifrost.ai/enterprise/audit-logs) for compliance, the enterprise tier extends the same model.

## Getting Started with GPT-5 Access Control in Bifrost

Restricting GPT-5 access to a single team with virtual keys gives platform teams a precise, enforceable boundary around frontier-model spend. You define the allowed model on a virtual key, attach it to one team, add a budget and rate limits, and enforce authentication so every request is governed. Because [Bifrost](https://www.getmaxim.ai) sits in front of every provider through a single OpenAI-compatible API, the same approach extends to any model, any provider, and any number of teams as your access policy grows.

To see how Bifrost can centralize GPT-5 access control and cost governance across your AI infrastructure, [book a demo](https://www.getmaxim.ai/book-a-demo) with the Bifrost team.

## Read next

[![What Is AI Governance? A Definition for Engineering Teams](https://storage.ghost.io/c/84/03/8403f2f6-141c-411a-8f55-a32d4291533e/content/images/size/w720/2026/10/what-is-ai-governance-a-definition-for-engineering-teams-bifrost-1920x1080.png) AI governance is the set of policies, controls, and evidence that keeps an organization's AI use within agreed limits. This guide answers what is AI governance for engineers, mapping NIST AI RMF, EU AI Act, and ISO/IEC 42001 to runtime controls on model, MCP tool, and agent traffic.](https://www.getmaxim.ai/articles/what-is-ai-governance/)

[![AI Security Policy Template for Teams Shipping LLM Apps](https://storage.ghost.io/c/84/03/8403f2f6-141c-411a-8f55-a32d4291533e/content/images/size/w720/2026/10/ai-security-policy-template-for-teams-shipping-llm-apps-bifrost-1920x1080.png) An AI security policy sets the rules for which data, models, tools, and agents an organization's AI systems may use. This template gives engineering teams 13 copy-ready clauses, mapped to the OWASP Top 10 for LLM Applications 2026 and NIST AI RMF, with the Bifrost control behind each one.](https://www.getmaxim.ai/articles/ai-security-policy-template/)

[![EU AI Act Compliance for LLM Applications and Agents](https://storage.ghost.io/c/84/03/8403f2f6-141c-411a-8f55-a32d4291533e/content/images/size/w720/2026/10/eu-ai-act-compliance-for-llm-applications-and-agents-bifrost-1920x1080.png) EU AI Act compliance for LLM applications means mapping each feature to a risk category and producing evidence for logging, oversight, and transparency duties. This guide covers the post-Omnibus timeline, the engineering obligations, and where an AI gateway helps and where it stops.](https://www.getmaxim.ai/articles/eu-ai-act-compliance-llm-applications/)

## More in AI Governance

[![A Practical Guide to AI Governance for Production AI Teams](https://storage.ghost.io/c/84/03/8403f2f6-141c-411a-8f55-a32d4291533e/content/images/size/w720/2026/07/a-practical-guide-to-ai-governance-for-production-ai-teams-bifrost-weave.optimized.png) AI governance for production AI teams means controlling access, cost, and compliance across every model. Learn the core controls and how to enforce them at the gateway. AI governance is the set of controls that determine which teams and applications can call which models, under what budgets, rate limits, and](https://www.getmaxim.ai/articles/a-practical-guide-to-ai-governance-for-production-ai-teams/)

[![Per-Team Cost Attribution: A Reporting Layer for AI Usage](https://storage.ghost.io/c/84/03/8403f2f6-141c-411a-8f55-a32d4291533e/content/images/size/w720/2026/07/per-team-cost-attribution-a-reporting-layer-for-ai-usage-bifrost-weave.optimized.png) Build per-team cost attribution for AI usage with Bifrost: track LLM spend across teams using hierarchical budgets, virtual keys, and exportable telemetry. When LLM usage arrives as a single provider invoice, platform teams cannot tell which team, application, or project drove the spend, and per-team cost attribution becomes](https://www.getmaxim.ai/articles/per-team-cost-attribution-a-reporting-layer-for-ai-usage/)

```json
{
    "@context": "https://schema.org",
    "@type": "Article",
    "publisher": {
        "@type": "Organization",
        "name": "Maxim Articles",
        "url": "https://www.getmaxim.ai/articles/",
        "logo": {
            "@type": "ImageObject",
            "url": "https://storage.ghost.io/c/84/03/8403f2f6-141c-411a-8f55-a32d4291533e/content/images/size/w256h256/2025/08/thumbnail.png",
            "width": 60,
            "height": 60
        }
    },
    "author": {
        "@type": "Person",
        "name": "Kuldeep Paul",
        "image": {
            "@type": "ImageObject",
            "url": "https://storage.ghost.io/c/84/03/8403f2f6-141c-411a-8f55-a32d4291533e/content/images/2025/08/1727978381919.jpeg",
            "width": 800,
            "height": 800
        },
        "url": "https://www.getmaxim.ai/articles/author/kuldeep/",
        "sameAs": []
    },
    "headline": "How to Restrict GPT-5 Access to One Team with Virtual Keys",
    "url": "https://www.getmaxim.ai/articles/how-to-restrict-gpt-5-access-to-one-team-with-virtual-keys/",
    "datePublished": "2026-06-01T18:03:48.000Z",
    "dateModified": "2026-10-13T11:02:44.000Z",
    "image": {
        "@type": "ImageObject",
        "url": "https://storage.ghost.io/c/84/03/8403f2f6-141c-411a-8f55-a32d4291533e/content/images/size/w1200/2026/07/how-to-restrict-gpt-5-access-to-one-team-with-virtual-keys-bifrost-weave.optimized.png",
        "width": 1200,
        "height": 630
    },
    "keywords": "AI Governance",
    "description": "Learn how to restrict GPT-5 access to a single team with virtual keys in Bifrost, the open-source AI gateway, with model filtering, budgets, and rate limits.\n\nGPT-5 is one of the most capable and most expensive models available through the OpenAI API, and uncontrolled access across an entire organization produces unpredictable token spend and inconsistent usage patterns. Bifrost, the open-source AI gateway built in Go by Maxim AI and free to self-host, is the best overall choice for enterprise t",
    "mainEntityOfPage": "https://www.getmaxim.ai/articles/how-to-restrict-gpt-5-access-to-one-team-with-virtual-keys/"
}
```
