# Sleeper Fantasy NFL Trending Players Scraper (`parseforge/sleeper-fantasy-nfl-scraper`) Actor

Track which NFL players the Sleeper fantasy community is adding and dropping right now. Each trending player comes with full name, position, team, status, injury tag, age, years of experience, and the add or drop count. Great for waiver wire calls and start or sit research.

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

## Pricing

from $0.80 / 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/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🏈 Sleeper Fantasy NFL Trending Players Scraper

> 🚀 **Export the most added and dropped NFL fantasy players in seconds.** See exactly who the Sleeper community is rushing to pick up or cut, with a live add/drop count behind every name.

> 🕒 **Last updated:** 2026-06-05 · **📊 16 fields** per record · Up to 200 trending players per run · Covers the full Sleeper NFL player pool (12,000+ profiles)

Fantasy football moves fast, and the waiver wire moves faster. This Actor reads the public Sleeper trending feed for NFL and tells you which players are heating up right now, ranked by how many fantasy managers added or dropped them inside your chosen time window. Every trending player is enriched with their full profile so you get a roster ready record instead of a bare player id.

**Coverage.** The Actor pulls the live trending add or drop list from Sleeper, then looks up each player in the complete Sleeper NFL profile map. That map carries over 12,000 players, so active starters, rookies, free agents and deep bench names all resolve to a real name, position, team and status.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Fantasy football managers and commissioners | Waiver wire and free agent pickup decisions |
| Fantasy content creators and analysts | Weekly trending add and drop articles and videos |
| Sports data and model builders | Feeding roster trend signals into projections |
| Discord and group chat bot makers | Auto posting hot adds to a league channel |

### 📋 What the Sleeper Fantasy NFL Trending Players Scraper does

- Reads the live Sleeper trending feed for NFL, either most added or most dropped.
- Ranks players by the number of add or drop transactions inside your lookback window.
- Fetches the full Sleeper NFL player profile map once per run and caches it in memory.
- Enriches every trending player with name, position, team, status, injury status, age, years of experience, jersey number and college.
- Returns one clean record per trending player, ready for analysis or automation.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `type` | string | Which trend to pull. `add` for most added players, `drop` for most dropped. Default `add`. |
| `lookback_hours` | integer | Time window in hours used to rank the trend. Default `24`, range 1 to 168. |
| `limit` | integer | How many trending players to request before enrichment. Default `25`, range 1 to 200. |
| `maxItems` | integer | Free users limited to 10 items (preview). Paid users optional, up to 1,000,000. |

```json
{
    "type": "add",
    "lookback_hours": 24,
    "limit": 25
}
````

```json
{
    "type": "drop",
    "lookback_hours": 48,
    "limit": 50
}
```

> ⚠️ **Good to Know:** `injuryStatus` is only present when Sleeper has flagged a player as injured. Healthy players return `null` for that field by design, which is the same behavior as the source feed.

### 📊 Output

| 🏷 Field | Type | Description |
|---|---|---|
| 🆔 `playerId` | string | Sleeper player id. |
| 🏈 `fullName` | string | Player full name. |
| 🔤 `firstName` | string | First name. |
| 🔤 `lastName` | string | Last name. |
| 🎽 `position` | string | Roster position such as RB, WR, TE, QB. |
| 🏟 `team` | string | NFL team abbreviation, null for free agents. |
| 📋 `status` | string | Player status such as Active or Inactive. |
| 🩺 `injuryStatus` | string | Injury tag such as Questionable, null when healthy. |
| 🎂 `age` | number | Player age. |
| 📅 `yearsExp` | number | Years of NFL experience. |
| 🔢 `number` | number | Jersey number. |
| 🎓 `college` | string | College attended. |
| 🔁 `trendType` | string | Whether the row came from the add or drop feed. |
| 📈 `trendCount` | number | Add or drop transaction count in the window. |
| ⏱ `lookbackHours` | number | Lookback window used for the ranking. |
| 🕒 `scrapedAt` | string | ISO timestamp when the record was collected. |
| ❌ `error` | string | Error message, null on success. |

Real sample records from a live run:

```json
{"playerId":"8800","fullName":"Malik Davis","firstName":"Malik","lastName":"Davis","position":"RB","team":"DAL","status":"Active","injuryStatus":null,"age":27,"yearsExp":4,"number":20,"college":"Florida","trendType":"add","trendCount":28296,"lookbackHours":24,"scrapedAt":"2026-06-05T17:03:10.133Z","error":null}
```

```json
{"playerId":"2078","fullName":"Odell Beckham","firstName":"Odell","lastName":"Beckham","position":"WR","team":"NYG","status":"Active","injuryStatus":null,"age":33,"yearsExp":12,"number":3,"college":"LSU","trendType":"add","trendCount":9009,"lookbackHours":24,"scrapedAt":"2026-06-05T17:03:10.133Z","error":null}
```

```json
{"playerId":"9479","fullName":"Darnell Washington","firstName":"Darnell","lastName":"Washington","position":"TE","team":"PIT","status":"Active","injuryStatus":null,"age":24,"yearsExp":3,"number":80,"college":"Georgia","trendType":"add","trendCount":7235,"lookbackHours":24,"scrapedAt":"2026-06-05T17:03:10.133Z","error":null}
```

### ✨ Why choose this Actor

- One record per trending player, already enriched with the full profile.
- A real add or drop count behind every name, not just a ranking.
- Adjustable lookback window so you can catch same day spikes or week long trends.
- Pulls from the public Sleeper API, no login or fantasy account required.
- Clean field names that drop straight into a spreadsheet, notebook or bot.

### 📈 How it compares to alternatives

| Approach | Trend counts | Profile enrichment | Setup |
|---|---|---|---|
| This Actor | Yes, add and drop counts | Yes, name, position, team, injury, age | None, just run |
| Manual app checking | Visible but not exportable | Manual reading | Tedious |
| Raw Sleeper API call | Returns only id and count | None, ids only | You build the lookup |

### 🚀 How to use

1. Sign up for a free Apify account using [this link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the Sleeper Fantasy NFL Trending Players Scraper.
3. Pick `add` or `drop`, set your lookback window and limit.
4. Click Start and let the run finish.
5. Open the results and review or connect them to your tool of choice.

### 💼 Business use cases

#### Fantasy media and content

| Need | How this helps |
|---|---|
| Weekly waiver wire articles | Pull the top adds with counts to anchor your list |
| Short form video scripts | Spot rising names before they trend everywhere |

#### League management

| Need | How this helps |
|---|---|
| Commissioner newsletters | Share the hottest pickups with your league |
| Trade talk prep | See who managers are cutting and why |

#### Analytics and modeling

| Need | How this helps |
|---|---|
| Roster trend features | Feed add and drop counts into projections |
| Ownership shift tracking | Compare windows to measure momentum |

#### Community and bots

| Need | How this helps |
|---|---|
| Discord pickup alerts | Post fresh adds to a channel automatically |
| Group chat digests | Summarize movers for your friends each morning |

### 🔌 Automating Sleeper Fantasy NFL Trending Players Scraper

Connect runs to the tools you already use with Apify integrations for Make, Zapier, Slack, Airbyte, GitHub and Google Drive. Schedule a daily run and push the hottest adds straight into a sheet, a channel or your own database without writing glue code.

### 🌟 Beyond business use cases

- **Research.** Study how fantasy managers react to injuries and depth chart changes.
- **Personal.** Win your home league by catching breakout players a day early.
- **Non-profit.** Power a free community newsletter for a charity fantasy event.
- **Experimentation.** Test whether trend counts predict next week production.

### 🤖 Ask an AI assistant

Paste your results into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai) or [Microsoft Copilot](https://copilot.microsoft.com) and ask for a ranked pickup list, a start or sit take, or a quick summary of the biggest movers.

### ❓ Frequently Asked Questions

**Is this affiliated with Sleeper?** No. It is an independent tool that reads the public Sleeper API.

**Do I need a Sleeper account?** No. The trending and profile endpoints are public and keyless.

**What does the count mean?** It is the number of add or drop transactions for that player inside your lookback window.

**Why is injuryStatus often null?** Sleeper only sets an injury tag for flagged players. Healthy players have no tag.

**Can I get dropped players too?** Yes. Set `type` to `drop`.

**How far back can the window go?** Up to 168 hours, which is one week.

**How many players can I pull?** Up to 200 trending players per run before enrichment.

**Does it cover free agents?** Yes. Free agents resolve from the profile map and return a null team.

**Is the data live?** Each run fetches the current trending feed at that moment.

**What sports are covered?** This Actor covers NFL fantasy trends.

### 🔌 Integrate with any app

Results are available through the Apify API and dataset endpoints, so you can pull them into any app, script or workflow that can read a web request.

### 🔗 Recommended Actors

- [Fantasy Premier League Player Stats Scraper](https://apify.com/parseforge)
- [Understat xG Scraper](https://apify.com/parseforge)
- [OpenDota Pro Matches Scraper](https://apify.com/parseforge)
- [Speedrun Leaderboards Scraper](https://apify.com/parseforge)

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with Sleeper. Only publicly available data collected.

# Actor input Schema

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

Choose which trend to pull from Sleeper. Add returns the players most added to fantasy rosters. Drop returns the players most dropped.

## `lookback_hours` (type: `integer`):

Time window in hours used to rank the trend. A value of 24 ranks adds or drops over the last day. Larger windows surface longer running trends.

## `limit` (type: `integer`):

How many trending players to request from Sleeper before enrichment. The default of 25 reliably yields more than five enriched records.

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

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

## Actor input object example

```json
{
  "type": "add",
  "lookback_hours": 24,
  "limit": 25,
  "maxItems": 10
}
```

# Actor output Schema

## `results` (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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/sleeper-fantasy-nfl-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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/sleeper-fantasy-nfl-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 '{
  "maxItems": 10
}' |
apify call parseforge/sleeper-fantasy-nfl-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Sleeper Fantasy NFL Trending Players Scraper",
        "description": "Track which NFL players the Sleeper fantasy community is adding and dropping right now. Each trending player comes with full name, position, team, status, injury tag, age, years of experience, and the add or drop count. Great for waiver wire calls and start or sit research.",
        "version": "0.1",
        "x-build-id": "1MTVd8viTBNXvq68A"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~sleeper-fantasy-nfl-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-sleeper-fantasy-nfl-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~sleeper-fantasy-nfl-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-sleeper-fantasy-nfl-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~sleeper-fantasy-nfl-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-sleeper-fantasy-nfl-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": {
                    "type": {
                        "title": "Trend Type",
                        "enum": [
                            "add",
                            "drop"
                        ],
                        "type": "string",
                        "description": "Choose which trend to pull from Sleeper. Add returns the players most added to fantasy rosters. Drop returns the players most dropped.",
                        "default": "add"
                    },
                    "lookback_hours": {
                        "title": "Lookback Hours",
                        "minimum": 1,
                        "maximum": 168,
                        "type": "integer",
                        "description": "Time window in hours used to rank the trend. A value of 24 ranks adds or drops over the last day. Larger windows surface longer running trends.",
                        "default": 24
                    },
                    "limit": {
                        "title": "Trend Limit",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "How many trending players to request from Sleeper before enrichment. The default of 25 reliably yields more than five enriched records.",
                        "default": 25
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```