Pre-Beta Pre-beta signups are open now. The full audytx engine is live for pre-beta. Everything free today stays free — paid tiers arrive Sep 01, 2026 from $20/month for unlimited repositories.
MCP Server · code-time
① Code-time ② Review-time ③ Plan-time

Your coding agent's Terraform security check
before the PR exists

A free hosted MCP server: grab a Client ID, point Claude Code or Cursor at the endpoint, and scan AWS Terraform the moment your agent writes it — IAM attack paths, misconfigurations, cost risks. The agent that wrote the code gets the verdict from a deterministic, non-AI engine that returns identical findings for identical input, every time.

claude mcp add --transport http audytx https://audytx.com/mcp --header "X-Client-ID: YOUR_CLIENT_ID"
Or add manually: url = "https://audytx.com/mcp" · header X-Client-ID (or standard Authorization: Bearer YOUR_CLIENT_ID if your client or gateway prefers it)
This URL is dual-purpose: GET it for these docs, POST JSON-RPC 2.0 to the same URL for the MCP API (a GET to the API path returns 405).
Free: create a Client ID · 500 calls/month · no credit card
Claude Code Cursor VS Code JetBrains Claude Desktop Windsurf Any MCP client
Connect in one step

Set up your MCP client

One endpoint, two accepted credentials: the X-Client-ID header or standard Authorization: Bearer <client-id>. Create a free Client ID first.

Claude Code one command
claude mcp add --transport http audytx https://audytx.com/mcp \
  --header "X-Client-ID: YOUR_CLIENT_ID"
Cursor .cursor/mcp.json

Project-level .cursor/mcp.json (or ~/.cursor/mcp.json globally). Cursor interpolates ${env:…} so the ID can live in your environment instead of the file:

{
  "mcpServers": {
    "audytx": {
      "url": "https://audytx.com/mcp",
      "headers": { "X-Client-ID": "${env:AUDYTX_CLIENT_ID}" }
    }
  }
}
VS Code .vscode/mcp.json

VS Code prompts once for the Client ID and stores it as a secret — it never sits in the file:

{
  "inputs": [
    {
      "type": "promptString",
      "id": "audytx-client-id",
      "description": "audytx Client ID (from audytx.com/dashboard)",
      "password": true
    }
  ],
  "servers": {
    "audytx": {
      "type": "http",
      "url": "https://audytx.com/mcp",
      "headers": { "X-Client-ID": "${input:audytx-client-id}" }
    }
  }
}
JetBrains IDEs AI Assistant → MCP

JetBrains AI Assistant's remote-server config is URL-only (no custom headers), so connect through the mcp-remote stdio proxy. In Settings | Tools | AI Assistant | Model Context Protocol (MCP), add a server as JSON:

{
  "mcpServers": {
    "audytx": {
      "command": "npx",
      "args": [
        "mcp-remote", "https://audytx.com/mcp",
        "--header", "X-Client-ID:${AUDYTX_CLIENT_ID}"
      ],
      "env": { "AUDYTX_CLIENT_ID": "YOUR_CLIENT_ID" }
    }
  }
}

No space after the colon in X-Client-ID:${…} — some clients split header args on spaces (a documented mcp-remote workaround).

Claude Desktop claude_desktop_config.json

Claude Desktop's native remote connectors require an OAuth sign-in flow, which audytx has staged (RFC 9728 metadata is live; the full authorization server is planned — see /mcp/security). Until then, the same mcp-remote proxy works today in Settings → Developer → Edit Config:

{
  "mcpServers": {
    "audytx": {
      "command": "npx",
      "args": [
        "mcp-remote", "https://audytx.com/mcp",
        "--header", "X-Client-ID:${AUDYTX_CLIENT_ID}"
      ],
      "env": { "AUDYTX_CLIENT_ID": "YOUR_CLIENT_ID" }
    }
  }
}
Windsurf / any MCP client ~/.codeium/windsurf/mcp_config.json

Step 0: create your Client ID at /dashboard — the UUID is shown once, so copy it then.

Windsurf reads ~/.codeium/windsurf/mcp_config.json. Add audytx as a remote server (Windsurf uses serverUrl for HTTP servers):

{
  "mcpServers": {
    "audytx": {
      "serverUrl": "https://audytx.com/mcp",
      "headers": { "X-Client-ID": "YOUR_CLIENT_ID" }
    }
  }
}

Verify: reload Windsurf's MCP servers, then ask your agent to list the audytx tools, or POST tools/list to the endpoint (discovery needs no auth).

Any other client that can reach a Streamable-HTTP server works too: point it at https://audytx.com/mcp and send the Client ID as either the X-Client-ID header or Authorization: Bearer YOUR_CLIENT_ID. Clients that only speak stdio can bridge with npx mcp-remote as in the JetBrains example above.

JSON-RPC 2.0 over HTTP

Call it with curl

Discovery is open; tools/call needs your X-Client-ID.

POST https://audytx.com/mcp · Streamable-HTTP

tools/call — scan_terraform (with your Client ID)

curl -sS https://audytx.com/mcp \
  -H "Content-Type: application/json" \
  -H "X-Client-ID: YOUR_CLIENT_ID" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/call",
    "params": {
      "name": "scan_terraform",
      "arguments": {
        "files": [
          { "path": "main.tf", "content": "resource \"aws_s3_bucket\" \"b\" { bucket = \"example\" }" },
          { "path": "iam.tf",  "content": "resource \"aws_iam_role\" \"r\" { assume_role_policy = \"{}\" }" }
        ]
      }
    }
  }'

tools/list — discovery (no auth)

curl -sS https://audytx.com/mcp \
  -H "Content-Type: application/json" \
  -d '{ "jsonrpc": "2.0", "id": 1, "method": "tools/list" }'

Discovery methods (initialize, tools/list, ping) need no auth; tools/call requires the X-Client-ID header.

Seven tools · one endpoint

MCP tools

A scan-fix-explain loop for your agent, plus a context-graph view and a flagged cost sampler. The full input/output reference is below the grid.

scan_terraform

Findings with file/line evidence and fixes — plus the false positives context suppressed, each with a rationale.

scan_cloudformation

The CFN twin of scan_terraform — same findings, same rule ids, for JSON/YAML templates, SAM, and cdk.out.

autofix_terraform

Applies only sound, line-anchored fixes and re-scans, up to three passes — optionally opening a PR.

dry_run_autofix

A unified diff per file showing exactly what autofix would change — nothing modified.

explain_finding

Full context for a rule ID: what it verifies, why it matters, MITRE ATT&CK mapping, and the fix.

get_context_graph

The relationship graph — resources, edges, and every suppression with its reason.

cost_sampler · flagged

Dollar-ranged AWS savings opportunities with Terraform remediation. Gated by a server flag.

scan_terraform Core

Scan AWS Terraform for security misconfigurations, IAM privilege-escalation paths, cross-resource attack paths, and cost risks. Returns findings with file/line evidence and fix snippets, plus the findings audytx suppressed as false positives — each with its rationale.

Inputs

  • files required Array of {path, content} — all .tf and .tfvars files. Cross-resource reasoning needs the full set.
  • plan optional Output of terraform show -json. Resolves final values and module-internal resources.
  • baseline optional Contents of your .audytx-baseline.yaml — applies the same user-authored suppressions the GitHub PR check does, so local findings match the PR gate.

Returns

  • findings[] Active findings with severity, file, line, message, fix snippet
  • suppressed[] Context-suppressed findings with rationale
  • summary Counts by severity
  • compliance_coverage[] Controls touched per framework (SOC 2, PCI-DSS, HIPAA, CIS AWS) — advisory signal, not attestation
scan_cloudformation Core

Scan AWS CloudFormation templates — JSON or YAML, including SAM and cdk.out-synthesized templates — for the same misconfigurations, IAM privilege-escalation paths, cross-resource attack paths, and cost risks scan_terraform finds. Findings reuse the SAME AWS_* rule ids, since the engine normalizes CloudFormation into the same resource vocabulary before evaluating.

Inputs

  • files required Array of {path, content} — all CFN/SAM/cdk.out templates of the stack or app, paths ending .json/.yaml/.yml/.template. Cross-resource reasoning needs the full set.
  • baseline optional Contents of your .audytx-baseline.yaml — same semantics as scan_terraform's.

Returns

  • findings[] Active findings with severity, file, line, message, fix snippet
  • suppressed[] Context-suppressed findings with rationale
  • summary Counts by severity
  • compliance_coverage[] Controls touched per framework (SOC 2, PCI-DSS, HIPAA, CIS AWS) — advisory signal, not attestation
autofix_terraform Fix

Apply audytx's sound one-click fixes and re-scan, looping until no auto-applicable findings remain (max 3 passes). Only precisely line-anchored fixes are applied — never a corrupting edit — and it returns the fixed files, what was fixed, and what remains for you.

Inputs

  • files required Array of {path, content}
  • github_token optional Use a fine-grained personal access token scoped to only the target repository, with the two repository permissions this flow needs: Contents: write (the git blob/tree/commit/ref calls) and Pull requests: write (opening the PR). With repo, audytx commits the fixes to a new branch and opens a pull request. The token is shape-validated, used solely for this one request's GitHub API calls against the repo you name, and never logged or stored.
  • repo optional owner/repo — required when github_token is provided. Strictly validated; every GitHub API call the token makes is confined to this repository.
  • base_branch optional Branch to target for the PR. Defaults to main.
  • baseline optional Contents of your .audytx-baseline.yaml — findings you suppressed there are neither auto-fixed nor reported as remaining.
  • only optional List of rule ids, e.g. ["AWS_RDS_001"]. Restricts the fix loop to those rules so you can accept one reviewed fix at a time; everything else is left untouched and reported as remaining. An empty list applies nothing.

Returns

  • files[] Fixed file contents
  • applied[] Which findings were auto-fixed
  • remaining[] Findings needing manual action
  • only_unknown_ids[] Entries of only naming a rule this scan did not produce — reported, never silently ignored (present only when you pass only)
  • pr_url URL of the opened pull request (only when github_token + repo are supplied)
dry_run_autofix Preview

Preview what autofix_terraform would do: a unified diff per file showing the exact line changes, with nothing modified. Review the diffs, confirm, then apply.

Inputs

  • files required Array of {path, content}
  • only optional List of rule ids — preview just those fixes, so the diff you review is the diff you will apply. Same semantics as autofix_terraform's.

Returns

  • diffs[] Unified diff per file
  • would_fix[] Which findings would be addressed
  • only_unknown_ids[] Entries of only naming a rule this scan did not produce (present only when you pass only)
explain_finding Info

Return structured explanation and remediation for a catalog rule ID (e.g. AWS_IAM_020): what the check verifies, why it matters, MITRE ATT&CK mapping, and how to fix it. Cross-resource skill findings (AWS_XREF_*, AWS_IAM_ATTACK_PATH_*) are explained inline in the scan result, not here.

Inputs

  • rule_id required e.g. "AWS_IAM_020"

Returns

  • title Check title and severity
  • description Full explanation
  • remediation Step-by-step fix guidance
get_context_graph Graph

Return the cross-resource relationship graph audytx computed: resources, edges (invocation, runs_as, dlq, network), and the findings the context layer suppressed with their rationale. Use it to understand why audytx suppressed a finding before you accept the suppression.

Inputs

  • files required Array of {path, content}

Returns

  • resources[] All parsed resources and their relationships
  • edges[] Graph edges with relationship type
  • suppressed[] Context-suppressed findings with rationale
cost_sampler Cost · flagged

Estimate monthly and annual AWS cost-savings opportunities: storage tiering (gp2→gp3, S3 lifecycle), non-prod right-sizing, NAT Gateway vs VPC endpoints, over-provisioned RDS/DynamoDB, and missing cost-allocation tags — each with a dollar range and Terraform remediation. Rollout-flagged: gated by a server flag, so it appears in tools/list only when active. See the cost sampler page.

Inputs

  • files required Array of {path, content} — all .tf and .tfvars files.
  • plan optional Output of terraform show -json to resolve variable/count/module values.

Returns

  • findings[] Cost-savings opportunities, each with a dollar range and Terraform remediation
  • total_savings Combined estimate (us-east-1 on-demand list pricing — opportunities, not your total bill)
prompts & resources Open

Beyond tools, the server implements the MCP prompts and resources primitives (spec 2025-06-18) — no Client ID needed, since they serve public catalog data so AI-generated Terraform comes out right the first time.

Prompts

  • secure-review Scan → triage with suppression rationales → explain → autofix → re-scan
  • pre-commit-gate A commit verdict on staged changes against a severity threshold — audytx returns the verdict, your agent enforces it

Resources

  • audytx://rules-catalog The full catalog of declarative checks
  • audytx://context-axes The cross-resource suppression axes
  • audytx://baseline-format The .audytx-baseline.yaml contract
Write → scan → fix

A typical coding-agent workflow

Step 1
Write Terraform
Your agent generates or modifies .tf files: IAM roles, Lambda functions, S3 buckets, API Gateway stages.
Step 2
Scan for issues
Pass all .tf files. Get findings with file/line evidence, severity, fix snippets — and suppressed false positives with rationale so the agent knows what was checked.
scan_terraform
Step 3
Apply sound fixes
Auto-apply precisely anchored fixes in up to 3 re-scan passes. What remains calls for architectural decisions, so review those yourself.
dry_run_autofix → autofix_terraform
Copy-paste starters

Example agent prompts

Before committing Terraform
"Before creating a PR, call audytx scan_terraform on all .tf files in this directory. Show me any High or Critical findings and apply the auto-fixable ones."
Understanding a suppressed finding
"Call audytx get_context_graph on these files. I want to understand why the DLQ finding was suppressed — is it because this Lambda is only invoked synchronously?"
Safe preview before applying
"Run audytx dry_run_autofix first and show me the diffs. If the changes look right, then run autofix_terraform to apply them."
Deep-dive on a finding
"The scan returned AWS_IAM_020. Call audytx explain_finding with that rule ID so I understand the exact privilege-escalation path before I change the IAM policy."
Safe to hand your agents

An agent tool your security team can say yes to

Read-only, stateless, and deterministic — it reviews, keeps nothing, and never guesses.

It reviews, never deploys

audytx returns findings and diffs for a human or pipeline to apply — no access to your cloud or repo, and it can't change a thing.

Keeps no copy of your code

Every call is independent: your Terraform is parsed in memory and discarded in the same request. What persists is quota metering, never content.

Deterministic, not a model

A hand-written Rust engine — explicit checks plus a relationship graph, no LLM in the loop. Every finding cites its exact check; no hallucinated vulnerabilities.

Evaluating for enterprise? See the full MCP security posture — mapped to the NSA MCP guidance + OWASP MCP Top 10, with the SSRF-audit verdict.

Open beta

Start free during the open beta

Create a Client ID, point your agent at the endpoint, and read the verdict on the Terraform it just wrote. Free for every team — and the free tier is here to stay.

Agent-first? Create a free Client ID — quotas are on the pricing page.

📊

What AI-generated Terraform gets wrong

We asked a frontier model to write Terraform for 50 realistic AWS scenarios, then measured every output. The failures are consistent: invented argument names that fail terraform validate, and a cross-resource gap (companion resources missing, secrets created but never wired for rotation) — exactly the class a relationship graph catches. Read the study →

Rate limits & pricing

Free, no credit card

Limits reset on the first of each month (UTC). Enterprise limits are available; get in touch. Full details at /pricing.

100
scans per account, per month — MCP, GitHub and run-task share one pool
$0
Free Client ID · 30s signup · no credit card
10 MB
Max payload per call (up to 1000 files)
Common questions

MCP server FAQ

How do I scan Terraform from Claude Code?

Add the server once with claude mcp add --transport http audytx https://audytx.com/mcp --header "X-Client-ID: YOUR_CLIENT_ID", using a free Client ID from your dashboard. Then ask Claude Code to run scan_terraform on your .tf files. You get findings with file and line anchors, severity, fix snippets, and the false positives audytx suppressed with rationale.

Is the audytx MCP server safe to give my coding agent?

Yes. It is read-only: audytx returns findings and diffs for you or your pipeline to apply, and never touches your cloud or repository. Every call is stateless — your Terraform is parsed in memory and discarded in the same request, with nothing stored. The engine is deterministic Rust, so there are no hallucinated findings.

What does the audytx MCP server cost?

It is free. A Client ID takes about 30 seconds to create, needs no credit card, and includes 100 scans per account each month across all your Client IDs. Every surface draws on the same pool — an MCP call, a pull request, or a run task each cost one scan. Free refills on the first of the month, UTC. Paid tiers open Sep 01, 2026; enterprise limits are available on request.

Stage ① of 3 · code-time

The same engine also reviews the pull request (review-time) and the terraform plan before apply (plan-time). See the whole delivery layer →