# Grant access to models

Last validated Jun 25, 2026

\[Missing snippet: aperture\_release\_note.mdx]

Aperture is deny-by-default. Without grants, users can connect to the Aperture device but cannot access any models. This guide covers how to configure network access to Aperture and set up grants that control which models each user or group can use.

For more information on how Aperture uses Tailscale identity for authentication and access control, refer to [How Aperture works][kb-how-aperture-works]. For the model behind grants, including deny-by-default access and precedence, refer to [how Aperture grants work][kb-how-grants-work].

## Prerequisites

Before you begin, ensure you have the following:

* An [Aperture instance][kb-get-started] with at least one configured provider.
* [Admin access][kb-set-up-admin-access] to the Aperture dashboard.
* Access to the Tailscale admin console.

## Step 1: Allow network access to the Aperture device

Before users can access models, they need network connectivity to the Aperture device through your tailnet.

1. Sign in to the Tailscale admin console.
2. Go to the [Access controls](https://login.tailscale.com/admin/acls/file) page.
3. Confirm that your access control rules allow users to connect to the Aperture device.

The following example permits all users in `group:ai-users` to connect to the Aperture instance with the hostname `ai`:

```json
{
  "groups": {
    "group:ai-users": [
      "dave@example.com",
      "alice@example.com"
    ]
  },
  "hosts": {
    "ai": "<aperture-ip-address>"
  },
  "grants": [
    {
      "src": ["group:ai-users"],
      "dst": ["ai"],
      "ip": ["tcp:80", "tcp:443", "icmp:*"]
    }
  ]
}
```

Replace `<aperture-ip-address>` with the Tailscale IP address of your Aperture device.

> **Tip:**
>
> You can also use [Tailscale tags][kb-tags] to manage access to the Aperture instance. Assign a tag (for example, `tag:ai`) to the Aperture device and use it as the `dst` in your grant rule. For how the Aperture device is referenced in grants defined in the tailnet policy file, refer to [Grants versus tailnet policy file grants][kb-aperture-vs-tailnet-grants].

## Step 2: Configure grants to control model access

After users can reach the Aperture device, configure grants to define which models they can access. \[Missing snippet: aperture\_admin\_nav.mdx] Use the visual grant editor, or edit the same grants as JSON on the **Administration** > **Configuration** page. You can also update grants through the API (`PUT http://<aperture-hostname>/api/config`).

The following example grants all users standard user access and lets them use all Anthropic models:

```json
{
  "grants": [
    {
      "src": ["*"],
      "app": {
        "tailscale.com/cap/aperture": [
          { "role": "user" },
          { "models": "anthropic/**" }
        ]
      }
    }
  ]
}
```

To restrict access, replace `"*"` with individual login names (for example, `"alice@example.com"`), Tailscale or SCIM groups (for example, `"group:ai-users"`), or tags (for example, `"tag:ci"`). Use a tag to grant access to non-user devices such as CI runners or services. Group matching requires [visible groups][kb-visible-groups] enabled for the Aperture device.

\[Missing snippet: contact\_account\_manager.mdx]

The following example grants members of `group:ai-users` access to all Anthropic models:

```json
{
  "grants": [
    {
      "src": ["group:ai-users"],
      "app": {
        "tailscale.com/cap/aperture": [
          { "role": "user" },
          { "models": "anthropic/**" }
        ]
      }
    }
  ]
}
```

\[Missing snippet: aperture\_grant\_dst\_note.mdx]

Each capability entry under `tailscale.com/cap/aperture` has these fields:

* **`role`**: Required. Set to `"user"` for standard access or `"admin"` for administrative access. Without a `role` grant, users receive HTTP 403 responses even if they have model grants.
* **`models`**: A glob pattern that specifies which models the user can access, in `provider/model` format. For example, `"anthropic/**"` matches all Anthropic models, and `"**"` matches all models from all providers.
* **`connectors`**: An array of FQN globs that grant access to MCP tools, resources, and HTTP connector proxies. Refer to [grant MCP tool access][kb-grant-mcp-tool-access] for details.

### Model pattern examples

The following examples show how to use patterns to grant access to specific models:

| Pattern              | Matches                                             |
| :------------------- | :-------------------------------------------------- |
| `"**"`               | All models from all providers                       |
| `"anthropic/**"`     | All Anthropic models                                |
| `"openai/gpt-5.5"`   | Exactly `openai/gpt-5.5`                            |
| `"*/claude-sonnet*"` | Any `claude-sonnet*` model from any single provider |

## Verify access

After configuring grants, verify that users can access the expected models. Send a test request from a device connected to the tailnet. Use a model ID that matches a configured provider and your `models` grant. You can use the bare model name (for example, `claude-sonnet-4-6`) or the full `provider/model` form. You can do this with `curl` or any HTTP client. For example:

```shell
curl -s http://<aperture-hostname>/v1/messages \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-6",
    "max_tokens": 25,
    "messages": [{"role": "user", "content": "respond with: hello"}]
  }'
```

If the request returns a successful response, the grant is working. If you receive an HTTP 403 error, the user has no `role` grant: add a `{ "role": "user" }` entry. If you receive an HTTP 404 error, the user has a role but no `models` grant matching the requested model, or the model is not configured on any provider: check the `models` pattern and confirm the model ID matches a configured provider. Refer to [Troubleshooting Aperture][kb-troubleshooting] for help diagnosing access issues.

## Next steps

* [Grant access to connectors][kb-grant-mcp-tool-access] to control which MCP tools, resources, and HTTP APIs users can access.
* [Set per-user spending limits][kb-set-per-user-spending-limits] to manage costs.
* [Set up the chat UI][kb-set-up-chat-ui] to let users talk to models directly from their browser.
* [Set up LLM clients][kb-use-your-tools] to connect through Aperture.

[kb-aperture-vs-tailnet-grants]: /docs/aperture/reference/aperture-vs-tailnet-grants

[kb-get-started]: /docs/aperture/get-started

[kb-grant-mcp-tool-access]: /docs/aperture/how-to/grant-mcp-tool-access

[kb-how-aperture-works]: /docs/aperture/how-aperture-works

[kb-how-grants-work]: /docs/aperture/how-grants-work

[kb-set-per-user-spending-limits]: /docs/aperture/how-to/set-per-user-spending-limits

[kb-set-up-admin-access]: /docs/aperture/how-to/set-up-admin-access

[kb-set-up-chat-ui]: /docs/aperture/how-to/set-up-chat-ui

[kb-tags]: /docs/features/tags

[kb-troubleshooting]: /docs/aperture/troubleshooting

[kb-use-your-tools]: /docs/aperture/use-your-tools

[kb-visible-groups]: /docs/aperture/visible-groups