---
license: cc-by-nc-4.0
task_categories:
  - tabular-classification
language:
  - en
tags:
  - synthetic
  - test-data
  - cybersecurity
  - network-traffic
  - intrusion-detection
  - incident-response
  - tabular
size_categories:
  - 10M<n<100M
pretty_name: Free Synthetic Security Cascade (100M)
---

# Free Synthetic Security Cascade — 100M Rows

A free, fully synthetic dataset of 100,000,000 network flow records, generated for developers and builders working on intrusion detection, security analytics, and incident-response models — realistic network traffic without touching any real network, host, or personal data.

Every value in this dataset is artificially generated. No real captures, no scraped traffic, no real IPs or PII. What makes it different: most rows are ordinary background traffic, but malicious activity arrives in **cascades** — dense bursts of correlated events where one intrusion triggers a chain of follow-on activity, separated by genuine calm stretches. This mirrors how real incidents actually unfold, so a model trained here has to handle both the quiet and the storm, not just uniformly-sprinkled anomalies.

## Schema

| Column | Type | Description |
|---|---|---|
| flow_id | string | Unique flow identifier |
| timestamp | timestamp[ms] | Flow start time |
| src_ip | string | Source IP address (synthetic) |
| dst_ip | string | Destination IP address (synthetic) |
| src_port | int32 | Source port |
| dst_port | int32 | Destination port |
| protocol | string | One of: TCP, UDP, ICMP |
| bytes_sent | int64 | Bytes sent in the flow |
| bytes_received | int64 | Bytes received in the flow |
| duration_ms | int64 | Flow duration in milliseconds |
| flag_pattern | string | TCP-style flag pattern (9 values, e.g. SYN-ACK-ACK, FIN-ACK, PSH-ACK) |
| cascade_id | string | ID linking flows in the same attack cascade (null for normal traffic) |
| cascade_type | string | Attack cascade type (null for normal traffic) |
| event_severity | string | One of: none, low, medium, high, critical |
| is_malicious_ground_truth | bool | Ground-truth label: true if the flow is part of an attack cascade |

**Cascade types:** `port_scan_to_bruteforce`, `ddos_burst`, `exfiltration_pattern`, `credential_stuffing_wave`, `lateral_movement`.

Normal background traffic has `cascade_id` and `cascade_type` null, `event_severity` of `none`, and `is_malicious_ground_truth` false. Malicious flows carry a shared `cascade_id` so you can group a full incident, a `cascade_type`, an elevated severity, and a true label.

## Format

- Apache Parquet, Snappy compression
- One file, ~4.25 GB, 100,000,000 rows
- Loads cleanly with pandas, polars, DuckDB, PyArrow, or the `datasets` library

## Quick start

```python
import pandas as pd
df = pd.read_parquet("security_cascade_100M.parquet")
print(df.head())
```

Or with the `datasets` library:

```python
from datasets import load_dataset
ds = load_dataset("ziadatalabs/FreeSyntheticSecurityCascade100M")
```

Or with DuckDB (great for querying without loading it all into memory):

```sql
SELECT cascade_type, count(*)
FROM 'security_cascade_100M.parquet'
WHERE is_malicious_ground_truth
GROUP BY cascade_type;
```

## Notes

- All data is synthetic and generated programmatically. Any resemblance to real hosts, IPs, or traffic is coincidental.
- IPs, ports, and flow stats follow realistic formats and distributions but describe no real network.
- The cascade clustering is **by design**: malicious events cluster into correlated bursts with quiet periods between them, so models trained on this data are stress-tested for real-world emergencies and incident response — ready for anything, not just evenly-spaced anomalies.
- `is_malicious_ground_truth` and `cascade_id` give you clean labels for both per-flow classification and full-incident grouping.

## License & Usage

Released under **CC BY-NC 4.0** — free for personal, research, and educational use, with attribution, no commercial use. See the license for details.

*Published by Zia Data Labs. We create synthetic data — and we give some of it away free, because good test data shouldn't be hard to find.*