# Facebook Comments Scraper (`dami_studio/facebook-comments-scraper`) Actor

Facebook comments scraper: export the comments on public Facebook posts, videos and reels. Paste the links and each row has the author, text, exact date, like count and reply count, with nested replies on request. Up to 5,000 comments per post. $0.25 per 1,000 comments, less on paid plans.

- **URL**: https://apify.com/dami_studio/facebook-comments-scraper.md
- **Developed by:** [Dami's Studio](https://apify.com/dami_studio) (community)
- **Categories:** Social media
- **Features:** Limited permissions
- **Stats:** 1,166 total users, 400 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.24 / 1,000 comments

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

**Facebook comments scraper that exports the comments under posts, videos and reels**, one row per
comment, with the author, the text, the exact time it was written, the like count and how many
replies it drew.

The part worth knowing before you start: this reads posts, not Pages. A bare Page link like
`facebook.com/natgeo` comes back rejected. Reaction counts above roughly a thousand arrive rounded.

| | |
|---|---|
| **Input** | Post, video, reel, photo or group-post links, up to 100 per run |
| **Output** | One row per comment, plus one per reply if you ask for them: author, text, time, likes, reply count, attachments |
| **Ceiling** | 50,000 comments per post link |
| **Speed** | Roughly 3 to 4 comments a second, so 1,000 comments take 4 to 5 minutes |
| **Account needed** | None |
| **Price** | $0.25 per 1,000 comments on the free plan, down to $0.244 on Business. The free plan's $5 a month covers about 20,000 |

| Using an AI agent? | |
|---|---|
| Actor | `dami_studio/facebook-comments-scraper` |
| Set one field | `startUrls`, labelled "Facebook post URLs" in the Console |
| Cap the bill | `maxTotalChargeUsd` on the run, for example `0.10`: it never charges past that |
| MCP, one link | `https://mcp.apify.com/?tools=fetch-actor-details,dami_studio/facebook-comments-scraper` |
| How often | Daily for a busy post, weekly for a quiet one |

### 🔍 What Facebook Comments Scraper does

It opens the post, then walks the comment thread to the end or
to your limit, whichever comes first.

Links in the `permalink.php?story_fbid=...&id=...` and `story.php` shapes are rewritten to the
equivalent `/posts/` link before the run starts, so paste whichever form you have. A share link
(`facebook.com/share/...`) is followed to the post it opens.

`inputUrl` is your link exactly as you pasted it, so you can join the results back onto your own
list. `facebookUrl` is the canonical link Facebook itself uses for that post, which is often a
different `pfbid` string.

### 📋 What data you get from each Facebook comment

| What you get | Field |
|---|---|
| The comment's ids and link | `commentId`, `id`, `feedbackId`, `commentUrl` |
| What it says, and any photo, video or sticker | `text`, `attachments` |
| A link shared in the comment | `sharedLinkUrl` |
| Everything tagged in the comment with @ or #: people, Pages, groups and hashtags, with their links | `tags` |
| The tags Facebook marks as Pages, on their own | `taggedPages` |
| When it was written | `date`, `timestamp` |
| Likes, and replies under this comment | `likesCount`, `likesCountText`, `commentsCount` |
| Whether it is a reply, and to which comment | `threadingDepth`, `replyToCommentId` |
| On a reply, what that comment said and who wrote it | `replyToCommentText`, `replyToProfileName` |
| Who wrote it | `profileName`, `profileId`, `profileUrl`, `profilePicture`, `author` |
| The post it sits under, and its comment total | `postId`, `postTitle`, `postDescription`, `pageName`, `facebookUrl`, `postCommentCount` |
| The link you pasted | `inputUrl` |
| Optional extra, only with `includeGender` on: Facebook's label for the account that wrote it | `gender` |

### ▶️ How to scrape Facebook comments

1. Open [Facebook Comments Scraper](https://apify.com/dami_studio/facebook-comments-scraper) and
   click **Try for free**.
2. Paste your links into **Facebook post URLs**, one per line.
3. Set **Max comments per post**. Start at 50 while you look at the shape of the output.
4. Click **Start**.
5. Download the dataset as JSON, CSV or Excel, or pull it from the Apify API.

Run it with empty input and you get one labelled sample row, which is not charged, so you can look
at the shape before you spend anything.

### 💰 How much does it cost to scrape Facebook comments?

**$0.25 per 1,000 comments.** That is the free plan's price; paid plans pay a little less: $0.248 on Starter, $0.246 on Scale and $0.244 on Business. On the free plan,
the $5 Apify gives you each month covers about 20,000 comments.

A reply costs the same as a top-level comment. You pay for comments that come back with data, so the
sample row, every diagnostic row, comments dropped by your date filter and a comment repeated under the same link
are not charged. If two different links lead to the same post, the post is read once per link and
charged each time.

### 📥 What you give it

```json
{
  "startUrls": [
    { "url": "https://www.facebook.com/natgeo/posts/pfbid02rAK2eMyfVYDZbESKoNVuwWjcFr5BgRBfjp27nhgQToSiQD9NF3ypNdXpQuwSp7qnl" }
  ],
  "resultsLimit": 50,
  "includeNestedComments": false
}
```

| Field | Default | What it is |
|---|---|---|
| `startUrls` | none | Public post, video, reel, photo or group-post links. First 100 per run, duplicates dropped. |
| `resultsLimit` | empty, runs as 50 | Comments per post link, 1 to 50,000. Multiply by your number of links to get the ceiling on the run and on the spend. |
| `includeNestedComments` | off | Also pull the replies under each comment. Each reply is its own row and counts towards the limit. |
| `maxRepliesPerComment` | 60 | Only with replies on. The most replies read under any one comment, 1 to 1,000. They still count towards `resultsLimit`. |
| `viewOption` | empty, runs as `RANKED_UNFILTERED` | How Facebook orders the thread before it is read: all comments (`RANKED_UNFILTERED`), most relevant (`RANKED_THREADED`), or newest first (`RECENT_ACTIVITY`). |
| `onlyCommentsNewerThan` | none | Cut-off date. `2026-01-31`, a full timestamp, a span like `3 days`, `2 weeks ago`, `24h` or `7d`, or `yesterday` / `today`. Older comments are dropped before they are billed. To fill the number you asked for, it reads on past older comments, up to four times that number of older ones a post (at least 100, at most 5,000). "Newest first" in Comments mode is quickest: it stops at the first older comment. A value it cannot read stops the run before anything is read, with a free `BAD_INPUT` row saying which forms work. |
| `proxyUrls` | none | Optional. A list such as `["http://user:pass@host:port"]`, one entry per server, if you want the traffic to leave through servers you already pay for. Stored as a secret. |
| `includeGender` | off | Adds a `gender` column on comment and reply rows: Facebook's own label for the account that wrote the comment, male or female, empty when it gives neither. Facebook doesn't print it beside the comment and it's personal data, so leave this off unless you have a reason to keep it. The price per comment stays the same. |

### 📤 What you get back

Seven comments from one post, read on 24 October 2026. Names are blurred here.

![Facebook comments as rows](https://api.apify.com/v2/key-value-stores/BTBHU3DdiuoF4JOsK/records/facebook-comments-scraper-output.png)

A real row from a run on 21 September 2026, with the text and links cut short:

```json
{
  "ok": true,
  "charged": true,
  "recordType": "comment",
  "inputUrl": "https://www.facebook.com/natgeo/posts/pfbid02rAK2eMyfVYDZbESKoNV...",
  "facebookUrl": "https://www.facebook.com/natgeo/posts/pfbid0nMcunWuEpusFmY7mj...",
  "postId": "1634927484671342",
  "postTitle": "National Geographic",
  "postDescription": "A punishing heat wave has left much of Europe in drought, causing rivers to run at record-low levels. ...",
  "pageName": "National Geographic",
  "commentUrl": "https://www.facebook.com/natgeo/posts/pfbid0nMcunWu...?comment_id=27860828630277533",
  "commentId": "27860828630277533",
  "date": "2026-08-15T06:07:03.000Z",
  "timestamp": 1786774023,
  "text": "Perfect opportunity to clean our waters!!! Bring this history to the musuem for our kids. ...",
  "likesCount": 107,
  "likesCountText": "107",
  "commentsCount": 6,
  "threadingDepth": 0,
  "replyToCommentId": null,
  "profileName": "...",
  "profileUrl": "https://www.facebook.com/...",
  "attachments": [],
  "scrapedAt": "2026-09-21T01:45:48.038Z"
}
```

| Field | How to read it |
|---|---|
| `commentId` | The numeric comment id. Use it as your key. |
| `likesCount`, `likesCountText` | Facebook publishes reactions as a display string (`"28"`, `"1.2K"`). `likesCountText` keeps it, `likesCount` is that string as a number, so `1.2K` reads as `1200`. |
| `commentsCount` | Replies under this comment, not the post's total. |
| `threadingDepth`, `replyToCommentId` | `0` for a top-level comment, `1` for a reply, with the parent's id on the reply. A reply to a reply that Facebook shows inside that list comes back as `2`, and `replyToCommentId` still names the top-level comment. |
| `replyToCommentText`, `replyToProfileName` | Only on reply rows: the text and author of the comment `replyToCommentId` names. |
| `postCommentCount` | The comment total Facebook gave for the post when the run read it, replies included, the same on every row of that post. `null` if Facebook gave none. |
| `sharedLinkUrl` | The link a commenter shared, when Facebook attached a preview card for it. `null` otherwise, including a link typed into the text with no card. |
| `tags` | Every tag in the comment, in order, each as `{type, name, id, url}`, with the name as written in the comment. `type` is `profile`, `page`, `group` or `hashtag`. Most Pages now run on Facebook's newer Page setup and arrive exactly like a person, so they come as `profile` too: a tagged Page is in this list, with its name and link. Empty when nothing is tagged. |
| `taggedPages` | Only the tags Facebook still marks as Pages (older-style Pages), each as `{name, id, url}`. Usually empty: look for Pages in `tags`. |
| `profileId` | A number on some accounts and an opaque `pfbid` string on others. |
| `profileUrl` | `null` when the commenter has no public profile link. |
| `attachments` | `{type, url}` for photo, video and sticker comments. Empty on ordinary text ones. |

### 🧾 Reading the output

Three kinds of row can land in your dataset.

| Row | How to spot it | Billed |
|---|---|---|
| A comment or a reply | `ok: true` and `charged: true` | yes |
| The sample row | `_sample: true` | no |
| A diagnostic | `ok: false`, `_diagnostic: true` and a `code` | no |

Filter on `charged == true` and you have your data. That flag is what separates real rows from the
sample and the diagnostics, not a receipt.

| `code` | What happened |
|---|---|
| `BAD_INPUT` | That link is not a post link, or the date in "Only comments newer than" could not be read. The row says which part failed. |
| `NOT_FOUND` | The post is private, deleted, or has no comment thread to read. |
| `NO_COMMENTS` | The post is readable but has no comments, or none newer than your cut-off. |
| `DATE_FILTER_STOP` | With a date filter, the post gave fewer new comments than you asked for before it reached the limit on older ones it reads. The row says how many it kept and skipped. Not charged. |
| `NOT_SERVED` | This comment was not served this run. Re-run it later. Runs before 13 October 2026 wrote `BLOCKED` here. |
| `RATE_LIMITED` | Facebook asked for a slower pace on that post. |
| `TARGET_ERROR` | Facebook answered with something the run could not read. |
| `NETWORK` | A request did not finish. |
| `DEAD_BATCH` | Fifteen links in a row came back empty before anything had been delivered, so the run stopped instead of working through a list of dead links. The rest were not read and not charged. |
| `PROXY_INPUT_ADJUSTED` | A connection setting this actor does not use was dropped. The run carried on. |
| `CHARGE_ERROR` | A billing event could not be recorded. Told to you rather than hidden. |
| `UNEXPECTED_ERROR` | The run stopped early on an unexpected error. The comments before this row are kept. |

| Optional column | How to read it |
|---|---|
| `gender`, with `includeGender` on | `male`, `female` or empty. It's Facebook's label for the account, and business Pages normally come back empty. The column is on the row and in exports, not in the default table view. |

### 💡 What people use it for

- Reading what people actually said under a campaign post, instead of the reaction total.
- Watching a competitor's announcement thread for complaints and feature requests.
- Tracking a thread over days: schedule the same link daily with `viewOption` on "Newest first" and
  `onlyCommentsNewerThan` at `24h`, key on `commentId`, and send the new comments to Slack, Google Drive or n8n.

From a Page to the conversation under its posts, in three steps:

1. Run [Facebook Posts Scraper](https://apify.com/dami_studio/facebook-posts-scraper) on the Page
   and copy the `postUrl` of the posts you care about.
2. Paste them here, with `includeNestedComments` on.
3. Keep `threadingDepth` 0 for the top-level comments, and sort on `likesCount` to see which ones
   people agreed with.

### 🚧 What it does not do

- **Posts, not Pages.** There is no Page-wide crawl here. Give it the links to the posts you care
  about, or use the Posts scraper above to find them first.
- **Public posts only.** A private group, a friends-only post or a Page restricted by age or
  country comes back as an uncharged diagnostic row saying so.
- **No reactions breakdown.** You get the total, not how many were love, haha or angry.
- **No commenter email or phone.**
- **It does not guess gender.** The `gender` column is Facebook's label or empty.
- **Replies below the first level are not read**, apart from the ones Facebook shows inside a
  comment's reply list.
- **Reply counts can exceed the rows you get.**
- **50,000 comments per link, inside the run's time limit.** For a long thread, raise the run's timeout.
- **A run that reaches its time limit stops cleanly.** It keeps what it delivered and its status says
  what it did not finish.
- It is not an official Facebook tool. Dami's Studio is independent and is not affiliated with or endorsed by Facebook or Meta, or by any other company named on this page.

### 🧭 Which Facebook scraper do you need?

| If you want | Use |
|---|---|
| The comments under posts you already have links for | This one |
| Recent posts from a Page, with their links | [Facebook Posts Scraper](https://apify.com/dami_studio/facebook-posts-scraper) |
| Posts from a public group | [Facebook Groups Scraper](https://apify.com/dami_studio/facebook-groups-scraper) |
| Reels from a Page | [Facebook Reels Scraper](https://apify.com/dami_studio/facebook-reels-scraper) |
| The reviews and recommendations on a Page | [Facebook Reviews Scraper](https://apify.com/dami_studio/facebook-reviews-scraper) |
| Comments under an Instagram post or reel | [Instagram Comments Scraper](https://apify.com/dami_studio/instagram-comments-scraper) |
| Comments under a YouTube video | [YouTube Comments Scraper](https://apify.com/dami_studio/youtube-comments-scraper) |

### ❓ Questions people ask

#### Do I need a Facebook account to scrape comments?

No. You need no Facebook account of your own for public posts.

#### Is the limit per post or per run?

Per post link. Ten links at 500 each is up to 5,000 rows, so keep an eye on it when you paste a long
list.

#### Why did I get fewer comments than the post shows?

Either your cut-off date dropped them, or the thread holds fewer than the counter claims. Open the post in a private browser window: the thread a
signed-out visitor sees there is the one this actor reads.

#### Can I get replies to replies?

Only the ones Facebook shows inside a comment's reply list. They come back with `threadingDepth` 2
when `includeNestedComments` is on. The deeper threads behind them are not read.

#### Can I call it from code or connect it to an AI assistant?

Yes. The [API tab](https://apify.com/dami_studio/facebook-comments-scraper/api/python) has code for Python, JavaScript and the command line. In Python:

```python
## pip install apify-client
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("dami_studio/facebook-comments-scraper").call(
    run_input={
        "startUrls": [{"url": "https://www.facebook.com/natgeo/posts/pfbid02rAK2eMyfVYDZbESKoNVuwWjcFr5BgRBfjp27nhgQToSiQD9NF3ypNdXpQuwSp7qnl"}],
        "resultsLimit": 50,
    },
    max_total_charge_usd=0.50,  # the most this run may spend
)
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if row.get("ok"):  # ok: false rows are free notes
        print(row["date"], row["likesCount"], (row.get("text") or "")[:80])
```

MCP clients like Claude and ChatGPT use `https://mcp.apify.com/?tools=fetch-actor-details,dami_studio/facebook-comments-scraper`; coding assistants can load [our skill file](https://api.apify.com/v2/key-value-stores/BTBHU3DdiuoF4JOsK/records/apify-facebook-meta-SKILL.md). All three bill your Apify account at the same price.

#### Is scraping Facebook comments legal?

This reads public posts signed out, never friends-only posts, private groups or messages. Comments,
and the people tagged in them, are personal data, which GDPR and similar laws cover, so have a reason
for collecting them and keep only what you need. The `includeGender` option is Facebook's own label
for the account: it isn't printed beside the comment and it's personal data like the rest, so leave
it off unless you have a lawful reason to hold it. Apify's write-up on
[the legality of web scraping](https://blog.apify.com/is-web-scraping-legal/) is a good starting
point, and we are not lawyers.

### 🆘 If something breaks

Open the **Issues** tab on the actor page. Paste the link you used and the run ID, and the log is
enough for us to see what happened.

# Actor input Schema

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

Public Facebook post, video, reel, photo or group-post permalinks. You get one row per comment for each of them.

## `resultsLimit` (type: `integer`):

Stop after this many comments for each post URL. Keep it low while you are testing - you pay per comment.

## `includeNestedComments` (type: `boolean`):

Also fetch the replies underneath each comment. Every reply is returned as its own row and counts towards the limit.

## `maxRepliesPerComment` (type: `integer`):

Only used with replies on. Stop after this many replies under any one comment. Replies still count towards the comment limit above.

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

How Facebook should order the comments before they are read.

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

Optional cut-off. A date (2026-01-31 or a full timestamp like 2026-01-31T18:00:00Z), a span (3 days, 2 weeks ago, 24h, 7d), or yesterday / today. Comments older than this are dropped and never charged. A value it cannot read stops the run before it reads a comment, with a free note saying which forms work. There is no add-on fee for using it.

## `proxyUrls` (type: `array`):

Leave this empty for a normal run. Fill it in only if you want the traffic to leave through proxy servers you already pay for, as a list with one entry per server, for example \["http://user:pass@host:port"]. Stored as a secret, so the addresses and passwords stay hidden in the run input.

## `includeGender` (type: `boolean`):

Adds a gender column: Facebook's own label for the account that wrote the comment, male or female, empty when it gives neither. Facebook doesn't print it beside the comment and it's personal data, so leave this off unless you have a reason to keep it.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.facebook.com/natgeo/posts/pfbid02rAK2eMyfVYDZbESKoNVuwWjcFr5BgRBfjp27nhgQToSiQD9NF3ypNdXpQuwSp7qnl"
    }
  ],
  "resultsLimit": 50,
  "includeNestedComments": false,
  "maxRepliesPerComment": 60,
  "viewOption": "RANKED_UNFILTERED",
  "onlyCommentsNewerThan": "",
  "includeGender": false
}
```

# Actor output Schema

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

Every comment row in the default dataset: profileName, text, date, likesCount, commentsCount, threadingDepth, commentUrl, facebookUrl, postId, postTitle and the rest. An empty, private or failed run returns a single uncharged row explaining what happened instead.

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.facebook.com/natgeo/posts/pfbid02rAK2eMyfVYDZbESKoNVuwWjcFr5BgRBfjp27nhgQToSiQD9NF3ypNdXpQuwSp7qnl"
        }
    ],
    "resultsLimit": 50,
    "includeNestedComments": false,
    "viewOption": "RANKED_UNFILTERED",
    "onlyCommentsNewerThan": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("dami_studio/facebook-comments-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 = {
    "startUrls": [{ "url": "https://www.facebook.com/natgeo/posts/pfbid02rAK2eMyfVYDZbESKoNVuwWjcFr5BgRBfjp27nhgQToSiQD9NF3ypNdXpQuwSp7qnl" }],
    "resultsLimit": 50,
    "includeNestedComments": False,
    "viewOption": "RANKED_UNFILTERED",
    "onlyCommentsNewerThan": "",
}

# Run the Actor and wait for it to finish
run = client.actor("dami_studio/facebook-comments-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.facebook.com/natgeo/posts/pfbid02rAK2eMyfVYDZbESKoNVuwWjcFr5BgRBfjp27nhgQToSiQD9NF3ypNdXpQuwSp7qnl"
    }
  ],
  "resultsLimit": 50,
  "includeNestedComments": false,
  "viewOption": "RANKED_UNFILTERED",
  "onlyCommentsNewerThan": ""
}' |
apify call dami_studio/facebook-comments-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dami_studio/facebook-comments-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/jTmbBeGhoZmHU3FFr/builds/JeKE1mhTPrCr9VSGn/openapi.json