# Get started with Aperture

Last validated Jun 27, 2026

[Start using Aperture](https://aperture.tailscale.com/)

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

> **Note:**
>
> During the beta testing period, Aperture by Tailscale is available at no additional cost with any Tailscale account, including free accounts created during Aperture signup. Request access at [`aperture.tailscale.com`][xt-aperture-signup].

This guide walks you through signing up for Aperture, configuring your first LLM provider, and sending a test request to confirm everything works. To learn more about what Aperture does before you start, refer to [What is Aperture?][kb-what-is-aperture].

## Prerequisites

Before you begin, confirm you have the following:

* **An API key from an LLM provider's developer platform.** Aperture supports OpenAI, Anthropic, Google Gemini, OpenRouter, Amazon Bedrock, Vertex AI, and OpenAI-compatible APIs. Refer to the [provider compatibility reference][kb-provider-compatibility] for the full list of supported providers and API formats. Get an API key from the provider's developer portal (for example, the [Anthropic Console][xt-anthropic-console], [OpenAI Platform][xt-openai-platform], or [Google AI Studio][xt-google-ai-studio]).

  > **Note:**
  >
  > An API key from the provider's developer platform is the standard path for getting started, but it isn't the only option. Consumer and business subscription plans such as Claude Pro, ChatGPT Plus, or Gemini Advanced provide OAuth tokens rather than these API keys. To use a subscription plan, configure the provider in [passthrough mode][kb-use-passthrough-mode] instead, so the client forwards its own subscription credential through Aperture. Aperture does not hold or manage the subscription itself.

* **A device connected to your tailnet.** Aperture listens on your [tailnet][kb-tailnet] at `http://<aperture-hostname>`. Your device must be running Tailscale and connected to the same tailnet as your Aperture instance. If you need to connect a device that is not in the tailnet, refer to [connect devices outside your tailnet][kb-connect-outside-tailnet].

## Step 1: Sign up for Aperture

1. Visit [`aperture.tailscale.com`][xt-aperture-signup] and complete the sign-up form. If you don't have a Tailscale account, the sign-up process creates a free one for you.
2. Confirm that your device can reach the Aperture dashboard at `http://<aperture-hostname>/ui/`.

## Step 2: Configure an LLM provider

Adding a provider is an admin task. You can use either the visual **Providers** page or the JSON **Configuration** editor.

**Visual editor**: \[Missing snippet: aperture\_admin\_nav.mdx] Fill in the provider name, base URL, API key, and model list through the form interface.

**JSON editor**: \[Missing snippet: aperture\_admin\_nav.mdx] Paste or write the configuration directly. The following example configures Anthropic with two Claude models:

```json
{
  "providers": {
    "anthropic": {
      "baseurl": "https://api.anthropic.com",
      "apikey": "<anthropic-api-key>",
      "models": [
        "claude-sonnet-4-6",
        "claude-opus-4-8"
      ],
      "authorization": "x-api-key",
      "compatibility": {
        "anthropic_messages": true
      }
    }
  }
}
```

For provider-specific instructions, refer to [Set up LLM providers][kb-set-up-providers]. For all available settings, refer to the [configuration reference][kb-aperture-configuration].

> **Note:**
>
> If you skip this step, Aperture uses a [default configuration][kb-aperture-default-configuration] that includes OpenAI and Anthropic with common models. You still need to add your own API keys before requests can succeed.

## Step 3: Send a test request

Send a request from a device in your tailnet to confirm Aperture is routing to your provider. You can test with any of the supported API formats. Replace the model name with a model you configured in step 2.

**Anthropic API format**:

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

**OpenAI Chat API format**:

```shell
curl -s http://<aperture-hostname>/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.5",
    "messages": [{"role": "user", "content": "respond with: hello"}]
  }'
```

**OpenAI Responses API format**:

```shell
curl -s http://<aperture-hostname>/v1/responses \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.5",
    "input": [{"role": "user", "content": "respond with: hello"}]
  }'
```

If the request succeeds, Aperture is routing to your provider. Open the [Aperture dashboard][kb-web-dashboard] at `http://<aperture-hostname>/ui/` to check the request in your usage history.

> **Note:**
>
> If your device is not in the tailnet, [connect through `ts-unplug`][kb-connect-outside-tailnet] and replace `http://<aperture-hostname>` with `http://localhost:<port-number>` in the examples above.

## Next steps

After you confirm your provider is working, explore the following features to get the most out of Aperture:

* [Grant users access to models][kb-grant-model-access] so team members can send requests through Aperture.
* [Set up LLM clients][kb-use-your-tools] to route traffic from tools such as Claude Code or Codex through Aperture.
* [Set up the chat UI][kb-set-up-chat-ui] to let users talk to models directly from their browser.
* [Set spending limits][kb-manage-spending] to control costs across your organization.
* [Connect devices outside your tailnet][kb-connect-outside-tailnet] if team members need access from devices that aren't in the tailnet.
* [Proxy MCP servers and HTTP APIs][kb-aperture-connectors] to give AI agents authenticated access to external tools through Aperture.

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

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

[kb-aperture-default-configuration]: /docs/aperture/configuration#default-configuration

[kb-connect-outside-tailnet]: /docs/aperture/connect-outside-tailnet

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

[kb-manage-spending]: /docs/aperture/manage-spending

[kb-provider-compatibility]: /docs/aperture/provider-compatibility

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

[kb-set-up-providers]: /docs/aperture/set-up-providers

[kb-tailnet]: /docs/concepts/tailnet

[kb-use-passthrough-mode]: /docs/aperture/how-to/use-passthrough-mode

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

[kb-web-dashboard]: /docs/aperture/reference/dashboard

[kb-what-is-aperture]: /docs/aperture/what-is-aperture

[xt-anthropic-console]: https://console.anthropic.com

[xt-aperture-signup]: https://aperture.tailscale.com

[xt-google-ai-studio]: https://aistudio.google.com

[xt-openai-platform]: https://platform.openai.com