# CRAN R Packages Metadata Scraper (`parseforge/cran-r-packages-scraper`) Actor

Pull authoritative metadata for any R package from the official CRAN crandb database. Returns package name, title, version, authors, maintainer, license, dependencies, and publication date. Handy for dependency audits, license compliance checks, and cataloging R tooling.

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

## Pricing

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

## 📦 CRAN R Packages Scraper

> 🚀 **Export R package metadata in seconds.** Feed a list of package names and get clean, structured records straight from the official CRAN database.

> 🕒 **Last updated:** 2026-06-05 · **📊 18 fields** per record · Powered by the CRAN crandb API · 20,000+ packages reachable

Pull authoritative metadata for any package on the Comprehensive R Archive Network (CRAN). This Actor queries the official `crandb.r-pkg.org` database, so every field comes directly from the package's own `DESCRIPTION` file. Hand it a list of package names and it returns the title, version, authors, maintainer, license, dependencies, and more for each one.

Coverage spans the entire CRAN registry. Popular packages like `ggplot2`, `dplyr`, and `data.table` resolve instantly, and any other published package name works the same way. Packages that do not exist on CRAN are reported as error records so you always know what resolved and what did not.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| R developers and data scientists | Audit dependencies and licenses across a package set |
| DevOps and security teams | Track versions and maintainers for supply-chain checks |
| Researchers and educators | Build catalogs of R tooling for analysis or teaching |
| Open-source maintainers | Monitor metadata of upstream and downstream packages |

### 📋 What the CRAN R Packages Scraper does

- Accepts a list of CRAN package names and fetches each one from the official crandb database.
- Returns 18 structured fields per package, including dependencies parsed into readable lists.
- Cleans the raw `DESCRIPTION` text so multi-line authors and descriptions become tidy single-line values.
- Flags any name that is not found on CRAN as an error record instead of failing the run.

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

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `packageNames` | array of strings | CRAN package names to look up. Defaults to nine popular packages. |
| `maxItems` | integer | Caps the number of packages processed. Free plan is limited to 10. |

Example: default popular packages

```json
{
  "packageNames": ["ggplot2", "dplyr", "data.table", "shiny", "Rcpp", "stringr", "tidyr", "jsonlite", "httr"]
}
````

Example: a custom dependency audit

```json
{
  "packageNames": ["tidymodels", "recipes", "parsnip", "workflows"],
  "maxItems": 50
}
```

> ⚠️ **Good to Know:** Package names on CRAN are case sensitive. Use `Rcpp`, not `rcpp`. Names that do not match a published CRAN package are returned as error records so the rest of the run still completes.

### 📊 Output

Each package becomes one record with the following fields.

| Field | Description |
|---|---|
| 📦 `package` | Package name |
| 📌 `title` | One-line package title |
| 🔖 `version` | Latest published version |
| 👥 `authorsR` | Structured `Authors@R` block from the DESCRIPTION |
| ✍️ `author` | Plain-text author credits |
| 👤 `maintainer` | Maintainer name and email |
| 📝 `description` | Full package description |
| ⚖️ `license` | License string |
| 🔗 `url` | Project or homepage URLs |
| 🐞 `bugReports` | Bug tracker URL |
| 📅 `published` | Publication date of the current version |
| 🛠 `needsCompilation` | Whether the package needs compilation |
| 🔢 `releaseCount` | Number of historical releases known to crandb |
| 📥 `depends` | Depends entries as a readable list |
| 📦 `imports` | Imports entries as a readable list |
| 💡 `suggests` | Suggests entries as a readable list |
| 🕒 `scrapedAt` | Timestamp of collection |
| ❌ `error` | Populated only when a name fails to resolve |

Real sample records:

```json
{
  "package": "ggplot2",
  "title": "Create Elegant Data Visualisations Using the Grammar of Graphics",
  "version": "4.0.3",
  "maintainer": "Thomas Lin Pedersen <thomas.pedersen@posit.co>",
  "license": "MIT + file LICENSE",
  "url": "https://ggplot2.tidyverse.org, https://github.com/tidyverse/ggplot2",
  "published": "2026-04-22 09:10:03 UTC",
  "needsCompilation": "no",
  "imports": ["cli", "grDevices", "grid"]
}
```

```json
{
  "package": "dplyr",
  "title": "A Grammar of Data Manipulation",
  "version": "1.2.1",
  "maintainer": "Hadley Wickham <hadley@posit.co>",
  "license": "MIT + file LICENSE",
  "url": "https://dplyr.tidyverse.org, https://github.com/tidyverse/dplyr",
  "published": "2026-04-03 07:30:08 UTC",
  "needsCompilation": "yes",
  "imports": ["cli (>= 3.6.2)", "generics", "glue (>= 1.3.2)"]
}
```

```json
{
  "package": "data.table",
  "title": "Extension of `data.frame`",
  "version": "1.18.4",
  "maintainer": "Tyson Barrett <t.barrett88@gmail.com>",
  "license": "MPL-2.0 | file LICENSE",
  "url": "https://r-datatable.com, https://Rdatatable.gitlab.io/data.table",
  "published": "2026-05-06 05:10:20 UTC",
  "needsCompilation": "yes",
  "imports": ["methods"]
}
```

### ✨ Why choose this Actor

- **Authoritative source.** Data comes straight from the official CRAN crandb database, not a third-party mirror.
- **Clean dependencies.** Depends, Imports, and Suggests arrive as readable lists, not raw blobs.
- **Resilient runs.** Unknown package names become error records, so one bad name never sinks the batch.
- **Zero setup.** No API key needed. Paste package names and run.

### 📈 How it compares to alternatives

| Approach | Setup | Structured fields | Dependency parsing | Batch lookups |
|---|---|---|---|---|
| CRAN R Packages Scraper | None | 18 fields | Yes | Yes |
| Manual DESCRIPTION reading | High | Manual | Manual | No |
| `available.packages()` in R | R environment | Limited | Partial | One mirror snapshot |

### 🚀 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 CRAN R Packages Scraper in the Apify Console.
3. Enter the package names you want, or keep the default popular set.
4. Click **Start** and let the Actor fetch each package.
5. Browse the results table or pull them through the Apify API.

### 💼 Business use cases

#### Dependency and supply-chain auditing

| Need | How this helps |
|---|---|
| Map the dependency tree of an internal project | Pull Depends and Imports for every package in scope |
| Spot heavy or risky dependencies | Compare import lists across packages at a glance |

#### License compliance

| Need | How this helps |
|---|---|
| Verify licenses before shipping | Read the license field for each package |
| Flag copyleft obligations | Filter on license strings like GPL or MPL |

#### Maintenance and ownership tracking

| Need | How this helps |
|---|---|
| Know who maintains a dependency | Capture maintainer name and email |
| Track version drift | Compare version and publication date over time |

#### Research and cataloging

| Need | How this helps |
|---|---|
| Build a catalog of R tools in a domain | Batch-fetch metadata for a curated package list |
| Study authorship patterns | Analyze the Authors@R and author fields |

### 🔌 Automating CRAN R Packages Scraper

Connect this Actor to the tools you already use:

- **Make** and **Zapier** to trigger runs and route results into other apps.
- **Slack** to post a summary when a run finishes.
- **Airbyte** to sync results into a warehouse.
- **GitHub** Actions to refresh metadata on a schedule.
- **Google Drive** to archive each run's output.

### 🌟 Beyond business use cases

- **Research.** Compile metadata for a literature review of R tooling.
- **Personal.** Track the packages you depend on in side projects.
- **Non-profit.** Audit open-source licenses for community tools.
- **Experimentation.** Prototype a package recommender from dependency graphs.

### 🤖 Ask an AI assistant

Drop the output into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai), or [Microsoft Copilot](https://copilot.microsoft.com) and ask it to summarize licenses, cluster packages by dependency overlap, or draft an upgrade plan.

### ❓ Frequently Asked Questions

**Where does the data come from?** The official CRAN crandb database at `crandb.r-pkg.org`, which mirrors each package's DESCRIPTION file.

**Do I need an API key?** No. The source is keyless and the Actor needs no credentials.

**Are package names case sensitive?** Yes. CRAN treats `Rcpp` and `rcpp` differently, so match the exact published name.

**What happens if a package does not exist?** That name is returned as an error record and the rest of the run continues.

**How many packages can I fetch?** Free plans are capped at 10 items per run. Paid plans can fetch many more.

**Does it return historical versions?** It returns the current published version plus a count of known releases. Per-version history is not expanded.

**Are dependencies included?** Yes. Depends, Imports, and Suggests are parsed into readable lists.

**Is the maintainer email included?** Yes, when CRAN publishes it in the DESCRIPTION.

**Can I schedule runs?** Yes, through the Apify scheduler or any connected automation tool.

**Is this affiliated with CRAN or the R Foundation?** No. It is an independent tool that reads publicly available CRAN data.

### 🔌 Integrate with any app

Every run produces structured records you can pull through the Apify API or connect to Make, Zapier, n8n, and more.

### 🔗 Recommended Actors

- [ParseForge collection](https://apify.com/parseforge) for more developer and data tooling scrapers.
- Browse related package-registry and metadata Actors on the ParseForge profile.

> 💡 **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 CRAN or the R Foundation. Only publicly available data collected.

# Actor input Schema

## `packageNames` (type: `array`):

List of CRAN R package names to fetch metadata for. Each name is looked up on the CRAN crandb database.

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

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

## Actor input object example

```json
{
  "packageNames": [
    "ggplot2",
    "dplyr",
    "data.table",
    "shiny",
    "Rcpp",
    "stringr",
    "tidyr",
    "jsonlite",
    "httr"
  ],
  "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 = {
    "packageNames": [
        "ggplot2",
        "dplyr",
        "data.table",
        "shiny",
        "Rcpp",
        "stringr",
        "tidyr",
        "jsonlite",
        "httr"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/cran-r-packages-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 = {
    "packageNames": [
        "ggplot2",
        "dplyr",
        "data.table",
        "shiny",
        "Rcpp",
        "stringr",
        "tidyr",
        "jsonlite",
        "httr",
    ],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/cran-r-packages-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 '{
  "packageNames": [
    "ggplot2",
    "dplyr",
    "data.table",
    "shiny",
    "Rcpp",
    "stringr",
    "tidyr",
    "jsonlite",
    "httr"
  ],
  "maxItems": 10
}' |
apify call parseforge/cran-r-packages-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CRAN R Packages Metadata Scraper",
        "description": "Pull authoritative metadata for any R package from the official CRAN crandb database. Returns package name, title, version, authors, maintainer, license, dependencies, and publication date. Handy for dependency audits, license compliance checks, and cataloging R tooling.",
        "version": "0.1",
        "x-build-id": "20dlAoeZZErOND6fk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~cran-r-packages-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-cran-r-packages-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~cran-r-packages-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-cran-r-packages-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~cran-r-packages-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-cran-r-packages-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": {
                    "packageNames": {
                        "title": "Package Names",
                        "type": "array",
                        "description": "List of CRAN R package names to fetch metadata for. Each name is looked up on the CRAN crandb database.",
                        "default": [
                            "ggplot2",
                            "dplyr",
                            "data.table",
                            "shiny",
                            "Rcpp",
                            "stringr",
                            "tidyr",
                            "jsonlite",
                            "httr"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```