# 🔧 ADA Website Fix-It Report — Remediation Plan (`upstanding_biobot/ada-remediation-report`) Actor

Turn accessibility scan results into developer-ready remediation reports. Plain-English explanations, AI code fixes, cost estimates, fix-by timeline, competitor benchmarking. $5/page, no subscription.

- **URL**: https://apify.com/upstanding\_biobot/ada-remediation-report.md
- **Developed by:** [Alexander Maksimchuk](https://apify.com/upstanding_biobot) (community)
- **Categories:** Developer tools, SEO tools, Open source
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$250.00 / 1,000 remediation reports

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## 🔧 ADA Website Fix-It Report

Turn accessibility scan results into developer-ready remediation reports. Every violation gets a plain-English explanation, AI-generated code fix, cost estimate, and recommended fix-by timeline. Includes competitor benchmarking and markdown export — everything agencies need to sell remediation and developers need to execute fixes.

### 📋 Table of Contents

- [What is this?](#-what-is-this)
- [How to use](#-how-to-use)
- [Input](#-input)
- [Output](#-output)
- [JSON output example](#-json-output-example)
- [How much does it cost?](#-how-much-does-it-cost)
- [Use cases](#-use-cases)
- [Integrations](#-integrations)
- [Is it legal?](#-is-it-legal)
- [Troubleshooting](#-troubleshooting)
- [FAQ](#-faq)
- [Tech stack](#-tech-stack)
- [Feedback & issues](#-feedback--issues)

### 🤔 What is this?

ADA Website Fix-It Report takes raw accessibility scan data and transforms it into actionable, developer-ready remediation documentation. Instead of handing developers a list of rule IDs, this Actor translates each violation into plain English ("Text is too hard to read against its background color"), generates a working code snippet to fix it, estimates labor hours and dollar costs, and sets a recommended fix-by timeline based on severity.

It also scans competitor websites and includes a benchmark comparison in the report — so agencies can show prospects exactly where they stand vs their competitors. Output in JSON, markdown, or both.

**Perfect for:** agencies pitching remediation services, dev teams receiving actionable fix tickets, and compliance officers documenting remediation timelines.

### 🚀 How to use

#### Step 1: Provide URLs or scan results

You have two options:

**Option A — Scan + Report (all-in-one):**

```json
{
  "startUrls": [{ "url": "https://example.com" }]
}
```

The Actor scans each URL with axe-core, then generates the full remediation report.

**Option B — Report from existing scan:**

```json
{
  "scanResult": [<dataset items from ADA Scanner Actor>]
}
```

Skip re-scanning by feeding results from our companion Actor: [ADA Website Compliance Checker](https://apify.com/upstanding_biobot/ada-wcag-compliance-scan).

#### Step 2: Add competitors (optional)

```json
{
  "startUrls": [{ "url": "https://yoursite.com" }],
  "competitorUrls": [
    { "url": "https://competitor1.com" },
    { "url": "https://competitor2.com" }
  ]
}
```

The Actor scans competitor sites and includes a benchmark comparison table in the report.

#### Step 3: Choose output format

| `reportFormat` | Output |
|----------------|--------|
| `json` | Structured JSON in dataset + key-value store (default) |
| `markdown` | Human-readable markdown report in key-value store |
| `both` | JSON + markdown |

#### Step 4: Run + export

Click **Start**. Results appear in:

- **Dataset** — Per-page remediation items (push individually)
- **Key-value store** — `OUTPUT` key with aggregated report + markdown

#### Quick start (API)

```json
{
  "startUrls": [{ "url": "https://example.com" }],
  "competitorUrls": [{ "url": "https://competitor.com" }],
  "reportFormat": "both"
}
```

### 📥 Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `startUrls` | array | — | URLs to scan + report. Format: `[{ "url": "https://..." }]` |
| `scanResult` | array | — | Pre-existing scan results JSON (from Scanner Actor). Skips re-scanning. |
| `competitorUrls` | array | — | Optional competitor URLs for benchmark comparison |
| `reportFormat` | string | `json` | Output format: `json`, `markdown`, or `both` |
| `llmModel` | string | `auto` | LLM model for code snippet generation |

> **Note:** Provide either `startUrls` or `scanResult` — not both. If `scanResult` is provided, the Actor skips scanning and goes straight to report generation.

### 📤 Output

#### Per-page remediation (dataset)

Each scanned page produces a remediation report pushed to the dataset:

| Field | Type | Description |
|-------|------|-------------|
| `url` | string | Page URL |
| `pageTitle` | string | Page title |
| `scanDate` | string | ISO 8601 scan timestamp |
| `remediationSummary` | object | Total cost (low/high), hours, violations by severity, grade, risk, fix-by date |
| `remediationItems` | array | Each violation with plain English, code snippet, cost, hours, help URL |
| `itemsByPriority` | object | Items grouped: critical, serious, moderate, minor |

#### Per-violation item

| Field | Type | Description |
|-------|------|-------------|
| `ruleId` | string | axe-core rule ID (e.g., `color-contrast`) |
| `impact` | string | Severity: critical, serious, moderate, minor |
| `plainEnglish` | string | Human-readable description (e.g., "Text is too hard to read against its background color") |
| `technicalDescription` | string | axe-core's technical description |
| `affectedElements` | integer | Number of elements affected |
| `codeSnippet` | string | AI-generated code fix (HTML/CSS) |
| `costLow` | number | Estimated cost — low end (USD) |
| `costHigh` | number | Estimated cost — high end (USD) |
| `estimatedHours` | number | Estimated labor hours |
| `helpUrl` | string | Link to Deque's remediation guide |
| `examples` | array | Up to 3 affected elements with CSS selector, HTML snippet, failure summary |

#### Aggregated output (key-value store)

| Field | Type | Description |
|-------|------|-------------|
| `reportDate` | string | Report generation timestamp |
| `totalPages` | integer | Pages scanned |
| `totalCostLow` | number | Total estimated cost — low end |
| `totalCostHigh` | number | Total estimated cost — high end |
| `totalHours` | number | Total estimated labor hours |
| `overallGrade` | string | Overall compliance grade (A–F) |
| `overallRisk` | string | Overall lawsuit risk level |
| `recommendedFixBy` | string | Date by which critical issues should be addressed |
| `reports` | array | Per-page remediation reports |
| `competitors` | array | Competitor benchmark results (if provided) |
| `markdownReport` | string | Full markdown report (if `reportFormat` includes markdown) |

### 📄 JSON output example

Here's real output from scanning `example.com` (clean site) and a fictional broken site:

#### Clean site result

```json
{
  "url": "https://example.com",
  "pageTitle": "Example Domain",
  "scanDate": "2026-07-04T02:15:33.841Z",
  "remediationSummary": {
    "totalCostLow": 0,
    "totalCostHigh": 0,
    "totalHours": 0,
    "criticalCount": 0,
    "seriousCount": 0,
    "moderateCount": 0,
    "minorCount": 0,
    "recommendedFixBy": "2026-10-02",
    "grade": "A",
    "lawsuitRisk": "Low",
    "complianceScore": 100
  },
  "remediationItems": [],
  "itemsByPriority": {
    "critical": [],
    "serious": [],
    "moderate": [],
    "minor": []
  }
}
```

#### Site with violations

```json
{
  "url": "https://broken-site.example",
  "pageTitle": "ACME Corp — Home",
  "scanDate": "2026-07-04T02:20:15.123Z",
  "remediationSummary": {
    "totalCostLow": 88,
    "totalCostHigh": 185,
    "totalHours": 2.8,
    "criticalCount": 1,
    "seriousCount": 2,
    "moderateCount": 1,
    "minorCount": 0,
    "recommendedFixBy": "2026-07-18",
    "grade": "D",
    "lawsuitRisk": "High",
    "complianceScore": 62
  },
  "remediationItems": [
    {
      "ruleId": "html-has-lang",
      "impact": "serious",
      "plainEnglish": "Page is missing language declaration (needed for screen readers)",
      "technicalDescription": "Ensures every HTML document has a lang attribute",
      "affectedElements": 1,
      "codeSnippet": "<html lang=\"en\">",
      "costLow": 5,
      "costHigh": 10,
      "estimatedHours": 0.1,
      "helpUrl": "https://dequeuniversity.com/rules/axe/html-has-lang",
      "examples": [
        {
          "target": ["html"],
          "html": "<html>",
          "failureSummary": "Fix any of the following:\n  The <html> element does not have a lang attribute"
        }
      ]
    },
    {
      "ruleId": "image-alt",
      "impact": "critical",
      "plainEnglish": "Images are missing text descriptions for screen reader users",
      "technicalDescription": "Ensures <img> elements have alternate text or a role of none or presentation",
      "affectedElements": 2,
      "codeSnippet": "<!-- Add alt text to images -->\n<img src=\"/logo.png\" alt=\"ACME Corp logo\">",
      "costLow": 16,
      "costHigh": 30,
      "estimatedHours": 0.4,
      "helpUrl": "https://dequeuniversity.com/rules/axe/image-alt",
      "examples": [
        {
          "target": ["img.hero-logo"],
          "html": "<img src=\"/logo.png\" class=\"hero-logo\">",
          "failureSummary": "Fix any of the following:\n  Element does not have an alt attribute"
        }
      ]
    },
    {
      "ruleId": "color-contrast",
      "impact": "serious",
      "plainEnglish": "Text is too hard to read against its background color",
      "technicalDescription": "Ensures the contrast between foreground and background colors meets WCAG 2 AA contrast ratio thresholds",
      "affectedElements": 1,
      "codeSnippet": "/* Increase contrast: minimum 4.5:1 for normal text */\n.cta-button {\n  color: #595959 !important;\n}",
      "costLow": 15,
      "costHigh": 30,
      "estimatedHours": 0.5,
      "helpUrl": "https://dequeuniversity.com/rules/axe/color-contrast",
      "examples": [
        {
          "target": [".cta-button"],
          "html": "<a href=\"/contact\" class=\"cta-button\">Contact Us</a>",
          "failureSummary": "Fix any of the following:\n  Element has insufficient color contrast of 2.8:1"
        }
      ]
    },
    {
      "ruleId": "label",
      "impact": "moderate",
      "plainEnglish": "Form fields are missing descriptive labels",
      "technicalDescription": "Ensures every form element has a label",
      "affectedElements": 1,
      "codeSnippet": "<label for=\"input-id\">Field label</label>\n<input id=\"input-id\" type=\"text\" name=\"field\">",
      "costLow": 20,
      "costHigh": 40,
      "estimatedHours": 0.5,
      "helpUrl": "https://dequeuniversity.com/rules/axe/label",
      "examples": [
        {
          "target": ["#newsletter-email"],
          "html": "<input type=\"email\" id=\"newsletter-email\" placeholder=\"Email\">",
          "failureSummary": "Fix any of the following:\n  Form element does not have an explicit label"
        }
      ]
    }
  ],
  "itemsByPriority": {
    "critical": [{ "ruleId": "image-alt", "..." : "..." }],
    "serious": [
      { "ruleId": "html-has-lang", "..." : "..." },
      { "ruleId": "color-contrast", "..." : "..." }
    ],
    "moderate": [{ "ruleId": "label", "..." : "..." }],
    "minor": []
  }
}
```

#### Competitor benchmark (when `competitorUrls` provided)

```json
{
  "competitors": [
    {
      "url": "https://competitor1.com",
      "pageTitle": "Competitor 1 — Home",
      "score": 85,
      "grade": "B",
      "risk": "Low",
      "totalViolations": 2,
      "critical": 0,
      "serious": 1
    },
    {
      "url": "https://competitor2.com",
      "pageTitle": "Competitor 2 — Home",
      "score": 45,
      "grade": "F",
      "risk": "High",
      "totalViolations": 8,
      "critical": 2,
      "serious": 3
    }
  ]
}
```

### 💰 How much does it cost?

**$5 per page report.** Includes axe-core scan + AI-generated code snippets + cost estimation + competitor benchmarking. No subscription needed.

#### Cost examples

| Use case | Pages | Competitors | Cost |
|----------|-------|-------------|------|
| Single page report | 1 | 0 | $5 |
| Full page report + 2 competitors | 1 | 2 | $5 (competitor scans included) |
| 5-page website audit | 5 | 0 | $25 |
| Agency pitch (prospect + 3 competitors) | 1 | 3 | $5 |
| Client portfolio (10 sites × 1 page) | 10 | 0 | $50 |
| Full website remediation plan (20 pages) | 20 | 0 | $100 |

> **Money-saving tip:** Run our free [ADA Scanner](https://apify.com/upstanding_biobot/ada-wcag-compliance-scan) first to identify sites with violations. Only run this report on sites that need remediation. Feed scanner results via `scanResult` input to skip re-scanning and save on compute.

### 🎯 Use cases

- **Agency pitch tool** — Scan prospect site, generate report showing violations + cost + fix timeline. Hands the prospect a ready-made remediation proposal
- **Developer handoff** — Code snippets + cost estimates give developers everything needed to start fixing. No guessing what "accessible" means
- **Compliance documentation** — Generate reports with fix-by dates for legal teams, insurance, and audit trails
- **Portfolio scoring** — Bulk scan client sites, rank by compliance score, prioritize remediation budget
- **Competitive analysis** — Show prospects where they rank vs competitors on accessibility. "Your site is Grade D, your competitor is Grade B — here's what they're doing right"
- **Pre-litigation assessment** — Document known violations + remediation timeline. Shows good-faith compliance efforts

### 🔗 Integrations

#### Chain with ADA Scanner

Feed scanner results directly into this Actor to skip re-scanning:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

## Step 1: Scan
scan_run = client.actor("upstanding_biobot/ada-wcag-compliance-scan").call(run_input={
    "startUrls": [{"url": "https://example.com"}]
})
scan_results = client.dataset(scan_run["defaultDatasetId"]).list_items().items

## Step 2: Generate report (no re-scan needed)
report_run = client.actor("upstanding_biobot/ada-remediation-report").call(run_input={
    "scanResult": scan_results,
    "reportFormat": "both"
})
report = client.key_value_store(report_run["defaultKeyValueStoreId"]).get_record("OUTPUT")
```

#### AI agents (MCP)

Both Actors work with the **Apify MCP server** (`https://mcp.apify.com`). AI agents can chain scanner → report autonomously:

```
User: "Check example.com for accessibility issues and give me a fix plan"
Agent: [runs scanner] → [feeds results to report Actor] → [returns markdown report]
```

#### Automation platforms

- **Zapier** — New scan result → trigger report Actor → email PDF to client
- **Make (Integromat)** — Schedule weekly accessibility monitoring → generate report → post to Slack
- **Custom webhooks** — Apify webhooks trigger downstream processing on report completion
- **LangChain/LlamaIndex** — Feed report data to LLMs for automated fix prioritization

### ⚖️ Is it legal?

**Yes.** This Actor performs automated accessibility scans on public web pages and generates reports based on those scans. It uses axe-core (open-source, MPL 2.0) — the same engine used by accessibility auditors worldwide.

- **What it does:** Loads public web pages, runs WCAG rules, generates remediation guidance
- **What it doesn't do:** It does not modify, hack, or breach any website
- **ADA context:** ADA Title III lawsuits related to website accessibility have surged — over 4,500 filed in 2023 alone. Automated accessibility testing is a recognized best practice for documenting compliance efforts. Having scan results + remediation timeline demonstrates good-faith effort
- **Cost estimates:** Labor hours and dollar ranges are based on industry averages for front-end developer work. Actual costs vary by developer, region, and project complexity
- **Not legal advice:** This report does not constitute legal advice or guarantee legal compliance. Consult an ADA attorney for legal assessment

### 🔧 Troubleshooting

| Problem | Cause | Fix |
|---------|-------|-----|
| **Empty report (0 items)** | Site had no violations, or scan found nothing | Check the `remediationSummary.grade` — if it's "A", the site is clean. If "F" with 0 items, the page didn't render |
| **"No startUrls or scanResult" error** | Neither input provided | Provide either `startUrls` or `scanResult` (from the Scanner Actor) |
| **Code snippets look generic** | LLM endpoint not configured or unreachable | Actor falls back to template snippets when LLM is unavailable. Check `llmModel` setting |
| **Competitor scan timeout** | Competitor site slow or blocking | Remove problematic competitor URL or try again |
| **Markdown report missing** | `reportFormat` not set to `markdown` or `both` | Set `reportFormat: "both"` to get JSON + markdown |
| **Duplicate violations scanned twice** | Provided both `startUrls` and `scanResult` | Use one or the other. If both provided, `scanResult` takes priority |

### ❓ FAQ

<details>
<summary><strong>What's the difference between this Actor and the ADA Scanner?</strong></summary>

The [ADA Scanner](https://apify.com/upstanding_biobot/ada-wcag-compliance-scan) finds violations — it gives you raw axe-core results with rule IDs, CSS selectors, and severity. This Actor (Fix-It Report) transforms those results into actionable documentation: plain-English explanations, AI-generated code fixes, cost estimates, fix timelines, and competitor benchmarks. Scanner = diagnosis. Report = treatment plan.

Think of it as: Scanner tells you what's broken. Report tells you how to fix it, how much it costs, and when to do it by.

</details>

<details>
<summary><strong>How are cost estimates calculated?</strong></summary>

Each WCAG rule has a base cost (labor hours + dollar range) derived from industry averages for front-end remediation. The Actor multiplies the base cost by the number of affected elements. For example, fixing a `color-contrast` violation on 3 elements costs $45-$90 (3 × $15-$30 base). These are estimates — actual costs depend on your developer's rate, codebase complexity, and workflow.

</details>

<details>
<summary><strong>How are fix-by dates determined?</strong></summary>

Recommended fix-by dates are based on violation severity, not legal deadlines:

- **Critical** — 14 days from scan date
- **Serious** — 30 days
- **Moderate** — 90 days
- **Minor** — 180 days

These timelines reflect best practices for prioritizing accessibility fixes. They are not legal deadlines — no statute requires fixes within these timeframes. However, documented remediation timelines demonstrate good-faith compliance efforts.

</details>

<details>
<summary><strong>What LLM generates the code snippets?</strong></summary>

The Actor uses AI-powered code snippet generation for fast, accurate fix recommendations. If the LLM endpoint is unreachable, it falls back to deterministic template snippets for 50+ common violation types.

</details>

<details>
<summary><strong>Can I use my own scan results?</strong></summary>

Yes. If you've already run the [ADA Scanner](https://apify.com/upstanding_biobot/ada-wcag-compliance-scan) or any axe-core scan, pass the results via the `scanResult` input. The Actor skips re-scanning and generates the report from your existing data. This saves compute costs and time.

</details>

<details>
<summary><strong>Can I scan competitor sites?</strong></summary>

Yes. Add competitor URLs to the `competitorUrls` input. The Actor scans each competitor with axe-core and includes a benchmark comparison table in the report — showing each site's compliance score, grade, risk level, and violation counts. This is powerful for agency sales pitches: "Your site is Grade D with 12 violations. Your top competitor is Grade B with 3 violations. Here's what they're doing right and what you need to fix."

</details>

<details>
<summary><strong>What output formats are available?</strong></summary>

- **JSON** — Structured data in dataset + key-value store. Best for programmatic consumption
- **Markdown** — Human-readable report in key-value store. Best for sharing with clients, managers, or stakeholders
- **Both** — JSON for APIs + markdown for humans

</details>

<details>
<summary><strong>Do I need the Scanner Actor to use this?</strong></summary>

No. This Actor can scan independently — just provide `startUrls` and it runs axe-core internally. However, chaining Scanner → Report is more efficient for multi-site workflows: scan all sites first (cheaper), then report on the ones with violations.

</details>

### 🛠️ Tech stack

- **[axe-core](https://github.com/dequelabs/axe-core)** — Deque's WCAG testing engine (90+ rules)
- **[Playwright](https://playwright.dev/)** — Headless Chromium browser automation
- **AI code generation** — LLM-powered code snippet generation for remediation
- **[Apify SDK](https://docs.apify.com/sdk/js/)** — Platform integration, dataset, key-value store

### 🔧 Companion Actors

Complete your audit pipeline with these related tools:

| Actor | What it does | Price |
|-------|-------------|-------|
| [Website Health Check](https://apify.com/upstanding_biobot/website-health-check) | 9-in-1 audit: accessibility + security + SSL + broken links + SEO + performance | $3/URL |
| [ADA Compliance Checker](https://apify.com/upstanding_biobot/ada-wcag-compliance-scan) | Scan any website for WCAG violations. Feed results to this Actor via `scanResult` | $2/scan |
| [llms.txt Generator](https://apify.com/upstanding_biobot/llms-txt-generator) | Generate llms.txt + check AI bot access. Boost AI search visibility | FREE |
| [AI Citation Monitor](https://apify.com/upstanding_biobot/ai-citation-monitor) | Track brand mentions in AI search responses | $0.50/query |

#### Recommended workflow

1. **[Health Check](https://apify.com/upstanding_biobot/website-health-check)** — Run broad 9-check audit first ($3/URL)
2. **[ADA Scanner](https://apify.com/upstanding_biobot/ada-wcag-compliance-scan)** — Deep-dive accessibility violations ($2/scan)
3. **ADA Fix-It Report** (this Actor) — Generate developer-ready remediation plan ($5/page)
4. **[llms.txt Generator](https://apify.com/upstanding_biobot/llms-txt-generator)** — Ensure AI search engines can find your site (FREE)
5. **[AI Citation Monitor](https://apify.com/upstanding_biobot/ai-citation-monitor)** — Track whether AI models mention your brand ($0.50/query)

### 💬 Feedback & issues

Found a bug? Have a feature request? Want better cost estimates for your region?

- **Apify Console** — Use the **Issues** tab on this Actor's page
- **Review** — Leave a rating/review on the Actor's Store page
- **Direct** — We monitor all feedback through the Apify platform

***

*This Actor is not affiliated with Deque Systems. axe-core is an open-source project licensed under MPL 2.0. Cost estimates are based on industry averages and are not guaranteed.*

# Actor input Schema

## `startUrls` (type: `array`):

URLs to scan first (using built-in axe-core), then generate remediation report. Leave empty if providing scanResult directly.

## `scanResult` (type: `array`):

If you already ran ADA WCAG Compliance Scanner, paste the dataset JSON here. Each item should be a page-level scan result with violations array. If provided, startUrls is ignored.

## `competitorUrls` (type: `array`):

Optional: scan competitor sites and include comparison table in report.

## `reportFormat` (type: `string`):

Output format for remediation report.

## `llmModel` (type: `string`):

Model used for code snippet generation and plain English translation.

## `prioritizeByImpact` (type: `boolean`):

Rank violations by business impact (lawsuit risk + user impact + conversion blocking). Adds priorityScore + businessImpactReason fields. Re-orders items by priority instead of just severity.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://example.com"
    }
  ],
  "reportFormat": "json",
  "llmModel": "auto",
  "prioritizeByImpact": false
}
```

# Actor output Schema

## `report` (type: `string`):

No description

## `summary` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://example.com"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("upstanding_biobot/ada-remediation-report").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "startUrls": [{ "url": "https://example.com" }] }

# Run the Actor and wait for it to finish
run = client.actor("upstanding_biobot/ada-remediation-report").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://example.com"
    }
  ]
}' |
apify call upstanding_biobot/ada-remediation-report --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=upstanding_biobot/ada-remediation-report",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/EJWEVoBNj2tkobbHU/builds/dF2ojYJ69ZS8cRfLe/openapi.json