Veriify documentation

What Veriify is

Veriify tests whether a product actually works — and whether it is honest — then helps you fix what it finds and proves the fix.

Anyone can generate software now. Far fewer people can verify it. Veriify closes that gap: point it at a website, a web app, a code repository, or an AI product, and it returns one Product Health Score from 0-100% built from 82 concrete, versioned checks across 10 dimensions. Every point deducted traces back to a specific finding with evidence. No black box, no vibes.

It does not stop at diagnosis. Veriify generates fixes, verifies them in a sandbox before they count, opens reviewed pull requests, and — when you want a human — connects you to vetted specialists who work in a scoped sandbox and only get paid once a re-scan proves the fix.

What makes the score different

• Deterministic. The same product scanned twice scores the same. Every deduction is a fixed value defined in a public, versioned rubric.
• Evidence-backed. Each finding carries the URL, the element, the header, or the response that triggered it.
• Quality and integrity. Most tools ask "does it work?". Veriify also asks "is it honest?" — dark patterns, fake urgency, hidden fees, undisclosed AI.
• Verified, not claimed. Nothing is marked fixed on your word. A passing re-scan or a live sandbox verification is what moves your score.

Quickstart

Three ways in, depending on what you're doing.

The loop

1. Scan — Veriify crawls every page, form, link, and asset, and runs the dimensions in parallel.
2. Score — you get one number plus a per-dimension breakdown, with every finding and its evidence.
3. Fix — open the Fix Workbench, edit in the Scoped Editor, ask the Agent, or hire a specialist.
4. Verify — re-scan. Only a passing check moves the score up and releases any escrow payment.

Core concepts

How the score is computed

1. Each finding deducts a fixed number of points from its dimension, based on severity.
2. Repeated instances of the same check stop deducting once they hit that check's cap.
3. Each dimension score is 100 - deductions, floored at 0.
4. Dimensions that don't apply are marked N/A and their weight is spread proportionally across the rest.
5. The composite is the weighted average, using the weights for your product category.

The dimensions

10 dimensions, 82 checks. Weights shown are the General preset; they shift by category.

Category weights

A store and a portfolio shouldn't be judged identically. Pick a category at scan time and Veriify re-weights the score to match what actually matters for that product.

Every preset sums to 100%. An online store is judged harder on Security and Functional Correctness — a broken checkout costs real money. A content or portfolio site weights Performance, Accessibility, and Content higher. The ai_product preset is used automatically by AI-product scans.

Check reference

Every check Veriify can emit, with its severity and cap. This is the complete, versioned constitution behind the score — nothing is deducted that isn't listed here.

Functional Correctness (12)

Reliability & Stability (4)

Performance (8)

Security (17)

UX & Accessibility (8)

Content & Communication (7)

Code & Architecture Quality (8)

Compliance & Trust (5)

Genuineness & Integrity (6)

AI Trustworthiness (7)

Scan modes

AI-product testing

Veriify converses with your chatbot or agent and grades what it actually does — producing an AI Trustworthiness score with every finding backed by its transcript.

Start at /scan/ai. Point it at either an API endpoint (a JSON POST it can call) or a chat page URL (it drives the chat UI in a real browser). Optionally supply ground truth — a docs URL Veriify reads to auto-generate questions, or your own Question :: Answer pairs — to test accuracy too.

What it probes

• Prompt injection and jailbreaks — does it obey injected instructions or drop its guardrails?
• System-prompt leakage — will it disclose its hidden instructions?
• Unsafe output — does it refuse clearly harmful requests?
• Consistency — does the same question get materially different answers across runs?
• Accuracy and fabrication — is it right against your ground truth, and does it invent answers to things it cannot know?
• Disclosure — does it admit it's an AI when asked?

Domain verification

Proving you own a domain unlocks the deeper features and earns the verified badge.

Go to /verify and prove ownership one of three ways:

• Meta tag — add <meta name="veriify-site-verification" content="…"> to your homepage.
• File — serve the token at /.well-known/veriify-verification.txt.
• DNS — publish a TXT record containing veriify-verification=….

Verification unlocks Deep Dive, active security probes, code connection, the verified badge, a Registry listing, and the AI transparency declaration.

Fix Workbench

Where diagnosis turns into action. Every finding, with a proposed fix, a risk level, and a way to actually apply it.

1. Open a finding to see exactly what's wrong, the evidence, and why it matters.
2. Edit in sandbox opens the single flagged file in the in-browser Scoped Editor — never the rest of your codebase.
3. Ask the Agent for a plain-English explanation or drop-in code.
4. Verify on server re-runs the exact rule that flagged it, against your edit, in a sandbox. A fix that doesn't pass is rejected.
5. Deploy opens a real pull request on GitHub — reviewed, never force-merged.

The Veriify Agent

An assistant that understands your score, explains any finding, and can act.

The Agent appears on every page once you're signed in. Ask it to scan a site, explain a check, or point you to the right tool — it runs the scan and links straight to the report. Inside the Fix Workbench and Scoped Editor it becomes finding-specific: it reads the actual flagged file and writes code you can paste or insert directly.

On Premium, the autonomous Agent triages your whole scan: it fixes and verifies what it can safely handle on its own, and escalates the rest with a suggested specialist.

It never claims a fix is verified — only the sandbox or a re-scan can do that.

Specialist marketplace

For the findings you don't want to fix yourself — vetted specialists, scoped access, and escrow that only releases on a verified fix.

How an engagement works

1. Hire or negotiate. Hire at the listed price, or make an offer — the specialist can accept, counter, or decline before any commitment.
2. Pending. The engagement is created. No money has moved.
3. Accept + NDA. The specialist reviews the brief and either accepts — signing an NDA that's recorded — or declines.
4. Fund escrow. You pay; the charge is authorised, not captured. The money is held, not transferred.
5. Scoped work. They work in a sandbox containing only the isolated problem — never your full codebase.
6. Deliver and verify. They mark it delivered; a passing re-scan or sandbox verification releases the payment.
7. Rate. Once escrow releases, you rate the specialist — that's what builds their public rating.

Money and disputes

• Payments run through Stripe Connect. Veriify takes a 15% platform fee; the rest goes to the specialist.
• Escrow uses manual capture — funds are authorised up front and only captured on completion.
• A dispute freezes the escrow. It does not auto-refund: neither side is paid until a Veriify admin reviews it and releases the funds to one party. Both the counterparty and the admin team are notified.
• Specialists are paid out to their connected Stripe account once the engagement completes.

Public trust check

Anyone can check any site — free, no account — at veriify.io/check.

Enter a domain and you get its publicly observable signals: HTTPS, TLS certificate validity, mixed content, core security headers, known-vulnerable front-end libraries, reachability, a discoverable privacy policy, contact information, and email anti-spoofing (SPF/DMARC) — each stated as an observation with the date it was seen.

If it's your site, claim it — verified owners get the badge, the full report, and a Registry listing.

Badge, seal & registry

• Score badge — an SVG at /badge/<scanId>.svg you can embed in a README or footer.
• Verified badge — earned at 100% on a Deep Dive with runtime checks included. It means every check passed, not that you paid for it.
• Public score page — a shareable report at /score/<scanId>.
• Registry — /registry lists platforms whose owners verified their identity and had their quality checked. Opt-in only; every listing links to its public check.
• Browser extension — shows a site's Veriify signals while you browse, from the same public data.

AI transparency

Declare how your product uses AI. Veriify audits the declaration against what its scans observe, and publishes the result.

At /attest, a verified owner declares four things: whether the product uses AI, whether users are told when they're interacting with AI, whether AI-generated content is labelled, and whether a human reviews AI output.

Veriify then cross-checks that declaration against its scans. If you declared that AI interactions are disclosed but a scan finds an AI feature with no disclosure, the public check page shows the mismatch instead of the claim.

MCP & AI dev tools

Run Veriify from inside Claude Code, Cursor, Windsurf, Cline, Claude Desktop, VS Code, or Zed — and scan your localhost dev server before you ship.

Veriify publishes an MCP server on npm — nothing to clone or install. It exposes five tools to any MCP-capable assistant:

Most clients (Cursor, Windsurf, Cline, Claude Desktop, VS Code, Zed) take it as JSON config:

{
  "mcpServers": {
    "veriify": {
      "command": "npx",
      "args": ["-y", "@veriify/mcp"],
      "env": { "VERIIFY_API_KEY": "vk_..." }
    }
  }
}

On Windows use "npx.cmd" — MCP clients spawn the command without a shell, and bare npx often fails to resolve.

Claude Code

Install once, then register the binary — this form works in every shell:

npm install -g @veriify/mcp
claude mcp add veriify veriify-mcp -s user -e VERIIFY_API_KEY=vk_your_key

Confirm with claude mcp list — you want veriify showing as connected. Then restart Claude Code and ask: "Scan localhost:3000 and fix what you find."

API keys and how scanning is routed

Create a key at Account. It ties scans to your plan, so your quota and finding visibility are exactly what your tier includes. Without a key you get the Free tier (1 scan/month, 5 findings) — enough to try it before signing up.

Hosted connector

Add Veriify by pasting a URL — nothing to install. The hosted counterpart to the npm package, for clients that support remote MCP servers.

Veriify runs an MCP server over HTTP at https://veriify.io/mcp. Add that URL in any client that supports remote MCP servers.

Sign in with one click

The connector is a full OAuth 2.1 authorization server, so supported clients handle the whole handshake for you: add the URL, get redirected to Veriify, approve the connection, done. No key to copy or paste.

Approving creates an API key named after the application, so a connection shows up in Account → API keys alongside your others — and you revoke it there the same way. There's one list, not two.

Or connect with an API key

For clients without OAuth support, pass a key from Account as a bearer token:

{
  "mcpServers": {
    "veriify": {
      "type": "http",
      "url": "https://veriify.io/mcp",
      "headers": { "Authorization": "Bearer vk_your_key" }
    }
  }
}

Either way you get the same tools — scanning, trust checks, check explanations, documentation search, blueprints, and account status — gated to your plan.

Connector or package?

API reference

The same endpoints the MCP server uses. Authenticate with a key from Account; every route enforces your tier and quota.

curl https://veriify.io/api/v1/scan \
  -H "Authorization: Bearer vk_your_key" \
  -H "Content-Type: application/json" \
  -d '{"url":"https://example.com","category":"saas"}'

Pass the key as Authorization: Bearer vk_… or X-Veriify-Key. An invalid key returns 401; running out of quota returns 402 with your usage and an upgrade link. Requests with no key are treated as Free tier and metered by IP.

CLI & CI

Scan from a terminal, or make it a gate in your pipeline.

npm run scan -- https://example.com
npm run scan -- https://example.com --category saas --json

Options: --category (weight preset), --verified (enables active probes on domains you own), --fixes (print the fix plan), --badge, --json.

In CI, run the scan against a preview deployment on every pull request and fail the build if the score drops below your bar — the quality gate a small team doesn't have to staff.

Blueprint Advisor

Structure before you build, so AI-assisted development doesn't drift into a pile of disjointed requests.

Describe what you're building at /advisor (or call veriify_blueprint from your AI tool) and Veriify returns a concrete, opinionated blueprint covering: the architecture shape, a real project structure, the data model, core building blocks, non-negotiable guardrails, testing and verification, deploy and environments, observability and operations, common mistakes for that kind of app, and an ordered build roadmap.

Connect a repo and it reviews your actual structure against the blueprint, calling out concrete gaps instead of giving generic advice.

Plans & limits

Every new account starts on a 7-day Premium trial — no card required. See /pricing for current prices.

Security & privacy

• Scoped access. Specialists see only the isolated flagged file in a sandbox — never your repository.
• Read-only snapshots. Code connection takes a read-only snapshot with secrets scrubbed before anything is stored. Veriify never touches your live infrastructure.
• Passive by default. Active security probes only run against domains you have verified.
• Crawl politeness. Scans respect robots.txt, are bounded in pages and depth, and identify themselves as VeriifyBot.
• Third-party boundaries. Scans never follow redirects off your origin, so findings are always about your property.
• Secrets. Payment details are handled by Stripe; an AI-product scan uses your API key only for that scan and never stores it with the results.
• NDAs. Specialists sign a recorded NDA before receiving any scoped access.

Glossary

Something missing from these docs? Tell us — we'd rather fix the documentation than answer the same question twice.