---
title: "A private deploy"
url: /trust/private
---

# A private deploy

> The site, the portal and the docs behind an enterprise sign-in, an IP allowlist or both, with the API on its Keys and the prices public while the product sells.

A private deploy opens the product's pages only to people who sign in through one enterprise connection, from allowed networks, or both.

**A visitor at a private deploy.** A request for a page.

1. Network: in `ips`. Or 403: off the list.
2. Sign-in (allowed): the connection. Or 401: with a link.
3. Group (signed in): in `groups`. Or 403: not a member.
4. The page (a member): kept in the log.

Every check runs at the edge, before any page is built.

## What an outsider meets
An agent that fetches the docs as Markdown, with no member's [Key](/reference/platform.md#key), gets the way in, never the page.

```http title="Response"
HTTP/1.1 401 Unauthorized
Content-Type: application/problem+json
X-Cost: price=0, currency="USD"
X-Request-Id: req_c50e8a1f7d24b39e6a08

{
  "type": "https://summaries.apis.dev/docs/errors#sign_in_required",
  "title": "Unauthorized",
  "status": 401,
  "detail": "The docs open to Acme's analysts, signed in from its network.",
  "code": "sign_in_required",
  "instance": "req_c50e8a1f7d24b39e6a08",
  "signIn": "https://summaries.apis.dev/login?connection=acme"
}
```

A person meets the sign-in page of the connection instead, under the product's brand.

## Who gets in
`pages: 'sso'` lets in people who sign in through the connection `sso` names, and `groups` narrows them to the groups it sends.

`pages: 'ips'` lets in any request from a network in `ips`. `pages: 'both'` asks for both, so a laptop off the office network meets the sign-in and the network check alike.

Each view is kept: who opened which page, from which network and when, read with `Viewer.list` on the [Operator plane](/trust/planes.md).

## What closes, and what stays open
`private` closes the pages people read. The API and the files agents read answer to [Keys](/reference/platform.md#key), as on every product.

| Part | On a private deploy |
| --- | --- |
| The landing site, the portal and the docs | Behind the gate; no search engine indexes them, and the sitemap is withheld |
| `llms.txt` and the docs MCP | Behind the gate for a person; an agent reads them with a member's Key |
| The API, MCP, SDK and CLI | Unchanged: each call presents a Key |
| `/pricing`, `/pricing.json` and the offer card | Public while the Offer sells to anyone, so a buyer and its agent read the price before they sign in |
| Directory entries | Withdrawn, unless the product sells and you keep them |
| The status page | Behind the gate, with the same history |

A product that sells to nobody outside, such as one built for your own team, keeps its prices behind the gate too.

## A Customer that needs its own cloud
A private deploy closes pages and leaves the product where it runs.

For a Customer whose security review asks for its own infrastructure, a plan with `isolation: 'own'` runs its [Namespace](/reference/platform.md#namespace) on its own runtime and store.

It stays in the region the workspace pins, with no change to any [Interface](/every-product.md), as [Limits, placement and recovery](/runtime/envelope.md) describes.

## Docs for one buyer
An answer engine for one buyer keeps its docs for that buyer's analysts, on its network, and sells by the call as before.

```ts title="definition.ts"
import { define, code, generative, agentic, human } from 'apis.dev'

/** Answers about any company by its domain, for Acme's analysts, from its network. */
export default define({
  name: 'summaries', domain: 'summaries.apis.dev',
  Company: {
    domain:    'url!#',
    score:     code((c) => ({ score: c.domain.endsWith('.ai') ? 80 : 50 })),
    summarize: generative('Two sentences on what {domain} sells',
      { returns: { summary: 'string' } }),
    research:  agentic('Find the head of sales at {domain}',
      { returns: { headOfSales: 'string' } }),
    verify:    human('Call and confirm the head of sales',
      { returns: { confirmed: 'boolean' }, role: 'researcher' }),
  },
  offer: {
    'Company.score': 0.001, 'Company.summarize': 0.02,
    'Company.research': 0.5, 'Company.verify': 5,
  },
  private: {
    pages:  'both',
    sso:    'acme',                       // Acme's enterprise sign-in connection
    ips:    ['203.0.113.0/24'],
    groups: ['analysts'],
  },
})
```

A private deploy is a Scale feature. A file with `private` on a lower plan is refused at publish with [`plan_required`](/reference/platform.md#plan_required).

Turning `private` off is one deploy; the pages open and the search engines may index them again.