Skip to main content
Skool has no public API, so PostQueen connects it through the PostQueen browser extension. The extension reads the Skool session cookies from your own Chrome and hands them to your instance. It only answers pages on the domain it was built for, so on a self-hosted PostQueen you build it with your instance’s address, load it into Chrome, and tell PostQueen its ID. Skool is the only channel that uses the extension today.
On PostQueen Cloud there is nothing to build: install the PostQueen extension from the Chrome Web Store and connect Skool as its channel page shows. This page is for a self-hosted PostQueen.

​
Before you start

Using a browser extension to interact with a platform may violate its terms of service and could result in your account being suspended or banned. PostQueen shows the same notice before a Skool account connects.

​
How it works

  1. The Chrome build writes your domain and its subdomains into the extension twice: into the manifest’s externally_connectable list, which decides which pages can reach the extension at all, and into the extension’s own check of every message’s origin. It also grants the extension access to your backend address, which the daily refresh needs. A build for any domain other than localhost does not answer pages on localhost.
  2. When someone picks Skool in Add Channel, PostQueen shows a Browser Extension Notice. After I understand, continue, the page asks the extension with the ID in EXTENSION_ID for the client_id and auth_token cookies of skool.com, and PostQueen stores them encrypted.
  3. From then on the extension sends fresh cookies to your backend once a day, whenever Chrome is running, so the connection stays alive.

​
Build the extension

1

Get the source

Clone the app repository and install the workspace at its root. The extension has no dependencies of its own, so the root install is what it builds with:
2

Build it for your domain

Build at the repository root, passing your instance’s two addresses:
The build goes to apps/extension/dist, and the same files zipped to apps/extension/extension.zip. Its manifest.json lists https://postqueen.example.com/* and https://*.postqueen.example.com/* under externally_connectable, and https://postqueen.example.com/* under host_permissions. Nothing in the source needs editing.Both addresses have to be absolute URLs, the same values your instance runs with. Without them, or with a relative backend such as /api, the build stops with an error instead of packing an extension that cannot reach your instance.
3

Load it into Chrome

Open chrome://extensions, turn on Developer mode, choose Load unpacked and pick the apps/extension/dist folder.
4

Copy the extension ID

Chrome shows the ID under the extension’s name, a string of 32 letters. An unpacked extension’s ID comes from the folder it was loaded from: loading the same folder again keeps it, and loading a copy from another folder or another computer gives a new one.

​
Set the variables

Add the ID to your environment:
EXTENSION_ID is one value for the whole instance, so every browser that connects Skool needs the build with that ID:
To give unpacked copies on different computers the same ID without publishing, upload the zipped build to the Chrome Web Store developer dashboard without publishing it, copy the public key it shows, and add it as "key" to apps/extension/manifest.json before you build. See Chrome’s guide to the manifest key.
Recreate the app container so it reads the new values. A plain docker restart or docker compose restart keeps the old container and its old environment. In the folder that holds docker-compose.yaml, recreate only the postqueen service:
The database, Redis and Temporal keep running. Avoid docker compose down for a settings change: on a host that runs other Compose services in the same project, it stops them too. On Kubernetes, see Kubernetes with Helm. Then open Channels, choose Add Channel, then Skool, and continue past the notice. The account appears in the Channels list. For local development, pnpm run dev at the repository root also builds the extension, in watch mode, from the repository’s .env. That build uses the key in apps/extension/manifest.dev.json, which pins its ID to gclbjdbkakfndpofanknmccecjlmleah, and it is meant for PostQueen running on localhost.

​
Troubleshooting

The window says “The PostQueen browser extension is not installed. You need to install it before connecting this channel.” Either EXTENSION_ID is empty on the instance, or no enabled extension in this browser trusts the page: the build is not loaded, it is turned off, it was built for another domain, or PostQueen is open over plain http on an address other than localhost.
The page can reach an extension but not this one. EXTENSION_ID is not the ID Chrome shows for the loaded build, or the build’s origin check refused the page because it was built with another FRONTEND_URL or PostQueen runs on a port other than 443. Fix the ID or rebuild, then recreate the container.
The browser is not signed in to Skool. Sign in at skool.com in the same Chrome profile, then connect again.
The extension stopped answering mid-connect. Reload it on chrome://extensions, reload PostQueen and try again.
The daily cookie refresh only runs while Chrome is open with the extension, and the extension can only reach the backend address it was built with. Keep Chrome running, rebuild if NEXT_PUBLIC_BACKEND_URL changed, and reconnect the channel.
Last modified on October 16, 2026