HoundDog.ai

Deterministic Privacy Code Scanner for GDPR Data Mapping Evidence and Proactive AI Governance

HoundDog.ai builds lightweight, Rust-based code scanners that give you a living, code-derived view of the services, APIs, data flows, and external integrations across the software you build. Deterministic analysis, refreshed on every commit, across every repo.

Need org-wide gRPC service mapping for your AI coding agents, covering every service, API, and field across monorepos and microservices? See ProtoMap.

Privacy Code Scanner

The Privacy Code Scanner provides deterministic, code-level evidence of sensitive data flows across logs, storage, APIs, third parties, and AI integrations.

Surveys go stale. Privacy platforms infer flows after deployment. AI-only approaches produce inconsistent evidence and waste tokens on discovery. Our engine continuously maps what developers actually implement, including shadow AI and SDKs, with accurate, reproducible results as code changes.

A fast, deterministic engine handles discovery, and AI is used selectively for reasoning and context. That means predictable performance and minimal latency, so the scanner runs directly in CI on standard CPU infrastructure.

It powers Replit's Security Agent at massive scale (100k daily scans) and is used by Fortune 1000 companies across technology, finance, and healthcare.

Use Cases

• Prevent sensitive data leaks. Catch leaks into application logs and other risky mediums before they reach production.
• Enable proactive AI governance. Discover AI integrations and see exactly what types of data are shared with them.
• Ground GDPR data mapping in code evidence. Give privacy teams deterministic evidence of actual data flows so they can prevent risks instead of documenting them after the fact.
• Keep RoPA updated at development speed. Reflect new categories of personal data and subprocessors as developers introduce them, instead of lagging one or two quarters behind the code.

HoundDog.ai in Action

With the self-hosted or cloud platform, your organization's data map becomes queryable in plain English:

• An AppSec engineer asks where auth tokens are leaking in plaintext into application logs.
• A privacy engineer asks which third-party integrations receive PII.
• An AI governance team asks which AI integrations exist and what sensitive data reaches them.

For example, "Which third-party and AI integrations have confirmed sensitive data flows?" queries the underlying dataflow graph and returns the relevant integrations, sensitive data elements, repositories, code locations, and risk status.

The data map becomes more than documentation. It becomes an interface to sensitive data flow evidence across your codebases, refreshed on every commit, across every repo.

Technical Highlights

• Deterministic static analysis. The same commit produces the same result, every time. No prompt sensitivity, and your AI tokens are saved for higher-value work like reasoning over detected flows.
• Deep dataflow tracing. Tracks sensitive data such as PII, PHI, CHD, and auth tokens through transformations across files, functions, and procedures, regardless of nesting depth. Flows are flagged when they reach a sink, whether controlled (a database) or high-risk (an LLM prompt or application logs).
• Broad coverage, fully customizable. 100+ sensitive data types and 900+ data sinks supported out of the box. You can also create your own data element and data sink rules.
• Built for large codebases. Scans millions of lines of code in under a minute on a modern laptop.
• AI integration (highly recommended). Works out of the box on the HoundDog.ai cloud platform, or with your organization's own AI provider and API key (see FAQ). AI reduces false positives, adds context, and lets you query the data map in plain English. It only sees the code behind each finding: its dataflow trace and the source file where it was detected.

Installation

Self-Hosted Platform + CLI Scanner (recommended)

Follow the self-hosted platform installation instructions. The platform runs in lightweight Docker containers on a developer's machine (ideal for POCs) and includes the CLI scanner.

Enable the AI integration with your organization's API key for the full experience: the scanner discovers, AI reasons over the detected flows, and you query the results in plain English.

CLI Scanner Only

For use with the cloud platform, or if you prefer results in the console or as Markdown reports.

Linux and macOS

curl -fsSL https://raw.githubusercontent.com/hounddogai/hounddog/main/install.sh | sh

The script installs the CLI to ~/.local/bin, a link into ~/.hounddog, and adds that folder to your PATH in your shell's profile. On macOS, the CLI requires Apple silicon. On an Intel Mac, use the hounddogai/hounddog Docker image instead.

Windows

irm https://raw.githubusercontent.com/hounddogai/hounddog/main/install.ps1 | iex

The script installs the CLI to %LOCALAPPDATA%\hounddog\bin, or for all users to %ProgramFiles%\hounddog\bin when run as an administrator, and adds it to the PATH. You can also download a binary, hounddog-<os>-<arch>, from the releases page, and check it against the release's SHA256SUMS.

To install a given version, which then stays:

curl -fsSL https://raw.githubusercontent.com/hounddogai/hounddog/main/install.sh | sh -s -- --version 4.0.0

& ([scriptblock]::Create((irm https://raw.githubusercontent.com/hounddogai/hounddog/main/install.ps1))) -Version 4.0.0

The CLI that the scripts install keeps itself up to date: at most once a day, a command downloads a newer release in the background for the next one. It does not in CI, in containers, when installed as root or as a Windows administrator, or when installed at a given version, which then stays. Run hounddog update to update by hand, hounddog update --auto on or off to choose, and hounddog update --rollback to go back to the version an update replaced. HOUNDDOG_DISABLE_AUTOUPDATE=1 turns automatic updates off for one command or a whole environment.

Uninstallation

Remove the CLI, its configuration, which can hold API keys, and its local scan state, which holds copies of scanned source files:

# Linux and macOS
rm -rf ~/.local/bin/hounddog ~/.hounddog ~/.config/hounddog ~/.local/share/hounddog
sudo rm -f /usr/local/bin/hounddog  # Only if installed as root

# Windows
Remove-Item -Recurse -Force "$env:LocalAppData\hounddog"  # CLI and local scan state
Remove-Item -Recurse -Force "$env:AppData\hounddog"       # Configuration, if it exists
Remove-Item -Recurse -Force "$env:ProgramFiles\hounddog"  # Only if installed as administrator

Usage

hounddog scan [OPTIONS] [PATH]

• Self-hosted platform: results appear at http://localhost:3300. Trial installs connect the CLI automatically; for Production installs, create a CLI API key in the web app after setup, and set HOUNDDOG_URL to the platform's URL, such as https://hounddog.example.com, and HOUNDDOG_API_KEY to the key.
• Cloud platform: set HOUNDDOG_API_KEY to your API key and results are uploaded to the platform.
• CLI only: pass --local (or --no-cloud), and results are displayed in the console. --no-cloud-upload uses the platform's settings without uploading the results.

For a quick demo, scan our Python test repository:

git clone https://github.com/hounddogai/hounddog-test-python
hounddog scan hounddog-test-python

Generate a Markdown report with --output-format=markdown:

hounddog scan hounddog-test-python --output-format=markdown --output-path=report.md

We recommend the Markdown Viewer Chrome extension for viewing reports (see setup and sample report).

More Options

hounddog scan --output-format=json                # Results as versioned JSON (also sarif, markdown, and agent)
hounddog data-elements list --output-format=html  # Supported data elements (HTML)
hounddog data-sinks list --output-format=html     # Supported data sinks (HTML)
hounddog [SUBCOMMAND] --help                      # All subcommands and options

Coding Agents

hounddog mcp serves the repository's scan results to coding agents over MCP, on standard input and output. Add it to Claude Code from the repository's folder:

claude mcp add hounddog -- hounddog mcp

Docker

The hounddogai/hounddog image runs the scanner on Linux (amd64 and arm64) without installing it. Mount the root of a Git checkout at /data, the image's working directory, and pass the API key from your environment:

docker run --rm -v "$PWD:/data" -e HOUNDDOG_API_KEY hounddogai/hounddog hounddog scan

• The image scans Git repositories only: Git metadata names the repository whose results the scan replaces.
• The image never updates itself. Pin a tag and move to a newer one deliberately, or pull the tag you run again when it moves.
• Docker passes on only the variables you name, so pass your CI provider's too, for Jenkins -e JENKINS_URL -e BRANCH_NAME -e CHANGE_TARGET -e CHANGE_BRANCH -e CHANGE_FORK. Without them, the scanner cannot tell that it runs in CI, or a pull request build from a branch build. Without HOUNDDOG_API_KEY, the scan uses the bundled rules only, uploads nothing, and warns.
• Self-hosted platforms also need -e HOUNDDOG_URL. Write output files under /data, such as --output-path=/data/report.md, to keep them.

CI Pipelines

--fail-severity-threshold=<info|low|medium|high> fails the build with exit code 3 on a risky dataflow at or above the threshold, after every output and the upload. --severity only chooses what the outputs show; it never changes what fails the build. Dataflows whose issue is ignored or snoozed on the platform never fail it, and severities that a user or an AI review set on the platform apply.

• Pull request builds fail only on risky dataflows that are new to the pull request's target branch. The scanner reads the target branch from the CI provider's variables, such as Jenkins' CHANGE_TARGET (Jenkins is detected by JENKINS_URL, or named with --ci=jenkins), or from HOUNDDOG_GIT_BASE_BRANCH, which takes precedence. Without a target branch, every risky dataflow counts as new.
• Branch builds, such as those of main, have no target branch, so every risky dataflow at or above the threshold fails the build until it is fixed, or ignored on the platform.
• In CI, the scan fails when HOUNDDOG_API_KEY is not set, so a credential that is not bound to the build cannot pass every build without uploading. Pass --local to scan with the bundled rules only.

Excluded Files

The scanner skips the files that the repository's .gitignore files exclude, and the files that one of these lists excludes, in this order of precedence:

1. A .hounddogignore file at the repository's root, in .gitignore syntax.
2. The file patterns on the HoundDog.ai platform, when the scan uses an API key.
3. The default patterns, which the platform's patterns also start with.

Exit Codes

• 0: the scan succeeded.
• 1: the scan failed with an error.
• 2: the command line is invalid.
• 3: --fail-severity-threshold found a risky dataflow at or above the threshold, so a CI pipeline can block the change while still telling it apart from a scan error.

Pricing

See the HoundDog.ai Pricing Page.

FAQ

How can I trust your scanner?

Visit our Trust Center for our latest SOC 2 report, penetration testing results, and SBOM details.

Does your scanner send my code to external servers?

Not by default. Scans run locally on your machine or CI runner, and code leaves it only for destinations your organization sets up:

• HoundDog.ai platform: when connected, the scanner uploads scan results, including the source files where dataflows were detected, so you can review each finding in context. The self-hosted platform runs entirely inside your network, so this code and the resulting data map stay within your infrastructure.
• AI integration: the platform reviews each uploaded finding using only its dataflow trace and the source file where it was detected, with the HoundDog.ai cloud platform's built-in AI or the AI provider your organization configures.

Does your scanner use AI?

Scans run on a deterministic static analysis engine, which keeps them fast, cheap, and free of hallucinations.

AI integration (cloud and self-hosted). On the HoundDog.ai cloud platform, AI works out of the box with Google Vertex AI. Your organization can also choose its own provider (AWS Bedrock, Anthropic, OpenAI, Google Gemini, Google Agent Platform, Microsoft Foundry, or xAI) and API key, on the cloud or self-hosted platform. Findings, traces, and source context then go directly to that provider under the DPA and terms your organization holds with it. The AI layer runs on the platform: it auto-closes false positives, adjusts severities, and adds context to findings the scanner already produced. The deterministic scan still runs in your CI on inexpensive CPU with negligible impact on CI time.

Rule development. HoundDog.ai uses AI internally to help generate and update detection rules before they ship with the scanner. Customer code and scan results are never used for this, and HoundDog.ai does not use customer code, findings, prompts, or responses to train AI models.

Why not just use an LLM?

We recommend using both. HoundDog.ai is built to make your AI more effective, not to replace it.

• Spend tokens on reasoning, not discovery. The scanner finds and traces sensitive data flows, so your AI tokens go to higher-value work like assessing risk, reviewing flows, and answering questions about your data map.
• Evidence you can stand behind. The same commit always produces the same result. That reproducibility makes findings usable as evidence for GDPR data mapping, RoPA, and audits, where AI-generated output that varies with the prompt may not yet be accepted.
• Easy to roll out org-wide. The Rust scanner runs in CI on standard CPU infrastructure, across every repo and every commit, with negligible impact on build times.

How is this different from secrets scanners like GitLeaks or TruffleHog?

Secrets scanners find credentials hardcoded in code, such as API keys, passwords, or tokens:

exposed_api_key = "sk-proj-1234567890-abcdefghijklmnopqrstuvwxyz"

HoundDog.ai tracks how sensitive data actually flows through code, across assignments and transformations:

import logging
import os

logger = logging.getLogger(__name__)

# HoundDog.ai detects that `foo` is an authentication token.
foo = os.environ.get("MY_API_KEY")

# HoundDog.ai traces values through various code paths.
bar = {"message": f"api_key={foo}".strip()}

# HoundDog.ai detects that `bar` contains an authentication token (tainted) and is leaked to a log.
logger.info("data=%s", bar)

How is this different from Semgrep or CodeQL?

Semgrep and CodeQL are powerful and highly customizable, but their rules take significant upfront investment to learn and maintain.

HoundDog.ai works out of the box: broad, high-quality coverage of data elements and sinks from day one, with custom rules when you need them. It is purpose-built for dataflow analysis, scales efficiently to large codebases, and detects complex flows that general-purpose tools miss.

Your scanner missed a dataflow!

Our rules are constantly evolving. Please report any false positives or negatives and we will address them.

Documentation

See the HoundDog.ai documentation.

License

See license information for HoundDog.ai's software.

Contact

Questions or feedback? Open a GitHub issue or email support@hounddog.ai.