openauditB85out of 100: openaudit's audit of itself

One scored audit of everything you ship.

Code, sites, apps, APIs, containers, infrastructure, cloud and mobile builds, audited for security, accessibility, performance and seven more areas. From your terminal, your CI or your AI agent.

bunx openaudit .

openaudit audits itself on every push: 85/100

Areas
9
Auditors
50
Took
17.4 s
Run
13 Oct 2026

Ten areas, each with its own grade

Every finding belongs to one area, and each area scores 0 to 100 from the severity of what was found. Pick an area to see what openaudit checks, where, and with which tools. The letters are openaudit's grades for its own repository.

Security

D53/100 in openaudit's own audit

Leaked secrets (also in git history), injection, XSS and other risky code, weak crypto, disabled TLS or JWT checks, security headers, TLS, DNS and email spoofing protection, exposed files and APIs, container, IaC and cloud misconfiguration, risky mobile manifests, and optional dynamic scanning

Applies to

  • Codebase
  • URL
  • Web app
  • Container
  • Infrastructure as code
  • Mobile build
  • Cloud account
Example finding
CriticalAWS access key IDsrc/config.ts:14code.secrets/aws-access-key-id

Wrapped tools, used when installed

  • actionlint
  • bandit
  • brakeman
  • bun
  • cargo
  • cargo-audit
  • checkov
  • docker
  • dockle
  • gitleaks
  • golangci-lint
  • gosec
  • govulncheck
  • grype
  • hadolint
  • kics
  • kube-linter
  • kubescape
  • mobsfscan
  • npm
  • osv-scanner
  • pip-audit
  • pnpm
  • prowler
  • ruff
  • semgrep
  • shellcheck
  • testssl.sh
  • trivy
  • trufflehog
  • zizmor

Agent playbooks

  • agent.authz
  • agent.injection
  • agent.secrets-config
  • agent.webapp-security
  • agent.mobile
  • agent.iac-architecture
All 61 security auditors

Accessibility

A100/100 in openaudit's own audit

WCAG checks in JSX, Vue, Svelte, HTML and CSS; axe-core and pa11y on rendered pages; Android layouts; keyboard and screen-reader journeys walked by an agent

Example finding
HighImage without alt textsrc/components/Hero.tsx:22code.accessibility/img-alt-missing

Wrapped tools, used when installed

  • lighthouse
  • pa11y

Agent playbooks

  • agent.a11y-journeys
  • agent.ux-content
All 8 accessibility auditors

Performance

A100/100 in openaudit's own audit

Page weight, caching, compression, Core Web Vitals, Lighthouse, image and bundle size, container image size, mobile app size and native libraries

Example finding
MediumRender-blocking script in <head>https://example.com/ head > scriptweb.performance/render-blocking-script

Wrapped tools, used when installed

  • cargo
  • lighthouse

Agent playbooks

  • agent.performance
All 8 performance auditors

SEO

Not graded in openaudit's own audit: its auditors run on url, web app targets

Titles and descriptions, crawlability, canonical URLs, sitemaps, structured data, broken links

Applies to

  • URL
  • Web app

Built in

Example finding
MediumBroken internal link (404)https://example.com/pricingweb.seo/broken-link

Wrapped tools, used when installed

  • lighthouse

Agent playbooks

  • agent.ux-content
All 3 seo auditors

Privacy

A100/100 in openaudit's own audit

Trackers and cookies set before consent, analytics, ad and session-replay SDKs, personal data written to logs, mobile permissions

Example finding
MediumTracking cookies set before consenthttps://example.com/webapp.browser/tracking-cookie-before-consent

Wrapped tools, used when installed

  • mobsfscan

Agent playbooks

  • agent.privacy
  • agent.mobile
All 9 privacy auditors

Best practices

A100/100 in openaudit's own audit

Repository hygiene (README, licence, security policy, CI, lockfiles), Dockerfile and IaC lint, GitHub Actions hardening

Example finding
LowADD used where COPY sufficesDockerfile:7container.dockerfile/add-instead-of-copy

Wrapped tools, used when installed

  • actionlint
  • checkov
  • dockle
  • hadolint
  • kics
  • kube-linter
  • lighthouse
  • semgrep
  • spectral

Agent playbooks

  • agent.secrets-config
  • agent.ux-content
All 19 best practices auditors

Reliability

F18/100 in openaudit's own audit

Type errors, broken pages and redirect chains, missing Kubernetes probes and limits

Example finding
LowHealth probes missingk8s/deployment.yaml:18iac.kubernetes/probes-missing

Wrapped tools, used when installed

  • actionlint
  • biome
  • cargo
  • eslint
  • golangci-lint
  • kics
  • kube-linter
  • kubescape
  • mypy
  • oxlint
  • ruff
  • shellcheck
  • spectral
  • staticcheck
  • tsc

Agent playbooks

  • agent.performance
  • agent.iac-architecture
All 22 reliability auditors

Maintainability

A98/100 in openaudit's own audit

Linting, strict typing settings, duplication, dead code, deep nesting and oversized files

Example finding
MediumTypeScript strict mode disabledtsconfig.json:4code.quality/ts-strict-disabled

Wrapped tools, used when installed

  • biome
  • cargo
  • eslint
  • golangci-lint
  • jscpd
  • knip
  • mypy
  • oxlint
  • ruff
  • staticcheck
  • tsc
All 14 maintainability auditors

Supply chain

A100/100 in openaudit's own audit

Known-vulnerable dependencies, unpinned versions and actions, OpenSSF Scorecard, licences, SBOMs, container image CVEs

Example finding
MediumBase image uses a mutable tagDockerfile:1container.dockerfile/from-latest

Wrapped tools, used when installed

  • brakeman
  • bun
  • cargo-audit
  • govulncheck
  • grype
  • npm
  • osv-scanner
  • pip-audit
  • pnpm
  • scorecard
  • syft
  • trivy
  • zizmor

Agent playbooks

  • agent.iac-architecture
All 21 supply chain auditors

Compliance

A100/100 in openaudit's own audit

Licence obligations, cookie consent, OWASP Top 10 and CWE Top 25 mapping, CIS cloud benchmarks

Applies to

  • Codebase
  • URL
  • Cloud account
Example finding
Mediumvendor/parser.c: GPL-3.0-onlyvendor/parser.c:1code.scancode/strong-copyleft

Wrapped tools, used when installed

  • prowler
  • scancode
  • syft

Agent playbooks

  • agent.privacy
All 6 compliance auditors

Point it at anything you ship

openaudit detects what the target is and what it contains, then runs the auditors that apply. Seven kinds of target and every major language, scored in the same ten areas.

By target

Number of auditors for each target and area
TargetSecuritySecAccessibilityA11yPerformancePerfSEOSEOPrivacyPrivBest practicesBPReliabilityRelMaintainabilityMntSupply chainSupComplianceComp
Codebasebunx openaudit .30 auditors1 auditors3 auditorsnone3 auditors6 auditors13 auditors14 auditors13 auditors4 auditors
URLbunx openaudit https://example.com9 auditors5 auditors2 auditors3 auditors3 auditors4 auditors1 auditorsnonenone2 auditors
Web appbunx openaudit https://example.com --browser5 auditors4 auditors1 auditors1 auditors1 auditors1 auditors1 auditorsnonenonenone
Containerbunx openaudit image:nginx:1.277 auditorsnone1 auditorsnonenone4 auditors2 auditorsnone4 auditorsnone
Infrastructure as codebunx openaudit ./infra11 auditorsnonenonenonenone6 auditors6 auditorsnone4 auditorsnone
Mobile buildbunx openaudit ./app-release.apk5 auditors1 auditors1 auditorsnone3 auditors1 auditorsnonenone1 auditorsnone
Cloud accountbunx openaudit cloud:aws --only cloud1 auditorsnonenonenonenonenonenonenonenone1 auditors

Dot size is the number of auditors that cover the area for that target, counted from the registry when the site is built.

By language

LanguageSecurityDependenciesTypes, lint and quality
JavaScript / TypeScriptbuilt-in rules, Semgrepnpm, pnpm, Yarn and Bun lockfiles via OSV.dev; npm / pnpm / bun audittsc, oxlint, Biome, ESLint*, knip*, strict tsconfig checks
Pythonbuilt-in rules, Semgrep, Banditrequirements*.txt, poetry.lock; pip-auditruff, mypy*, type-checker configuration
Gobuilt-in rules, Semgrep, gosecgo.mod; govulncheck*staticcheck, golangci-lint*
RustSemgrepCargo.lock; cargo-auditclippy*, [lints] and unsafe policy checks
Rubybuilt-in rules, Semgrep, Brakeman (Rails)Gemfile.lockNone
PHPbuilt-in rules, Semgrepcomposer.lockNone
Java / Kotlinbuilt-in rules, Semgrep, mobsfscan (Android)Maven and Gradle via osv-scanner and TrivyNone
C# / .NETbuilt-in rules, SemgrepNuGet via osv-scanner and TrivyNone
Swift / Objective-Cmobsfscan (iOS)NoneNone
ShellNoneNoneShellCheck, set -euo pipefail checks
HTML, CSS, JSX, Vue, Svelteaccessibility and performance rulesNoneNone

* Opt-in: run it with --only <id>, e.g. --only code.clippy. The next section explains why some tools are opt-in.

One issue, one finding

Most audits are a pile of tool outputs that disagree. openaudit runs the tools, merges what they agree on, and hands you one scored result.

  1. Run

    Point it at a folder, a URL, an image or a cloud account. It picks the auditors that apply and runs them in parallel. A scanner that isn't installed is skipped with an install hint.

  2. Merge and score

    When several tools report the same issue, you get one finding that names who confirmed it, scored once. Each area scores 0 to 100 from what remains.

    Example: one leaked key, three tools, one finding. A single critical finding takes an area to 50.

  3. Report and gate

    One report as HTML, JSON, SARIF, Markdown or CSV. --fail-on sets the exit code for CI, and --diff keeps a pull request to the files it changed.

A report people actually read

One self-contained HTML file with no external requests. It opens offline, works with JavaScript off and prints cleanly, so it can be attached to a CI run or an email.

The openaudit HTML report: an overall grade dial with one arc per area, severity counts and a navigation rail listing every areaThe openaudit HTML report in the dark themeOpen the live report
The report for openaudit's own repository, from an earlier run. The live one is rebuilt on every push.
  1. Overview

    An overall grade with one arc per area, severity counts and the status of every auditor that ran or was skipped.

  2. A tab per area

    Each area has its own tab, with filters, search and findings grouped by rule.

  3. OWASP and CWE

    Findings mapped to the OWASP Top 10 and the CWE Top 25.

  4. Downloads

    The same audit as JSON, SARIF, Markdown or CSV, straight from the page.

Built for agents

Some audits need judgment rather than patterns. openaudit lets the agent you already use drive the whole loop, and checks its fixes.

  • MCP server, over stdio or HTTP

    Claude Code, Cursor, Codex and other agents get run_audit, get_finding, compare_reports and the playbook tools. Remote agents connect over Streamable HTTP with a bearer token.

  • 10 playbooks for judgment calls

    Authorisation, injection paths, privacy data flows, keyboard journeys and more. Your agent does the review with its own tools; its findings merge into the same scored report. No extra API key.

  • A JSON agent mode

    --json prints one JSON report on stdout and nothing else, and openaudit schema gives its JSON Schema.

  • A skill for the whole loop

    skills/openaudit/SKILL.md teaches an agent the loop: baseline, triage, run the playbooks, fix, then verify with compare_reports.

claude mcp add openaudit -- bunx openaudit mcp
MCP, playbooks and agent setup
Example session in Claude Code
  1. Audit this repo and fix what matters.
  2. openaudit run_audit target: "."
  3. 78/100, grade C. 1 critical and 3 high findings from 41 auditors.
  4. openaudit get_playbook id: "agent.authz"
  5. Authentication and authorization review: inventory every route, then check who can reach it.
  6. Read src/routes/admin.ts
  7. openaudit submit_findings 2 findings
  8. Merged into the report. Security 61 to 54.
  9. Edit src/routes/admin.ts, src/config.ts
  10. openaudit compare_reports
  11. 3 fixed, 0 new.

Runs where you already work

From a terminal, an editor, a pull request or a container. Every route produces the same report.

CLI

bunx openaudit

openaudit needs Bun 1.4 or newer. Scanners are optional: an auditor whose tool is missing is skipped with an install hint, and the rest of the audit runs normally. To run from source, see Contributing.

CLI reference

bunx openaudit .                            # a codebase
bunx openaudit https://example.com          # a live site (add --browser for Playwright + axe-core)
bunx openaudit ./app-release.apk            # a mobile build (.apk, .aab, .ipa)
bunx openaudit image:nginx:1.27             # a container image
bunx openaudit cloud:aws --only cloud       # a live cloud account (Prowler)

bunx openaudit . -f html -o report          # write the interactive report to report/
bunx openaudit doctor                       # which optional scanners are installed

MCP

openaudit mcp

The MCP server lets an agent run audits, read findings with the surrounding source code, compare reports to confirm fixes, and work through playbooks. Playbooks are judgment-heavy checks, such as authorization, business logic and real-world accessibility, that the agent does with its own code and browser tools. It then reports the results back with submit_findings. Playbooks need no API key.

MCP and agents

claude mcp add openaudit -- bunx openaudit mcp

GitHub Action

wezter96/openaudit

The repository is also a GitHub Action. On pull requests it reports only findings in changed files, uploads SARIF to code scanning, attaches the reports as an artifact and writes a job summary.

Inputs and outputs

permissions:
  contents: read
  security-events: write

steps:
  - uses: actions/checkout@v7
    with:
      fetch-depth: 0 # diff mode compares against the base branch
  - uses: wezter96/openaudit@main # pin to a commit SHA in real use
    with:
      fail-on: high

Docker

ghcr.io/wezter96/openaudit

ghcr.io/wezter96/openaudit bundles openaudit with the free scanners, pinned to exact versions. Images are multi-arch (linux/amd64, linux/arm64) and ship with provenance and an SBOM.

Tags and included scanners

# Audit the current directory. Run as yourself: git refuses repositories owned by
# another user, and reports are written as you
docker run --rm --user "$(id -u):$(id -g)" -v "$PWD:/src" -w /src \
  ghcr.io/wezter96/openaudit . -f html,sarif -o openaudit-report --fail-on high

# Audit a live site with a real browser
docker run --rm ghcr.io/wezter96/openaudit:latest-full https://example.com --browser

# See which tools are installed
docker run --rm ghcr.io/wezter96/openaudit doctor

GitLab CI

include: remote

On merge requests the job audits only changed files (--diff origin/$CI_MERGE_REQUEST_TARGET_BRANCH_NAME); on the default branch and schedules it audits everything.

GitLab setup

include:
  - remote: https://raw.githubusercontent.com/wezter96/openaudit/main/integrations/gitlab/openaudit.gitlab-ci.yml

variables:
  OPENAUDIT_FAIL_ON: high   # optional

pre-commit

id: openaudit

The hooks audit the whole working tree with --offline --fail-on high, so staged changes are covered and a commit stays quick. They do not use --diff: it compares commits (<ref>...HEAD) and staged changes are not committed yet, so --diff HEAD would find nothing. To check a branch's committed changes instead, run the hook on pre-push with your own arguments.

Hooks and stages

repos:
  - repo: https://github.com/wezter96/openaudit
    rev: main # pin to a tag or commit
    hooks:
      - id: openaudit          # needs Bun on PATH
      # - id: openaudit-docker # or: the Docker image, nothing else to install

SARIF

-f sarif

Run the audit from the repository root, so that SARIF file paths line up with the files in the repository. The job needs the security-events: write permission to upload SARIF.

Code scanning setup

- uses: oven-sh/setup-bun@v2
- name: openaudit
  run: bunx openaudit . --format sarif,markdown --out openaudit --fail-on high
- name: Upload SARIF
  if: always()
  uses: github/codeql-action/upload-sarif@v4
  with:
    sarif_file: openaudit/openaudit-report.sarif
    category: openaudit
- name: Job summary
  if: always()
  run: cat openaudit/openaudit-report.md >> "$GITHUB_STEP_SUMMARY"

IDEs

mcp.json

Cursor and VS Code start the same MCP server from a project's mcp.json (VS Code uses "servers" instead of "mcpServers"), so the agent in your editor can run audits and playbooks.

Editor and Codex setup

{
  "mcpServers": {
    "openaudit": { "command": "bunx", "args": ["openaudit", "mcp"] }
  }
}

Safe on hostile input

openaudit treats every target as hostile. Tools that would run project code are opt-in, and nothing builds or installs what it scans.

The full safety model

  • Files

    Reads are confined to the project root and never follow symlinks out of it.

  • HTTP

    User-supplied headers go only to the exact target origin, and credentials are stripped on cross-origin redirects.

  • Agents

    openaudit's own agents have no shell, and the browser is held to the target origin at the network layer. deepsec's reviewer does get a sandboxed shell, which is why it is opt-in.

  • Wrapped tools

    Tools never build or install the target. They run from temporary directories so project config can't redirect them (pnpm hook files, pa11y config, oxlint JS plugins, Spectral custom functions). Linters whose config is code (ESLint, clippy, mypy, golangci-lint) are opt-in.

  • Git

    Every git call overrides core.fsmonitor and hooks, diffs compare commits rather than the working tree, and history scans run on a fresh mirror clone.

Free and open source

No account, no licence key and no hosted service in the way.

  • MIT licensed

    Read the code, run it anywhere, change it. The licence

  • Free tools only

    Every scanner openaudit wraps is free and open source, and keeps its own licence.

  • Tokens are the only cost

    And only if you choose the AI features: AI triage and the headless agentic auditors are opt-in.

openaudit is shared with OpenSverige, Sweden's open community for people building AI agents and MCP servers. Come show what you've audited, or tell us what openaudit missed.

Questions

Does it upload my code?

No. Audits run on your machine and file reads stay inside the project. Some auditors use the network: dependency checks look packages up on OSV.dev, and URL audits send low-volume GET and HEAD requests to the site you point them at. --offline turns off everything except the target. Code only leaves your machine if you turn on the opt-in agentic auditors, which send the files the agent reads to Anthropic; --ai sends finding metadata, never file contents.

Which tools do I need installed?

Only Bun 1.4 or newer. The 32 built-in auditors need nothing else. Each of the 45 wrapped scanners is used when it is on your PATH, and a missing one is skipped with an install hint. openaudit doctor lists what is available, and the Docker image ships with the free scanners preinstalled.

Does it replace Snyk or SonarQube?

It covers much of the same ground, such as static analysis, vulnerable dependencies and code quality, using free and open-source scanners. It also puts websites, containers, infrastructure, cloud accounts and mobile builds in the same report. It runs where you run it rather than as a hosted service, and it can run alongside a commercial tool: both can upload SARIF to GitHub code scanning.

How is the score calculated?

Each finding adds a penalty: 40 for critical, 15 for high, 5 for medium, 1 for low and nothing for info. An area scores 100 × 40 ÷ (40 + penalty), so one critical finding gives 50 and one high gives 73. Grades start at 90 for A, 80 for B, 70 for C, 50 for D. The overall score is the average of the areas that were examined. More on scoring

Can AI agents use it?

Yes, it is built for them. Add the MCP server and your agent can run audits, read findings with the surrounding source, work through the playbooks and confirm its fixes with compare_reports. --json gives scripts and agents one machine-readable report. Agent setup

Is it free?

Yes. openaudit is MIT licensed and every scanner it wraps is free and open source. The only cost is tokens, and only if you choose to use the AI features.

Audit your own project

bunx openaudit . -f html -o report

Writes the interactive report to report/. Open report/openaudit-report.html in any browser.