# EPSS Exploit Prediction Scoring System Scraper (`parseforge/epss-exploit-prediction-scraper`) Actor

Scrape EPSS (Exploit Prediction Scoring System) scores from FIRST.org. Returns the 30-day probability and percentile rank of CVE exploitation. Filter by CVE ID(s), date, history window, or minimum score.

- **URL**: https://apify.com/parseforge/epss-exploit-prediction-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Business, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $24.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/main/banners/banner-default.jpg?raw=true)

## 📈 EPSS Exploit Prediction Scraper

> 🚀 **Export FIRST.org EPSS exploit-prediction scores in seconds.** Pull the daily probability that a CVE will be exploited in the next 30 days, plus its global percentile rank, with optional historical time-series for trend analysis. No sign-up, no token, no manual ingestion.

> 🕒 **Last updated:** 2026-05-15 · **📊 8 fields** per record · **📈 240,000+ scored CVEs** · **🎯 Daily refresh** · **📅 Up to 730-day history**

The **EPSS Exploit Prediction Scraper** pulls scores from the FIRST.org Exploit Prediction Scoring System and returns **8 normalised fields per record**, including the CVE ID, the EPSS score (probability between 0 and 1 of exploitation in the next 30 days), the percentile rank against every other scored CVE, a derived severity band (Critical / High / Medium / Low), the score date, and an optional historical time series. EPSS is the de facto data-driven prioritisation signal used by mature security teams worldwide and is recommended by the U.S. federal vulnerability disclosure community as a complement to CVSS.

The system covers **240,000+ scored CVEs refreshed daily** and offers up to **730 days of historical scores per CVE** for trend tracking. This Actor makes that data downloadable as CSV, Excel, JSON, or XML in minutes. Filters apply at the source, so you skip pagination, rate-limit handling, and time-series flattening entirely.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Security teams, vulnerability managers, threat intel analysts, SOC engineers, risk modellers, security tool builders, ML researchers | EPSS-based patch prioritisation, risk scoring, vendor scorecards, CVE trend analysis, SIEM enrichment, ML features for vulnerability prediction |

---

### 📋 What the EPSS Exploit Prediction Scraper does

Several workflows in a single Actor:

- 📈 **Daily corpus export.** Pull every scored CVE for the latest available date.
- 🆔 **Single CVE score.** Look up one CVE by ID for a quick triage check.
- 📦 **Batch CVE scores.** Pass a comma-separated list of CVE IDs and get every score in one run.
- 📅 **Specific date.** Fetch scores for a historical date (YYYY-MM-DD).
- 🕰️ **Time-series window.** Return up to 730 days of historical scores per CVE for trend analysis.
- 🎚️ **Threshold filters.** Restrict to CVEs above a minimum EPSS score (e.g. ≥ 0.5) or above a percentile (e.g. top 5%).
- 📊 **Flatten time series.** Toggle to emit one row per (cve, date) for spreadsheets and SQL.

Each record includes the CVE identifier, the canonical detail URL, the EPSS probability, the percentile rank, a derived severity band, the score date, and an optional nested or flattened time series.

> 💡 **Why it matters:** CVSS tells you how bad a CVE could be in theory; EPSS tells you how likely it is to actually be exploited in the next 30 days. Combining the two is the modern standard for patch prioritisation. Building your own EPSS ingestion means handling pagination, daily refreshes, and the optional time-series shape. This Actor skips all of that and gives you a clean, downloadable dataset.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded EPSS dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>cveId</code></td><td>string</td><td><code>""</code></td><td>Single CVE or comma-separated list (e.g. <code>CVE-2021-44228,CVE-2023-50164</code>). Empty = full corpus.</td></tr>
<tr><td><code>date</code></td><td>YYYY-MM-DD</td><td><code>""</code></td><td>Score date. Empty = latest available.</td></tr>
<tr><td><code>daysBack</code></td><td>integer</td><td><code>null</code></td><td>Return up to N days of historical scores per CVE (max 730).</td></tr>
<tr><td><code>minEpssScore</code></td><td>string (float)</td><td><code>""</code></td><td>Threshold 0-1. Example: <code>0.5</code> = 50% probability of exploitation.</td></tr>
<tr><td><code>minPercentile</code></td><td>string (float)</td><td><code>""</code></td><td>Threshold 0-1. Example: <code>0.95</code> = top 5% of scored CVEs.</td></tr>
<tr><td><code>flattenTimeSeries</code></td><td>boolean</td><td><code>false</code></td><td>Output one row per (cve, date) instead of nested time series.</td></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
</tbody>
</table>

**Example: top 1% of CVEs by EPSS for the latest date.**

```json
{
    "minPercentile": "0.99",
    "maxItems": 500
}
````

**Example: 90-day history for the Log4Shell family, flattened.**

```json
{
    "cveId": "CVE-2021-44228,CVE-2021-45046,CVE-2021-45105",
    "daysBack": 90,
    "flattenTimeSeries": true
}
```

> ⚠️ **Good to Know:** EPSS scores are updated daily. A score of 0.95 means a 95% modelled probability of exploitation in the next 30 days. EPSS does not replace CVSS; the two answer different questions and work best together.

***

### 📊 Output

Each record contains **8 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🆔 `cve` | string | `"CVE-2021-44228"` |
| 🔗 `url` | string | `"https://www.first.org/epss/"` |
| 📈 `epss` | number | null | `0.97432` |
| 📊 `percentile` | number | null | `0.99987` |
| 🚦 `severity` | string | null | `"Critical"` |
| 📅 `date` | YYYY-MM-DD | `"2026-05-14"` |
| 🕰️ `timeSeries` | object\[] | null | `[{ "date": "2026-05-13", "epss": 0.974, "percentile": 0.99987 }, ...]` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-15T00:00:00.000Z"` |

#### 📦 Sample record

<details>
<summary><strong>🔥 Top-of-the-list: Log4Shell (CVE-2021-44228) with 30-day history</strong></summary>

```json
{
    "cve": "CVE-2021-44228",
    "url": "https://www.first.org/epss/",
    "epss": 0.97432,
    "percentile": 0.99987,
    "severity": "Critical",
    "date": "2026-05-14",
    "timeSeries": [
        { "date": "2026-05-13", "epss": 0.97412, "percentile": 0.99987 },
        { "date": "2026-05-12", "epss": 0.97365, "percentile": 0.99986 },
        { "date": "2026-05-11", "epss": 0.97331, "percentile": 0.99985 }
    ],
    "scrapedAt": "2026-05-15T00:00:00.000Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 📈 | **Authoritative source.** Pulls directly from the FIRST.org EPSS catalogue, the de facto exploit-prediction model. |
| 🎯 | **Daily probabilities.** 30-day exploitation probability between 0 and 1, refreshed every day. |
| 📊 | **Percentile ranks.** Compare any CVE against every other scored entry in the corpus. |
| 🕰️ | **Up to 730 days of history.** Track score evolution over time for individual CVEs. |
| 🚦 | **Derived severity bands.** Critical / High / Medium / Low buckets ready for dashboards. |
| 📐 | **Flatten or nest.** Toggle between long-format (one row per cve+date) and wide-format outputs. |
| 🚫 | **No sign-up.** Works with public exploit-prediction data. No login or token needed. |

> 📊 EPSS is the modern data-driven complement to CVSS. Owning a clean local feed is a multiplier for every patch-management and risk-scoring workflow.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ EPSS Exploit Prediction Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **240,000+ scored CVEs** | **Daily** | CVE list, date, score, percentile | ⚡ 2 min |
| Commercial threat-intel feeds | $10,000+/year | Curated subset | Streaming | Many | ⏳ Days |
| Manual CSV dumps | Free | Full | Stale by next day | None | 🐢 Hours |
| Self-built ingestion | Engineering time | Full | Custom | Custom | 🛠️ Weeks |

Pick this Actor when you want EPSS scores ready to merge with your CVE inventory.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the EPSS Exploit Prediction Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick a CVE list, threshold, or date, then set `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor collect your data.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 🛡️ Vulnerability Management

- EPSS-aware patch prioritisation queues for IT and SOC
- Risk scores combining CVSS severity with EPSS probability
- Daily delta reports flagging CVEs whose EPSS rose sharply
- Tier-1 vs tier-2 ticket routing based on percentile thresholds

</td>
<td width="50%" valign="top">

#### 🔍 Threat Intelligence & Research

- Track EPSS climbers and fallers in near real time
- Build vendor risk scorecards based on average EPSS
- Map EPSS evolution against active campaigns and zero-days
- Correlate EPSS jumps with KEV additions and disclosures

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 🤖 Risk Modelling & ML

- Feature inputs for vulnerability-prediction ML models
- Backtest patch prioritisation policies against historical EPSS
- Train custom severity models on EPSS time series
- A/B-test patch SLAs against EPSS bucketing

</td>
<td width="50%" valign="top">

#### 📊 Executive Reporting

- Board dashboards mixing CVSS, EPSS, and KEV signals
- Insurance underwriting models incorporating exploit probability
- Customer-facing trust pages with EPSS-aware patch SLAs
- Quarterly risk-posture reports

</td>
</tr>
</table>

***

### 🔌 Automating EPSS Exploit Prediction Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify documentation](https://docs.apify.com/) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Daily refreshes line up perfectly with the EPSS publication cadence.

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- EPSS calibration and validation studies
- Joint CVSS + EPSS prioritisation research
- Coursework on quantitative vulnerability management
- Reproducible studies with cited, versioned dataset pulls

</td>
<td width="50%">

#### 🎨 Personal and creative

- Hobbyist EPSS dashboards for home-lab security research
- Newsletter research on the riskiest CVEs of the week
- Portfolio projects that show off security data engineering
- Personal alerting bots for vendors you actually use

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Local government IT teams tracking EPSS evolution
- Civic-tech projects mapping risk for critical infrastructure
- Investigative journalism on exploit-prediction trends
- Educational outreach for risk-based prioritisation

</td>
<td width="50%">

#### 🧪 Experimentation

- Train ML models that predict EPSS jumps
- Prototype agent pipelines that summarise EPSS climbers
- Test SIEM rules against historical EPSS waves
- Build dashboards on top of live EPSS feeds

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20EPSS%20Exploit%20Prediction%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20EPSS%20Exploit%20Prediction%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20EPSS%20Exploit%20Prediction%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20EPSS%20Exploit%20Prediction%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 What is EPSS?

EPSS (Exploit Prediction Scoring System) is a daily-updated model from FIRST.org that estimates the probability a CVE will be exploited in the wild in the next 30 days. It is the modern data-driven complement to CVSS.

#### 📈 What does the score mean?

The EPSS score is a probability between 0 and 1. A score of 0.95 means a 95% modelled probability of exploitation in the next 30 days. The percentile field tells you where the CVE ranks against every other scored entry.

#### 🔁 How often is the dataset refreshed?

EPSS publishes new scores every day. Every run reflects the corpus as of the latest available date.

#### 🚦 What are the severity bands?

The Actor derives a `Critical` / `High` / `Medium` / `Low` band from the EPSS score: > 0.95 is Critical, ≥ 0.5 is High, ≥ 0.1 is Medium, otherwise Low. The bands are convenience labels; raw scores remain in the dataset for custom thresholds.

#### 🕰️ How far back does the history go?

Up to 730 days per CVE via the `daysBack` input. The full historical corpus is available from the source with continuous coverage since the model went live.

#### 🆚 EPSS vs CVSS - which should I use?

Both. CVSS rates technical severity if a vulnerability is exploited; EPSS estimates the likelihood of exploitation. Mature programmes combine the two: a Critical CVSS with a high EPSS gets fast-tracked, while a Critical CVSS with a low EPSS can be patched on the regular cycle.

#### 🧮 Can I get one row per (cve, date) instead of nested time series?

Yes. Set `flattenTimeSeries: true` to emit one row per CVE per date. This is the most spreadsheet- and SQL-friendly shape for trend analysis.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to run this Actor on any cron interval. A daily schedule lines up with the EPSS publication cadence.

#### ⚖️ Is this data legal to use?

EPSS is published under permissive open licensing by FIRST.org. You should review the source license for your specific application but raw scores are public.

#### 💳 Do I need a paid Apify plan to use this Actor?

No. The free Apify plan is enough for testing and small runs (10 records per run). A paid plan lifts the limit and gives you scheduling, higher concurrency, and larger datasets.

#### 🆘 What if I need help?

Our support team is here to help. Contact us through the Apify platform or use the Tally form linked below.

***

### 🔌 Integrate with any app

EPSS Exploit Prediction Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get EPSS alerts in your security channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe EPSS data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes. Push fresh EPSS data into your ticketing system, or alert your team in Slack when a CVE jumps into the top percentile.

***

### 🔗 Recommended Actors

- [**🛡️ NIST NVD CVE Scraper**](https://apify.com/parseforge/nist-nvd-cve-scraper) - Official NVD catalogue with CVSS v4/v3/v2 scores
- [**🚨 CISA KEV Scraper**](https://apify.com/parseforge/cisa-kev-scraper) - Known Exploited Vulnerabilities catalogue with due dates
- [**🐙 GitHub Security Advisories Scraper**](https://apify.com/parseforge/github-security-advisories-scraper) - GHSA + CVE advisories with patched versions
- [**📦 OSV Vulnerabilities Scraper**](https://apify.com/parseforge/osv-vulnerabilities-scraper) - Open source vulnerabilities across 30+ ecosystems
- [**🔬 CIRCL CVE Scraper**](https://apify.com/parseforge/circl-cve-scraper) - CIRCL Luxembourg CVE catalogue with CWE and CAPEC

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more security and reference-data scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by FIRST.org or the EPSS Special Interest Group. All trademarks mentioned are the property of their respective owners. Only publicly available exploit-prediction data is collected.

# Actor input Schema

## `cveId` (type: `string`):

Single CVE or comma-separated list (e.g. 'CVE-2021-44228,CVE-2023-50164'). Leave empty to scrape the full daily corpus.

## `date` (type: `string`):

Fetch EPSS scores for this specific date (YYYY-MM-DD). Defaults to the latest available scores.

## `daysBack` (type: `integer`):

Return up to N days of historical scores per CVE. Use to track score evolution.

## `minEpssScore` (type: `string`):

Only include CVEs with EPSS >= this threshold (0.0 - 1.0). Example: 0.5 = 50% probability of exploitation in next 30 days.

## `minPercentile` (type: `string`):

Only include CVEs in the top percentile (0.0 - 1.0). Example: 0.95 = top 5%.

## `flattenTimeSeries` (type: `boolean`):

When daysBack is set, output one row per (cve, date) instead of nesting time-series inside each CVE. Easier for spreadsheets and SQL.

## `maxItems` (type: `integer`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "cveId": "",
  "date": "",
  "minEpssScore": "",
  "minPercentile": "",
  "flattenTimeSeries": false,
  "maxItems": 10
}
```

# Actor output Schema

## `overview` (type: `string`):

Overview of scraped data

## `fullData` (type: `string`):

Complete dataset

# 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 = {
    "cveId": "",
    "date": "",
    "minEpssScore": "",
    "minPercentile": "",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/epss-exploit-prediction-scraper").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 = {
    "cveId": "",
    "date": "",
    "minEpssScore": "",
    "minPercentile": "",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/epss-exploit-prediction-scraper").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 '{
  "cveId": "",
  "date": "",
  "minEpssScore": "",
  "minPercentile": "",
  "maxItems": 10
}' |
apify call parseforge/epss-exploit-prediction-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/epss-exploit-prediction-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "EPSS Exploit Prediction Scoring System Scraper",
        "description": "Scrape EPSS (Exploit Prediction Scoring System) scores from FIRST.org. Returns the 30-day probability and percentile rank of CVE exploitation. Filter by CVE ID(s), date, history window, or minimum score.",
        "version": "0.0",
        "x-build-id": "hxraNWCHY9oddVv2M"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~epss-exploit-prediction-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-epss-exploit-prediction-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~epss-exploit-prediction-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-epss-exploit-prediction-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~epss-exploit-prediction-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-epss-exploit-prediction-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "cveId": {
                        "title": "CVE ID(s)",
                        "type": "string",
                        "description": "Single CVE or comma-separated list (e.g. 'CVE-2021-44228,CVE-2023-50164'). Leave empty to scrape the full daily corpus.",
                        "default": ""
                    },
                    "date": {
                        "title": "Score Date",
                        "type": "string",
                        "description": "Fetch EPSS scores for this specific date (YYYY-MM-DD). Defaults to the latest available scores.",
                        "default": ""
                    },
                    "daysBack": {
                        "title": "History Window (days)",
                        "minimum": 1,
                        "maximum": 730,
                        "type": "integer",
                        "description": "Return up to N days of historical scores per CVE. Use to track score evolution."
                    },
                    "minEpssScore": {
                        "title": "Minimum EPSS Score",
                        "type": "string",
                        "description": "Only include CVEs with EPSS >= this threshold (0.0 - 1.0). Example: 0.5 = 50% probability of exploitation in next 30 days.",
                        "default": ""
                    },
                    "minPercentile": {
                        "title": "Minimum Percentile",
                        "type": "string",
                        "description": "Only include CVEs in the top percentile (0.0 - 1.0). Example: 0.95 = top 5%.",
                        "default": ""
                    },
                    "flattenTimeSeries": {
                        "title": "Flatten Time Series",
                        "type": "boolean",
                        "description": "When daysBack is set, output one row per (cve, date) instead of nesting time-series inside each CVE. Easier for spreadsheets and SQL.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
