Pageguard
GitHub Get started

Open source · MIT licensed

Prove every tag, cookie, and beacon on your site.

Pageguard is web governance for the client side. It crawls your sites, runs their tags in a real browser, and validates what it finds against policies you control — so martech, privacy, and engineering share one source of truth.

Start self-hosting Star on GitHub
  • Go core, stdlib only
  • Playwright rendering
  • PostgreSQL + Helm
  • 100% self-hosted
Playwright render
MIT licensed

Audits the martech you already ship

  • Google Tag Manager
  • GA4
  • Adobe Analytics
  • Meta Pixel
  • Segment
  • OneTrust
  • Cookiebot
  • Usercentrics

The gap

Your tag layer ships blind.

Tags change in a CMS, a container, a consent banner, or one line of JavaScript. By the time reporting breaks, the evidence is already gone.

Tag drift goes unnoticed

A container is removed, a pixel is duplicated, an event stops firing. Pageguard records what actually loads, page by page, so silent regressions surface before revenue reporting does.

Consent promises don’t match reality

Trackers fire before the banner. Cookies appear that your policy forbids. Simulate accept, reject, necessary-only, and GPC states — then see the exact requests that leaked.

Audits live in screenshots and spreadsheets

A finding without an observation is an opinion. Every Pageguard finding carries the request, cookie, tag, or data-layer event that produced it — exportable and reviewable.

How it works

From crawl to court-ready evidence.

Four stages, one engine. Run it in CI, on a schedule, or from the dashboard whenever the tag layer changes.

01

Crawl

A breadth-first crawler respects robots.txt, applies scope rules, and fans out across a worker pool. Every scanned page is checkpointed, so runs resume instead of re-fetching.

robots.txt · sitemaps · checkpoints
02

Render

Fetch over plain HTTP, or execute the page in a real Playwright browser. Auto mode upgrades SPA-like pages only where JavaScript is required.

HTTP · Chromium · auto
03

Validate

Declarative tag policies, multi-step journeys, privacy rules, and out-of-process Node validators. Policies live in YAML or JSON and evaluate against captured evidence.

YAML · JSON · TypeScript
04

Prove

Pass/fail reports per rule and per page. Screenshots on journey failure, hashed cookie values, live progress over SSE or WebSocket, and JSON, CSV, or print-ready HTML exports.

JSON · CSV · HTML

Capabilities

One audit engine for the whole tag lifecycle.

Scanning, tag governance, journey testing, and privacy compliance share the same evidence model — no stitching together four tools and hoping the numbers agree.

Page scanning

BFS crawling with robots.txt handling, sitemap discovery, SPA detection, and a starter tag detector. HTTP and headless-browser fetchers behind one interface.

Tag policies

Assert tags, requests, data-layer events, and cookie inventories must exist or must not exist. Add value rules, attribute checks, and consent requirements.

Journey testing

Script navigate, click, fill, and wait steps in one browser session. Validate URL, title, tags, events, and cookies after every step, with a failure screenshot.

Privacy compliance

Score GDPR, CCPA, LGPD, and ePrivacy against consent-state simulations. Flag pre-consent leaks, missing rights flows, DPIA triggers, and cross-border hosts.

Plugin SDK

Write validators in TypeScript against a stable JSON protocol. Plugins run out of process, so a bad validator is isolated and never aborts a scan.

Streaming API

REST endpoints plus SSE and WebSocket progress streams. PostgreSQL persistence, in-memory mode for tests, Docker Compose, and a Helm chart for clusters.

Also in the box HAR capture Data-layer capture Regional egress proxies Run resume Helm chart Alerting · roadmap

Evidence over assertions

Findings you can hand to legal, martech, or engineering.

Pageguard doesn’t just say a page failed. It keeps the observation that produced the finding — the tag, request, cookie, or event — and makes the whole run reproducible.

  • Every finding is traceable to the exact observation that produced it.
  • Cookie values are hashed at the edge and never persisted in plaintext.
  • Runs are resumable from page checkpoints, with no duplicate pages or findings.
  • Reports export as JSON, CSV, or print-ready HTML — no proprietary format.
Read the architecture 
# one policy across tags, cookies, and events
version: 1
name: "Acme tag policy"

must_exist:
  - id: gtm
    target: tag
    match:
      tag: google-tag-manager

  - id: purchase-event
    target: event
    match:
      event: purchase

value_rules:
  - id: currency-code
    variable: cart.currency
    pattern: "^[A-Z]{3}$"

consent_requirements:
  gated_categories: [advertising, social]

Illustrative shape of Pageguard policies and reports.

Self-hosted by default

Run it on your own infrastructure.

One Go binary, Playwright for rendering, and optional PostgreSQL. No SaaS account, no per-page pricing, and no audit data leaving your network unless you send it.

  • Go 1.25+ for the API and orchestrator
  • Node + Playwright for browser rendering
  • PostgreSQL optional — in-memory works for evaluation
  • Docker Compose or Helm for production
MIT license No vendor lock-in Audit the source
Quick start 
$ git clone https://github.com/bhkbdbhatt/openobserve.git
$ cd openobserve
$ go run ./cmd/pageguard --addr :8080 --plugins ./plugins

→  API ready http://localhost:8080
Docker Compose 
$ docker compose -f deploy/docker-compose.yml up --build

API       http://localhost:8080
dashboard http://localhost:3000
postgres  localhost:5432
4 privacy regulations evaluated out of the box
3 render modes: HTTP, browser, and auto
100% self-hosted, with no per-page pricing
MIT licensed — inspect it, fork it, ship it

FAQ

Questions worth asking.

Straight answers about licensing, privacy, and what Pageguard does — and doesn’t — replace.

Is Pageguard really open source?

Yes. Pageguard is MIT licensed and built to be self-hosted. You can inspect the scanning engine, extend it with the TypeScript plugin SDK, and run it entirely inside your own network. It was formerly scoped as “OpenObserve” and renamed to avoid confusion with the observability project.

Does it replace my consent management platform?

No. Pageguard audits what your CMP and tags actually do. It simulates consent states such as accept-all, reject-all, necessary-only, and GPC, then reports trackers and cookies that fire outside the policy you defined. It does not collect consent or replace the banner.

Do you store raw cookie values?

No. Raw cookie values are hashed at the edge and never persisted. Reports keep cookie metadata, domains, attributes, categories, and hashes — enough to prove behavior without retaining sensitive values.

Can it audit single-page apps?

Yes. Browser render mode executes client-side JavaScript in Playwright and captures the resulting tags, requests, cookies, console output, and data layer. Auto mode only upgrades SPA-like pages, so simple pages stay fast.

How do journeys differ from a scan?

A scan audits pages at rest. A journey runs a scripted flow — navigate, click, fill, wait — in a single browser session and validates expectations after each step. That catches checkout, signup, and other multi-step paths where tags fire in sequence.

What does it cost?

The software is free under the MIT license. You pay only for the infrastructure you run it on. The dashboard can be hosted statically, but the Go API needs a long-running server, PostgreSQL, and Playwright — Render, Fly.io, Railway, or your own VPS all work.

Take back the tag layer

Stop trusting the tag layer. Audit it.

Crawl a site, write a policy, and get evidence you can act on — in an afternoon, on your own infrastructure.

Start self-hosting Explore the repository

MIT licensed · Self-hosted · PostgreSQL ready