For Plex server owners

Your server.
Their kids.
Everyone in control.

Give the families on your Plex server a place to manage their own kids' titles, screen time and bedtime. You approve every child. Parents handle the everyday rules.

Free, open source and self-hosted. Runs in Docker next to Plex, using its existing sharing and session controls.

Admin preview Example family

Admin

Approve requests and choose who can use KidsWatch for Plex.

Checks running
1Open requests
1Kids waiting
2Approved kids
1Watching now

Open requests

SarahAdd a childToday, 9:41 AM

Please approve Rowan's account.

R
RowanParent: Sarah
Awaiting approval
Every child needs your approval.

Kids

R
RowanParent: Sarah
Awaiting approval
M
Morgan47 min / 2 hr today
Active
J
Jamie30 min / 1 hr today
Active

Who can use this site

Everyone you share Plex with. Changes save right away.

PersonCan use the site
S
SarahLast signed in today
A
AlexNever signed in

Activity log

  • Sarah connected a Plex accountRowan · Today, 9:41 AM
  • You gave a parent site accessSarah · Today, 9:35 AM
  • KidsWatch for Plex updated library accessMorgan · Today, 9:30 AM

How it works

A little setup. A lot less admin.

Kids keep the normal Plex apps on their TV, tablet or phone. Nothing to install on their devices.

  1. 1

    Enable a parent

    Someone you already share with signs in with Plex, and you turn on their parent access.

  2. 2

    Approve their child

    The parent adds a child, connects their Plex account with a one-time link, and sends it to you for approval.

  3. 3

    Share just their titles

    KidsWatch labels allowed titles, limits the child's share to those labels, and turns off and verifies downloads, free online movies and Live TV from Plex.

  4. 4

    Keep the rules running

    Every 20 seconds, KidsWatch checks playback and stops it with a message when time is up, watch hours end or a parent pauses.

What can parents manage?

KidsWatch for Plex is a small website you host yourself. It uses the sharing and session controls that Plex already has, and it puts them in a place parents can use without touching your server settings.

  • Titles by age. Parents pick Little kids, Kids or Teens, based on official ratings, then allow or block single movies and shows. R, TV-MA and unrated titles never show up for kids.
  • Screen time and watch hours. Daily minutes and watch hours for school days and weekends, with presets for the school year and summer.
  • Pause and extra time. Parents can pause watching, add time for today, or push bedtime back. Extra time and later bedtimes reset the next day.
  • Activity. A 7-day chart, recorded stops, and a list of who changed what and when. Watch history is available if you also run Tautulli.
  • You stay in charge. Only people you already share with can ask for parent access. You enable parents, approve each child, and answer requests for titles or more access.

Before you install

What you need

  • Your own Plex Media Server with movie or TV libraries you are allowed to share.
  • Plex Pass on the server owner's account. KidsWatch relies on it to stop playing videos and to limit each child to their allowed titles.
  • Docker with Docker Compose v2, on a machine that can reach your Plex server.
  • A web address with HTTPS so parents can reach the site, for example through a reverse proxy like Caddy.
  • A private way to get sign-in codes on your phone. Your admin sign-in asks for a six-digit code. Home Assistant works well, or any private notification service that accepts a simple web request.
  • A free, regular Plex account for each child, made by their parent. A managed Plex Home profile on its own will not work.

Optional extras: Tautulli for watch history, and a request site such as Overseerr. Both are off by default.

Privacy and security

Your hardware. Your families' data.

  • No KidsWatch cloud

    No KidsWatch account or analytics. The app talks to your Plex server, plex.tv for sign-in and sharing, and only the optional services you set up.

  • Read-only Plex settings

    Reads your existing Plex settings through a read-only mount. No Plex token to paste into config; parent and child connection tokens are not saved.

  • One private database

    Child names, linked accounts, rules, usage, requests and change history stay on your machine. Keep the database and its backups private.

  • A second step for admins

    A six-digit code to your phone, strict security headers, protection against forged requests, and secure cookies by default.

It can change Plex shares. Treat it like an admin tool: use HTTPS, a machine you trust, and keep it up to date.

Choose your install path

One small app next to Plex

Both paths use Docker and your existing server. The repository is private while we get it ready; the GitHub source and README links will work once it is public.

Option 1

Use your AI assistant

Already use an agent to look after your Plex server or home lab? Give it this prompt. It asks where to host KidsWatch, how parents will reach it, then shows a plan and waits for your OK.

Your agent never needs your Plex token. The prompt tells it to keep secrets out of chat and keep an undo note.

Read the install prompt
Help me install KidsWatch for Plex, a self-hosted parental controls app for my Plex server. Ask before you change anything.

Before you start
1. Confirm you can run Docker and Docker Compose v2 on the host. If Docker needs sudo, use it for every Docker command. Never change Docker socket permissions.
2. Ask me:
   - Which machine, VM or container on my network should host it, where Plex runs, and where its Preferences.xml file is.
   - Whether the Plex server owner account has Plex Pass (required).
   - Which reverse proxy I use (Caddy, Traefik, Nginx Proxy Manager, Cloudflare Tunnel, other) or none.
   - The address parents will use, for example https://kids.example.com. The app needs HTTPS, even at home.
   - How admin sign-in codes should reach my phone: a Home Assistant webhook or another private notification receiver. The README requires one.
   - Whether to turn on the optional Tautulli watch history.
   - My time zone.

Install
3. Fetch the official repository https://github.com/pughouselabs/kidswatch-for-plex and follow its README exactly. If my setup does not fit, tell me instead of improvising.
4. Show me a plan (files, commands, anything outside the app folder) and wait for my OK.
5. Create .env from .env.example and docker-compose.yml from docker-compose.example.yml with my answers. Find my movie and TV library keys with the README's read-only command.
6. Start it with docker compose up -d --build and run the README's /healthz and /readyz checks. If /readyz fails, explain why using the README.
7. Set up HTTPS through my reverse proxy as the README describes. Keep port 8080 private.

Safety rules
- Never put my Plex token, Preferences.xml contents, the notification URL or any other secret in chat, logs, shell history or the repo. Read secrets from my existing password manager, or let me enter them on the machine.
- Never expose the app to the internet without HTTPS. Keep PK_SECURE_COOKIES=1 and PK_OWNER_CODE=1.
- Do not change existing Plex settings beyond what the README requires.
- Back up files outside the app folder before editing them. Keep an undo note: what changed, where the backups are, and how to remove the app with the README's cleanup command.

When you finish, report
- The URL, the readiness result and the undo note.
- What I still have to do: sign in as the Plex server owner, enable parents on the Admin page, approve a test child, and test that a real video stops.

Works with any agent that can run commands on your server. Read the prompt first, and keep an eye on what the agent does.

Option 2

Do it yourself

Comfortable with Docker? Download the source, point it at Plex, add private sign-in code delivery, and put it behind HTTPS.

The README (coming soon) covers file permissions, troubleshooting and the full settings list.

Open the 9-step install guide
  1. Check what you need

    Make sure you have everything in What you need, then check that Docker works on the machine that will run KidsWatch:

    docker version
    docker compose version

    If either says permission denied, put sudo in front of every Docker command on this page. Do not change the Docker socket's permissions to get around it.

  2. Download it

    Get the source, copy the example files, and create the folders the app uses:

    git clone https://github.com/pughouselabs/kidswatch-for-plex.git
    cd kidswatch-for-plex
    cp docker-compose.example.yml docker-compose.yml
    cp .env.example .env
    sudo install -d -o 1000 -g 1000 -m 0700 data secrets
  3. Point it at your Plex settings file

    In docker-compose.yml, replace /path/to/plex/Preferences.xml with your server's existing file. On Linux it is usually under /var/lib/plexmediaserver/Library/Application Support/Plex Media Server/. For Plex in Docker, look in the folder mapped to Plex's /config.

    The app runs as user 1000 and mounts the file read-only. Give user 1000 read access, but do not make the file readable by everyone, and never copy what is in it into .env.

  4. Fill in your settings

    Edit .env. These are the settings most people change:

    Settings reference
    SettingWhat to put
    PK_PUBLIC_URLThe HTTPS address parents will open, for example https://kids.example.com.
    PK_PLEX_URLYour Plex server address as the container sees it, for example http://plex.example.com:32400. Inside the container, localhost means the container itself.
    PK_TZYour time zone, for example America/Denver. Set it before adding children.
    PK_KID_SECTIONSThe movie and TV library keys kids may use, for example 4,7. Step 6 shows how to find them.
    PK_HA_WEBHOOK_FILE/run/secrets/notification_url once step 5 is done.
    PK_OWNER_NAMEYour name as parents will see it in help and messages.
    PK_SEED_PARENTSOptional. Plex usernames to turn on as parents at first sign-in, if they already share your server.
    PK_TAUTULLI_URL and PK_TAUTULLI_CONFIGOptional watch history. Set both and uncomment the Tautulli mount in docker-compose.yml.
    PK_SECURE_COOKIES and PK_OWNER_CODELeave both at 1.
  5. Set up your sign-in codes

    Your admin sign-in needs a six-digit code sent to your phone, and sign-in stays blocked until delivery works. Make a private webhook, for example a Home Assistant automation that sends a phone notification, and save its full URL in your password manager. Then put that URL in secrets/notification_url, owned by user 1000 with mode 600, without typing it into a command. The README (coming soon) has the Home Assistant recipe and a test command.

  6. Start it and pick the kids' libraries

    docker compose config --quiet
    docker compose up -d --build
    docker compose ps

    Run the README's library listing command (coming soon). It prints each library's key, name and type without showing your token. Put the movie and TV keys in PK_KID_SECTIONS, then apply the change:

    docker compose up -d --force-recreate kidswatch

    After any .env change, use this command. A plain docker compose restart keeps the old settings.

  7. Check that it is ready

    curl --fail http://127.0.0.1:8080/healthz
    curl --fail http://127.0.0.1:8080/readyz

    The second check passes only when Plex, your libraries and the time keeper are all working. Give a fresh install a few seconds. If it keeps failing, read the logs with docker compose logs --tail=50 kidswatch.

  8. Put it behind HTTPS

    The app only listens on the Docker host itself, on port 8080. Keep it that way and let a reverse proxy serve your address. With Caddy installed on the same host, back up /etc/caddy/Caddyfile and add:

    kids.example.com {
        reverse_proxy 127.0.0.1:8080 {
            header_up X-Forwarded-For {remote_host}
            header_up X-Forwarded-Proto {scheme}
            header_up -CF-Connecting-IP
            header_up -CF-IPCountry
        }
    }

    Then run sudo caddy validate --config /etc/caddy/Caddyfile and sudo systemctl reload caddy. Caddy gets the certificate for you. Other proxies work too, as long as they replace the visitor address headers instead of passing them through. A proxy running in Docker should join a private network with the app and use kidswatch:8080.

  9. Sign in for the first time

    Open your HTTPS address and sign in with the Plex server owner's account, then enter the code sent to your phone. On the Admin page, turn on a parent. Connect and approve a test child, check what that child sees in Plex, and test that a real video stops before you rely on the limits.

Keep it running

The details, when you need them

Updating and removing

Updating

Stop the app, back up its data and settings, keep the current image, then build the new version:

docker compose stop
sudo cp -a data "data-backup-$(date +%F)"
cp .env .env.backup && cp docker-compose.yml docker-compose.yml.backup
docker tag kidswatch:local kidswatch:previous
git log -1 --oneline
git pull
docker compose up -d --build

Write down the version that git log printed, and keep the backups as private as the live data. Then repeat the readiness checks, look at a child's titles, and test a real video stop. To roll back, stop the app, go back to the old version and image, and restore the matching data backup. An older version may not read data from a newer one, which is why the backup matters.

Removing

Stopping the container does not remove the shares and labels KidsWatch made on your Plex server. Take a private backup first, then list what will be removed and remove it:

docker compose exec kidswatch python -m app.cleanup
docker compose exec kidswatch python -m app.cleanup --apply
docker compose down

The first command only shows the list. The second removes each tracked child's share and labels. After that you can delete the app folder when you no longer need it.

Limitations to know before you start

KidsWatch does a few things well. It is honest to say what it does not do.

  • It is not a device lock. It stops videos on the next check, normally within 20 seconds. A child can press play again, and the next check stops that too. Music is not counted.
  • Rules follow the child's own account. If a child watches on a parent's account, the rules do not apply. Put a PIN on parent profiles.
  • It only covers your server. It does not filter anything played from other servers or other apps.
  • New titles take a little while. Allowed titles sync about every five minutes, and new titles can take up to 15 minutes or so to show up for kids.
  • Ratings come from your library. A title with a wrong rating still needs a parent to look at it.
  • Plex can change. It depends on the sharing and session features in Plex, which Plex can change at any time. Check your shares in Plex now and then.
  • One copy per database. Run a single container. It is not built to scale out.
Common questions
Does it cost anything?

No. KidsWatch for Plex is free and open source under the MIT license. You do need Plex Pass on the server owner's account.

Do the parents or kids need Plex Pass?

No. Children do not need their own Plex Pass for KidsWatch's controls. The remote-playback rules from Plex may still apply to some devices or accounts.

Can I use Plex Home managed profiles for the kids?

Not on their own. Each child needs a free, regular Plex account with an email address the parent controls. A parent can still invite that account into their own Plex Home so it shows up as a profile on the family TV.

Does it send any data to you?

No. There is no telemetry and no outside service run by us. Everything is stored on your machine.

Can kids get around it?

Downloads are off and the free online movies and Live TV from Plex are switched off, so most easy ways around it are closed. The main gap is a parent's account: if a child watches on it, they see what the parent sees. Parents should keep their child's Plex password to themselves.

What happens if KidsWatch is down?

Kids can still watch the titles they are allowed, but time is not counted and videos are not stopped until it is back. Usage from that time can be incomplete.

How do I remove it?

Use the cleanup command in Removing. It lists, and then removes, every share and label KidsWatch made on your server. Stopping the container alone leaves those shares in place.

Sending this to a parent?

The parent guide explains what they get, what their kids will see, and what they need to do.