# People and profiles

With sign-in on, everyone who signs in is an owner: the same page, the same buttons, the same assistant. A profile gives someone less. Children might see only the Media tab, press the one button you allow, and ask the assistant for things a parent then approves.

```yaml title="config.yaml"
profiles:
  kids:
    tabs: [Media]                      # the tabs they see, by name as in layout. Left out: all of them
    actions: [downloads.pause]         # page buttons they may press, as <integration>.<action>. Left out: none
    assistant:                         # left out: no assistant for them
      access: { default: none, requests: write }
      instructions: "Only suggest shows rated TV-Y7 or below."
      suggestions: ["What can I watch tonight?"]
      approve: owner                   # owner: what asks first goes to an owner · self: they approve their own
users: { sam: kids, alex: kids }       # account → profile. Anyone not listed is an owner
```

## Set it up

1. Turn on [sign-in](/start/sign-in/). Without it there are no people, only a page, so profiles do nothing. `config check` says so.
2. Make an account for each person. With local accounts, `node dist/server.js user add sam`. With a [sign-in proxy](/start/sign-in/#behind-a-sign-in-proxy) or [OpenID Connect](/start/sign-in/#openid-connect), the name is what your proxy's header or the `claim` says.
3. Add `profiles` and `users` as above. Names in `users` don't care about case, so `Sam` from a proxy is still `sam`.
4. Run `node dist/server.js config check`, then `node dist/server.js user list` to see who is an owner and who has which profile.

Profiles and `users` reload live, like the rest of the config. Only you can change them, by hand: the assistant's setup tools can't touch either, as they can't touch `auth`.

## What someone with a profile gets

**The page.** Their tabs, and only the cards on them. Rings in the top bar, live activities, the weather beside the clock and the calendar only show if their card is on one of their tabs. The status sentence is written from their cards alone.

**Buttons.** Only the `actions` the profile lists, pressed straight away: listing one is your yes. A card from an integration they were given nothing on is read-only for them. In ⌘K, the Do list is the same buttons.

**The assistant.** Theirs, if the profile has one:

- **It never has more than yours.** For each integration and each tool, it gets the lower of `assistant.access` and the profile's `access`. A profile can only narrow.
- **`default` covers their tabs.** An integration with no card on their tabs gets nothing unless the profile names it.
- **`show` draws only their cards**, and one search across everything covers only what they may read.
- **`instructions` is guidance.** It's added to the assistant's instructions for them, and a model can ignore it. What holds is `access`, in code.
- **Valet's own tools aren't theirs:** no setup tools, rules, reminders, activity log, timeline, plans or pins, no MCP servers, no other models from `assistant.models`, and none of your chat commands. They keep `show`, drawing a chart, one search across what they may read, and Valet's own docs.

**⌘K.** Their buttons, commands for tools their assistant may use, search inside the services their assistant may read (nothing, without an assistant), their tabs, and Valet's docs. The Account group shows who's signed in.

## What stays with owners

Whatever a profile says, these are for owners only:

- the cards, tabs and wallpapers of the tabs they don't have, and any picture that isn't on their cards or from an integration their assistant may read
- the activity log, rules, reminders, pins and the year in review
- the assistant's brief, its suggested questions written from the whole page, and the line about what several problems have in common
- notifications: a profile can't turn them on for a device, and a device turned on before its account got a profile hears nothing
- notices about Valet's own things (a reminder, a rule, backups); they hear a notice only when it's about one of their cards
- approvals from outside the chat (an MCP client's, or another person's): they can't see them or answer them
- a config edit that didn't apply, and the welcome card

Every one of these is held on the server, not just hidden on the page. `npm run test:exposure` signs in with a profile and tries every route.

## Approvals that go to an owner

With `approve: owner`, the default, anything their assistant would ask before doing is asked of an owner instead:

1. Sam asks for a show. The assistant calls the request tool, which would ask first.
2. Nothing runs. Every owner's page shows the approval card, in the tool's own words, with "Asked by sam", and owners get a notification.
3. Sam's chat says it's waiting for an owner.
4. An owner presses Allow. If Sam's chat is still open it carries on and says it's done. If Sam had to wait longer, the yes is kept for ten minutes for that exact request: asking again runs it.
5. It runs once. The activity log says "sam, approved by pat".

A no is a no: Sam's chat says an owner declined. A yes covers that one request with that exact input, from that person, once. Five approvals can wait at a time.

With `approve: self`, they get the same approval card you do, for what their access allows and nothing more. Use it for an older child or a housemate you'd trust with their own buttons.

## Telegram

An id in [`assistant.telegram.users`](/assistant/telegram/) can be bound to an account, so a child's Telegram is the child's assistant:

```yaml
assistant:
  telegram:
    token: ${TELEGRAM_BOT_TOKEN}
    users: [123456789, { id: 987654321, as: sam }]
```

A plain id is an owner, as before. A bound one talks as that account, profile and all: with `approve: owner`, they get no buttons, and what needs a yes goes to an owner's page.

## Their own Plex, Jellyfin and requests

A profile picks which cards someone sees, not whose data is behind them. The services use your keys, so out of the box everyone sees the same Now playing, the same Continue watching and the same requests: the whole house's.

Some services know whose activity is whose, and your key can read each person's. Tell Valet who is who there with `people`, on that service's block:

```yaml title="config.yaml"
integrations:
  plex:
    type: tautulli
    url: http://tautulli:8181
    apiKey: ${TAUTULLI_KEY}
    people: { sam: samantha, alex: alex.k, pat: pat }   # the name they sign in to Valet with → their name on this service
  requests:
    type: seerr
    url: http://seerr:5055
    apiKey: ${SEERR_KEY}
    people: { sam: samantha, alex: alex }
```

Then each of them sees their own on that service's cards, in the assistant, in ⌘K's search and in the live activities in the top bar. Nothing else changes: the same cards, the same tabs, and your one key.

| Service | What becomes their own | What stays everyone's |
|---|---|---|
| [Tautulli](/integrations/tautulli/) | Now playing, Most watched, Who's watching (their row), Plays, The year so far, Viewing, the history and stats tools, and stopping a stream (only their own) | Your library, Recently added |
| [Jellyfin](/integrations/jellyfin/) and [Emby](/integrations/emby/) | Now playing, Continue watching, Recently added (what their libraries hold), the status card, search, and stopping a stream (only their own) | Your library |
| [Seerr](/integrations/seerr/) | Requests, the requests tool, and a request the assistant makes for them is theirs in Seerr, with their limits and approvals | Search |
| [Audiobookshelf](/integrations/audiobookshelf/) | Continue listening, Listening now, Listening this week, the status card and the assistant's listening tools. Needs an administrator's API token | New on the shelf, search |

The name on the right is the service's own: a Plex user name, display name or email for Tautulli; a user name for Jellyfin, Emby and Audiobookshelf; a user name, Plex or Jellyfin name, email or display name for Seerr. Names compare without case on both sides, and two people can share one.

**A name the service doesn't know is an error on their cards**, never everyone's. `node dist/server.js doctor` asks each service about each name and says which don't match. With local accounts, `config check` also names anyone in `people` who has no account.

**Anyone not in `people` sees what they did before**: everyone's. Give a profile's people a name there, or leave the card off their tabs.

**Owners are people too.** An owner in `people` sees their own. To see the whole house's again, choose **Everyone's activity** in ⌘K. It's remembered in that browser, and only an owner's counts.

### Where it reaches

- **The page**: their own cards, fetched as them and kept apart from the shared ones. Two people mapped to the same user share one copy. Each is fetched only while someone it's for has the page open, as often as the shared card would be.
- **The assistant, ⌘K and Telegram**: the same service's tools answer for whoever asks, so "what am I watching" is theirs. A Telegram id [bound to an account](#telegram) is that person; a plain one is an owner.
- **Notices**: someone with their own card doesn't get the shared card's toasts (somebody else's stream starting).
- **The wall** shows the shared cards: a screen on the wall is nobody in particular.
- **A card made from one of these** (`from:` on an `api` card) is made once, from everyone's. Whoever has their own there doesn't get it, its tools included; `config check` says so.
- **The [network map](/integrations/network/)** shows whether the service answers, from the shared card, and never what anyone is watching.
- **Rules, reminders, the timeline, the activity log, the year in review and notifications** watch the shared cards, as before. They're owners' things, about the whole house.

What this doesn't do is sign in to anything as them. Plex's On Deck, for one, is only Plex's to give with that person's own token, so Valet's Plex card stays the server's numbers: use Tautulli for whose is whose. Navidrome, Immich, Kavita and Komga answer only for the account whose key or password Valet has, so `people` isn't offered there.

## Nobody left as an owner

If `users` gives every local account a profile, nobody is an owner: nobody can approve, read the log or use the full page. Valet won't pick someone to promote. It says so in its log and in `config check` and `user list`, and the accounts stay as narrow as you made them. To get back in, take one name out of `users` (it reloads live), or add an account of your own with `user add`.

A name in `users` whose profile doesn't exist sees nothing at all until you fix it, rather than everything. `config check` names unknown profiles, tabs, actions and integrations, and any level a profile asks for that's more than `assistant.access` gives.

## What it doesn't cover

- **Each chat's history is kept in its own browser.** Two people sharing one browser share its chats.
- **An integration you name in a profile's access is theirs to read through the assistant**, cards or not. Give a profile only what you'd show them.
- **Whose data it is, outside `people`.** A service with no `people`, and anyone not in it, sees the house's: your keys' view. See [their own Plex, Jellyfin and requests](#their-own-plex-jellyfin-and-requests).
- **It never signs in as them.** Everything is read with your keys, so what a service only shows its own user (Plex's On Deck, a music server's plays) stays yours.
- **It isn't a lock on the services themselves.** Someone with the service's own address and a login can still use it. Valet only narrows what reaches them through Valet.