DEV Community

Deepak Satyam
Deepak Satyam

Posted on

StackHawk vs ZAP vs Schemathesis (2026): which API security testing tool finds what

If you want automated security testing for an API in CI, three names come up first: ZAP, the free and open-source scanner; StackHawk, the commercial developer-focused scanner that grew out of ZAP; and Schemathesis, an open-source tool that generates tests from your API schema.

They overlap less than it seems. This post explains what each one actually tests, what it costs, and which fits which team. All facts are from each project's own docs, repositories and pricing pages as of November 2026, linked inline.

(Disclosure and scope: I build SpecShield, which does **static* API security checks — it reads specs and logs and never sends requests. It isn't a competitor to these three; it does a different job, which I cover briefly at the end. I haven't run StackHawk for this post, so its section is based on its documentation rather than my own tests.)*

The short version

ZAP StackHawk Schemathesis
What it is General DAST scanner (web apps + APIs) Commercial DAST for developers and CI Property-based API testing from the schema
Finds Injection, misconfiguration, known vulnerability classes Same classes, plus multi-user authorization testing Server errors, spec violations, auth bypass, object-level authorization
API inputs OpenAPI, SOAP, GraphQL OpenAPI, GraphQL, gRPC, JSON-RPC, SOAP OpenAPI, GraphQL, gRPC
Authorization (BOLA) testing Manual setup Yes ("Business Logic Testing", 2+ user profiles) Yes (object_level_authorization, 2+ peers)
License / price Apache-2.0, free Wingman $10/user/mo (14-day trial); Scale custom MIT, free
Runs as Docker scripts, desktop app, daemon CLI in CI Python CLI, pytest plugin

ZAP: the free, broad scanner

ZAP is one of the most widely used DAST tools in the world: Apache-2.0, around 16,000 GitHub stars, latest stable release v2.17.0. It started as an OWASP project; since September 2024 it's ZAP by Checkmarx. Its project leads joined Checkmarx, and it continues as a community project under the same license.

For APIs, the relevant piece is the API scan, a script in ZAP's Docker images:

docker run -t zaproxy/zap-stable zap-api-scan.py \
  -t https://staging.example.com/openapi.json -f openapi
Enter fullscreen mode Exit fullscreen mode

It imports an OpenAPI, SOAP or GraphQL definition and runs an active scan tuned for APIs: it skips checks that don't apply (like XSS) and adds alerts for server errors and for responses with content types unusual for an API.

Strengths: free, mature, huge rule set for classic vulnerability classes (injection, misconfiguration, information leaks), and an active community.

Weaknesses for API teams: it was built as a web-app proxy and scanner, and that shows. Authenticated scanning requires a context file with users defined in it, and testing whether user A can read user B's objects needs manual setup rather than a built-in check. Results are alerts by vulnerability class, not by API operation.

StackHawk: ZAP's lineage, packaged for CI

StackHawk was originally built on ZAP. In June 2024 it announced its own engine, HSTE, which it describes as an internal fork of ZAP that lets it "rework, remove and replace ZAP's internals." StackHawk also funds ZAP contributions through its ZAP Fund.

What you pay for is mostly the developer workflow around the scanner:

  • Configuration in a YAML file in your repo, with a CLI (HawkScan) that runs locally or in CI.
  • API inputs including OpenAPI, GraphQL, gRPC, JSON-RPC and SOAP.
  • Authenticated scanning: form login, HTTP auth and third-party OAuth.
  • Business Logic Testing (launched December 2025): you configure two or more user profiles, and it tests horizontal access (user A reading user B's data — BOLA) and vertical access (a member calling admin functions — BFLA).
  • Findings triaged in a dashboard, with fix guidance aimed at developers.

Pricing: Wingman is $10 per user per month with unlimited apps and 50 scans per user per month, and a 14-day trial with no card required. Scale (org-wide, SSO, attack-surface discovery, sensitive-data detection, unlimited scans) is quoted by sales.

Strengths: the CI experience, authorization testing that's configured rather than scripted, and support.

Weaknesses: it's a paid product with a per-user model, and like any DAST it needs a running environment with test users and data. The authorization testing is only as good as the user profiles and data you give it.

Schemathesis: tests generated from your schema

Schemathesis (MIT, ~3,800 stars, v4.33.4 released 12 November 2026) comes from a different tradition. It isn't a vulnerability scanner. It's a property-based testing tool built on Hypothesis: it reads your schema, generates valid, edge-case and invalid inputs, chains operations into stateful workflows, and checks every response.

schemathesis run https://staging.example.com/openapi.json
Enter fullscreen mode Exit fullscreen mode

Its built-in checks are on by default. The security-relevant ones:

Check What it catches
ignored_auth A protected operation accepts requests with missing or invalid credentials
object_level_authorization One user can read another user's object (OWASP API1). Needs two or more configured peers
use_after_free A deleted resource is still accessible (stateful mode)
negative_data_rejection The API accepts input the schema says is invalid
unsupported_method An undeclared HTTP method doesn't return 405
not_a_server_error A 5xx — often the first sign of an unhandled injection or parsing bug

Plus conformance checks: status codes, content types, headers and response bodies must match the schema.

Strengths: it finds the bugs that come from your API's shape — validation bypasses, crashes on edge cases, auth that isn't enforced, broken object-level authorization — and it doubles as contract testing, because every response is checked against the spec.

Weaknesses: it doesn't carry a library of attack payloads for classic vulnerability classes the way ZAP does, and it's only as good as your schema. An endpoint that isn't in the spec never gets tested.

Which finds what

Problem ZAP StackHawk Schemathesis
SQL / command injection ✅ attack payloads ✅ attack payloads Partial (5xx on generated input)
Security headers, misconfiguration ✅ ✅ ❌
Auth not enforced Partial ✅ ✅ ignored_auth
BOLA (user A reads user B's data) Manual ✅ 2+ profiles ✅ 2+ peers
BFLA (member calls admin function) Manual ✅ ❌ no dedicated check
Invalid input accepted ❌ ❌ ✅
Response doesn't match the spec ❌ ❌ ✅
Endpoints missing from the spec Only if crawled Only if discovered ❌

How I'd choose

  • No budget, want broad vulnerability coverage: ZAP's API scan in CI against staging. Expect to spend time tuning rules and setting up authentication.
  • No budget, want API-specific bugs and authorization checks: Schemathesis. Configure two users for the object-level authorization check; that one check is worth the setup.
  • Many services and teams, want authorization testing without scripting, budget for tooling: StackHawk. Use the 14-day trial on one service with two real test users before deciding.
  • Best free combination: Schemathesis and ZAP. They find mostly different things, and both are free.

The part none of them cover

All three are dynamic: they send requests to a running environment. That leaves two gaps:

  1. Changes before they deploy. A PR that removes security from an endpoint or adds client_secret to a response is visible in the spec diff before anything runs. A DAST only finds it after deployment to staging, and only if the scan covers that endpoint.
  2. Endpoints that aren't in the spec. Every tool above is driven by the spec or by crawling. An old /v1 route still serving traffic, or /actuator/env answering 200, can sit outside both.

This is the gap SpecShield covers, statically. specshield gate --security blocks the PR that weakens auth. specshield audit --logs compares your access logs with the spec to find undocumented endpoints, old versions still answering, and exposed files like /.env. It sends no requests, so it can't confirm a vulnerability the way a DAST can. It complements these tools; it doesn't replace them.


Running one of these in CI? I'd like to know which findings were real and which were noise — especially for BOLA testing, which is where these tools differ the most.

Top comments (0)