# Medium Articles Scraper (`fetch_cat/medium-articles-scraper`) Actor

Scrape public Medium article metadata from RSS feeds by tag, author, publication, or feed URL.

- **URL**: https://apify.com/fetch_cat/medium-articles-scraper.md
- **Developed by:** [Fetch Cat](https://apify.com/fetch_cat) (community)
- **Categories:** News, Automation, Business
- **Features:** Limited permissions
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 article rows

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

Collect recent public Medium article metadata from tags, author handles, publications, or Medium feed URLs. Export titles, links, authors, dates, tags, snippets and available images to JSON, CSV or Excel. This Medium Articles Scraper reads feeds, not full article archives or engagement counters.

### Quick start

1. Open the Actor's Input tab and choose a tag, author, publication or feed URL. Remove unwanted example sources.
2. Set a small article limit and start the run.
3. Open the dataset and export results. Filter `itemType` to `article` when you only want articles, not source diagnostics.

```json
{
  "tags": ["artificial-intelligence"],
  "maxItems": 10,
  "maxItemsPerSource": 10,
  "includeSnippetHtml": true
}
```

Feeds expose recent items only. A higher limit does not unlock historical articles, paywalled text or keyword search.

Prefer a video guide? This short Apify walkthrough shows you how to set up and run an Actor. It uses a different Actor, but the setup steps are the same.

https://youtu.be/1OW8gOqlZbY?t=25

### Ready-to-run examples

Choose a public example to see its settings before starting a run:

- [Medium publication articles](https://apify.com/fetch_cat/medium-articles-scraper/examples/medium-publication-articles)
- [Medium author articles](https://apify.com/fetch_cat/medium-articles-scraper/examples/medium-author-articles)
- [Medium AI tag articles](https://apify.com/fetch_cat/medium-articles-scraper/examples/medium-ai-tag-articles)

### What you get

Article rows contain feed-derived titles, source links, available authors, dates, tags, snippets and images. Diagnostic rows separately describe source outcomes. Feed fragments are not a guaranteed full article, and estimated reading time and membership hints retain their uncertainty.

### Who is it for?

- **Editorial researchers** preparing source-linked recent reading lists.
- **Publication analysts** reviewing items exposed by selected public feeds.
- **Topic researchers** examining available article metadata and snippets.
- **AI and data developers** using feed fragments as input to a separate analysis workflow.

### How you can use the data

- **Prepare an artificial-intelligence reading sample.** Use the existing tag with ten total articles and ten considered items per source. Keep title, URL, author and publication date for editorial review without claiming every article mentioning AI is included.
- **Compare your own publication or author exports.** Supply supported publication slugs, author handles or feed URLs and retain article IDs with collection times. Duplicate articles are saved once, but sourceInputs is not an exhaustive map of every overlapping feed.
- **Choose feed snippets for your own analysis.** Enable snippet HTML when formatting is useful or keep plain snippetText. Do not present feed text as a full article corpus, verified paywall status or Medium's native reading time.
- **Separate source diagnostics from reading material.** Filter itemType to article for a reading list and inspect status and errorCode on diagnostic rows. Dataset row count can exceed the article cap, and a succeeded run can contain no articles.

### Input settings

Supply at least one of `startUrls`, `tags`, `authors` or `publications`. You may combine them. Sources are processed in that order. Results retain feed order, not a global date or popularity sort.

| Setting | JSON key | Purpose |
| --- | --- | --- |
| Medium feed or page URLs | `startUrls` | Feed URLs or supported Medium tag, author and publication pages. |
| Tags | `tags` | Topic names such as `data science`. |
| Authors | `authors` | Handles such as `@ev` or Medium profile URLs. |
| Publications | `publications` | Slugs such as `the-generator` or Medium publication URLs. |
| Maximum article rows | `maxItems` | Total article-row cap. Diagnostics may add rows. |
| Maximum articles per source | `maxItemsPerSource` | Feed items considered per source, before duplicate removal. |
| Include snippet HTML | `includeSnippetHtml` | Include `snippetHtml`. Plain-text `snippetText` remains available. |
| Include article details (reserved) | `includeArticleDetails` | Accepted but currently has no effect, even when `true`. |

See each input field's help for defaults and limits. Use explicit limits for predictable API requests.

#### Example inputs

Use the Quick start input as a small first run. Adjust the fields described above for your own data.

### Output data

The following abbreviated, synthetic example illustrates the shape, not an observed article:

```json
{
  "itemType": "article",
  "input": "data-science",
  "inputType": "tag",
  "feedUrl": "https://medium.com/feed/tag/data-science",
  "title": "Illustrative article title",
  "url": "https://medium.com/example/illustrative-article-abc123def456",
  "authorName": null,
  "publishedAt": null,
  "tags": ["Data Science"],
  "snippetText": "Illustrative feed snippet.",
  "readingTime": 1,
  "readingTimeMethod": "estimated_from_feed_words",
  "isMemberOnly": null,
  "status": "ok",
  "errorCode": null
}
```

| Fields | Meaning |
| --- | --- |
| `itemType`, `status`, `errorCode`, `errorMessage`, `httpStatus` | Article or diagnostic row and available source outcome. |
| `input`, `inputType`, `feedUrl`, `feedTitle`, `sourceInputs` | Source provenance. Do not rely on `sourceInputs` as an exhaustive cross-feed overlap report. |
| `articleId`, `guid`, `url`, `canonicalUrl` | Feed-derived identifiers and article links. |
| `title`, `authorName`, `publicationName` | Available metadata.  `publicationName` may be the feed title rather than a verified publication identity. |
| `publishedAt`, `updatedAt`, `rawPublishedAt`, `rawUpdatedAt` | Parsed and original dates when supplied. |
| `tags`, `tagsNormalized` | Original categories and normalized tags. |
| `snippetHtml`, `snippetText`, `imageUrl` | Feed fragment, plain text and available first image. Not guaranteed full text. |
| `readingTime`, `readingTimeMethod` | Minutes estimated from feed text, not Medium's native reading-time value. |
| `isMemberOnly`, `subtitle` | Membership is a best-effort text hint (`true` or `null`), not a verified paywall flag. `subtitle` is currently always `null`. |
| `source`, `scrapedAt` | Source label and collection timestamp. |

Missing values remain `null` or empty arrays. `snippetHtml` is omitted when disabled. Repeated articles across sources are saved once. A per-source cap is applied before duplicates are removed, so fewer articles may be returned than requested.

#### Download your results

Open your run's dataset, choose **Export** and select JSON, CSV or Excel. JSON keeps nested fields together. CSV and Excel are useful when you want to review the records in a spreadsheet.

See [Apify's download and export guide](https://docs.apify.com/storage/dataset#apify-console) for the available formats and field options.

### Pricing

The `start` event is charged once after source validation. The `item` event applies to each saved article row. Diagnostic rows are not charged as articles.

Use explicit small total and per-source limits. See the [live Pricing tab](https://apify.com/fetch_cat/medium-articles-scraper/pricing) for current rates.

### Tips for best results

- **Remove unwanted example sources.** URLs, tags, authors and publications can all contribute work.
- **Filter article rows explicitly.** Diagnostic rows describe source outcomes rather than reading material.
- **Retain raw dates and feed links.** They help check metadata before reusing it in a brief.
- **Keep per-source limits small deliberately.** The cap applies before duplicate removal and can produce fewer saved articles.
- **Use snippets as excerpts.** The reserved article-details option does not add full text.

### Limits and caveats

Only recent public Medium feed metadata and exposed snippets are supported. Full bodies, claps, responses, historical pagination, keyword search and native ranking are not provided. No login, cookies or member-only bypass is supported. Custom-domain feeds and arbitrary websites are outside the supported URL contract.

At least one supported source is required. URL sources are processed before tags, authors and publications, in that order. Feed order is retained rather than globally sorting dates or popularity. Total limits count article rows while diagnostics may add dataset rows. Per-source limits count considered feed items before duplicate removal, and feeds may contain fewer recent entries than either limit.

Missing values remain null or empty, and snippetHtml is omitted when disabled. Reading time is estimated from feed words, publicationName can be the feed title rather than verified identity, and member-only status is a best-effort text hint rather than a verified access flag. Subtitle is always null. Include article details is accepted but has no effect.

Unsupported URLs, non-feed responses, empty feeds and source fetch failures produce diagnostic rows. A succeeded run can contain no article rows, so inspect itemType, status and errorCode rather than counting every row as an article or treating a fetch failure as privacy or deletion. In your destination, compare successive datasets or send alerts yourself: the Actor does not detect new-article changes or send notifications.

### Automation and integrations

#### Save your settings for next time

Once you have an input that works for you, [save it as an Apify task](https://docs.apify.com/actors/running/tasks). This keeps your settings together so you can use them again without filling in the form from scratch.

#### Run on a schedule

Need fresh results regularly? You can [schedule the Actor or a saved task](https://docs.apify.com/actors/running/schedules) to run at a time that suits you.

Each scheduled run collects the data again. If you want to compare results or highlight changes, add that step in your own workflow.

#### Send results to your other tools

Use **n8n, Make or Zapier** to connect this scraper to the rest of your workflow. For example, you could pass its results to an AI assistant or add records to a spreadsheet. Follow the [Apify integration guides](https://docs.apify.com/integrations) for your chosen tool.

For a custom connection, an [Apify webhook](https://docs.apify.com/integrations/webhooks) can notify your app when a run finishes or fails. Your app can then fetch the results or handle the failure.

### API usage

Want to collect this data from your own app or automation? The examples below send input to the scraper and show how to collect its results.

The Node.js and Python examples wait for the run to finish before reading its results. The cURL example starts the run and returns its details. Wait for that run to finish, then use its `defaultDatasetId` to fetch the results.

For setup instructions, see Apify's [JavaScript client guide](https://docs.apify.com/api/client/js), [Python client guide](https://docs.apify.com/api/client/python) and [Actor runs API reference](https://docs.apify.com/api/v2/acts-runs-post).

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~medium-articles-scraper/runs' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  --data @- <<'JSON'
{
  "tags": [
    "artificial-intelligence"
  ],
  "maxItems": 10,
  "maxItemsPerSource": 10,
  "includeSnippetHtml": true
}
JSON
```

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/medium-articles-scraper').call({
  "tags": [
    "artificial-intelligence"
  ],
  "maxItems": 10,
  "maxItemsPerSource": 10,
  "includeSnippetHtml": true
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/medium-articles-scraper').call(run_input={'tags': ['artificial-intelligence'], 'maxItems': 10, 'maxItemsPerSource': 10, 'includeSnippetHtml': True})
print(client.dataset(run['defaultDatasetId']).list_items().items)
```

### MCP and AI agents

You can ask your AI assistant to collect data with **Medium Articles Scraper** and help you work with the results. The scraper returns the data, and your assistant can then summarize it, compare records or prepare notes.

Connect your assistant through the [Apify MCP server](https://mcp.apify.com/). MCP gives your assistant a way to find this scraper, run it and read the results. Follow the [official setup and sign-in guide](https://docs.apify.com/mcp) for your app.

#### Easier setup with an Apify plugin

If you use a supported coding assistant, the [official Apify plugin](https://docs.apify.com/agents/plugins) can set up the connection for you. It connects your assistant to Apify and includes instructions for common tasks. Follow the guide for your particular app.

#### Use Apify AI in Console

Prefer to keep everything in Apify? Open [Apify AI in Console](https://docs.apify.com/account/apify-ai) and ask it to find Fetch Cat's **Medium Articles Scraper**. You can describe the data you want and ask questions about the results.

Apify AI is currently in beta. It asks for confirmation before starting an Actor, and normal run charges apply.

#### Choose your assistant

- **Claude and Claude Code (Anthropic):** [Apify setup guide](https://docs.apify.com/integrations/claude).
- **ChatGPT and Codex (OpenAI):** [Apify setup guides](https://docs.apify.com/integrations/openai).
- **Grok Bot (xAI):** [Apify plugin guide](https://docs.apify.com/integrations/grok-bot).
- **Gemini CLI (Google):** [MCP server setup guide](https://geminicli.com/docs/tools/mcp-server/). Use the server URL below with the HTTP configuration supported by Gemini CLI.

#### Connect just this scraper

To keep your setup focused on this scraper, add this server configuration to a compatible MCP client:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=fetch_cat/medium-articles-scraper"
    }
  }
}
```

Sign in to Apify when your client asks. If your client uses a Bearer token instead, follow its setup guide and keep the token in its secure configuration. Configuration formats vary by app, so use the linked guide if your client needs a different format.

#### Use Apify's general server

Already connected to the general Apify MCP server at `https://mcp.apify.com`? You can use it to find this scraper without adding another server. Ask your assistant to use **Medium Articles Scraper** by Fetch Cat, or give it the identifier `fetch_cat/medium-articles-scraper`.

Your assistant can check the available settings and retrieve the results from the returned run. If the run is still working, it should follow that run rather than start it again. Both connection options use Apify's hosted service.

#### Example requests

- “Use Fetch Cat’s Medium Articles Scraper to collect up to 5 artificial-intelligence tag articles, considering at most 5 items from that source with snippet HTML enabled. Keep article links, titles, dates and available authors for my reading list.”
- “Collect up to 5 recent Medium feed articles from publication the-generator, considering at most 5 items from that source with snippet HTML off. Keep plain snippets and source diagnostics separate, without retrieving full article bodies.”
- “Retrieve up to 5 recent Medium feed articles from author @ev, considering at most 5 items from that source. Keep source IDs, dates and collection time for comparison with my own export, and report diagnostic outcomes without counting them as paid articles.”

Normal Apify charges apply. Check the [live Pricing tab](https://apify.com/fetch_cat/medium-articles-scraper/pricing) before asking your assistant to run a larger batch.

### Pay with x402

If your AI agent has a funded wallet, it can pay for Apify usage through [x402](https://docs.apify.com/integrations/x402). This experimental option lets an agent use Apify without a conventional account.

[Apify AGI](https://agi.apify.com/) provides a prepaid API token with a spending cap after payment. Your agent can use that token to run this scraper through the Apify API or an authenticated MCP connection.

Some MCP setups also support paying for each request directly. That is a different payment option, so check the official guide for its availability.

Follow the official guide for wallet setup, supported payment options and current terms. Apify handles the payments. Keep wallet keys and payment tokens in your agent's secure configuration.

#### Other ways for agents to pay

Apify also supports **MPP** for prepaid access through AGI and **Skyfire** for eligible Actors. If your agent already uses one of these, see the [agentic payment guide](https://docs.apify.com/agents/payments) to choose the right setup.

### FAQ

#### Can I read Medium articles for free or unlock member-only stories?

This Actor exports public feed metadata and available snippets. It does not unlock member-only stories or provide a full-text reader.

#### Can I find Medium articles about AI or AI agents?

Use relevant tags such as `artificial-intelligence`. These are topic feeds, not keyword search. They do not guarantee every article mentioning a phrase.

#### Why are there fewer articles than requested?

Feeds contain limited recent items, duplicate articles are skipped, and a source may be unavailable. Check diagnostic rows for the actual source outcome. An inaccessible response alone does not prove a source is private or deleted.

#### Can I export or automate the results?

Export the dataset as CSV, JSON or Excel, or retrieve it through the API. External workflows can compare successive datasets. This Actor does not itself detect changes or send new-article alerts.

### Related Actors

- [RSS Feed Reader](https://apify.com/fetch_cat/rss-feed-reader) — Read public RSS, Atom or RDF feed entries, without fetching linked full articles.
- [DEV.to Articles Scraper](https://apify.com/fetch_cat/devto-articles-scraper) — Research developer-community articles.
- [Substack Posts Scraper](https://apify.com/fetch_cat/substack-posts-scraper) — Collect Substack publication posts.
- [Google News Scraper](https://apify.com/fetch_cat/google-news-scraper) — Discover news coverage across publishers.
- [Bing Rank Tracker & SERP Scraper](https://apify.com/fetch_cat/bing-search-results-scraper) — Research search-result visibility.

### Support and feedback

For custom additions or integrations, email <hello@fetchcat.dev>.

Found an error or have a feature request? [Open an issue](https://apify.com/fetch_cat/medium-articles-scraper/issues) with the run URL, a non-sensitive input example and what you expected.

Need help sharing it? See [Apify’s guide to sharing a run when reporting an issue](https://docs.apify.com/account/collaboration/general-resource-access#automatically-sharing-runs-via-actor-issues). Sharing a run can give the developer access to its input, logs and results, so use a run that contains no sensitive data. Please leave out API tokens, passwords, cookies, private documents and personal data. Use a public sample URL or a redacted example instead.

Tried this scraper? We'd love to hear how it worked for you. [Leave a review](https://apify.com/fetch_cat/medium-articles-scraper/reviews) to help others choose the right tool and help us improve it. Your feedback means a lot to us.

Made with care for curious people, AI agents and the possibilities in data. ♥

# Changelog

This Actor's version history is a separate document: https://apify.com/fetch_cat/medium-articles-scraper/changelog.md

# Actor input Schema

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

Medium RSS feed URLs are processed directly. Medium tag, author, and publication URLs are normalized to their public /feed/ routes. Direct article HTML URLs are reported as unsupported diagnostics in V1.

## `tags` (type: `array`):

Medium tags or topics. Spaces are converted to Medium tag slugs, for example `data science` becomes `/feed/tag/data-science`.

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

Maximum article rows across all sources, 1–5000. The form default is 20; runtime omission uses 25. Diagnostic rows may be added beyond this cap and are not charged as article rows.

## `maxItemsPerSource` (type: `integer`):

Feed items considered per source before duplicate removal, bounded by maxItems. Form default: 20, allowed 1–500. Runtime omission uses 50, bounded by maxItems. A feed may expose fewer recent items; this does not request historical pages.

## `includeSnippetHtml` (type: `boolean`):

Save the raw feed description/content HTML fragment when Medium includes it. Plain text is always saved as `snippetText`.

## `includeArticleDetails` (type: `boolean`):

Reserved and currently ignored, including when true. This field does not fetch article pages or add full text, claps, responses or subtitle values.

## `authors` (type: `array`):

Medium author handles or profile URLs, for example `@ev` or `https://medium.com/@ev`.

## `publications` (type: `array`):

Medium publication slugs or URLs, for example `the-generator` or `https://medium.com/the-generator`.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://medium.com/feed/tag/artificial-intelligence"
    },
    {
      "url": "https://medium.com/feed/@ev"
    },
    {
      "url": "https://medium.com/feed/the-generator"
    }
  ],
  "tags": [
    "artificial-intelligence",
    "data-science"
  ],
  "maxItems": 20,
  "maxItemsPerSource": 20,
  "includeSnippetHtml": true,
  "includeArticleDetails": false,
  "authors": [
    "@ev"
  ],
  "publications": [
    "the-generator"
  ]
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrls": [
        {
            "url": "https://medium.com/feed/tag/artificial-intelligence"
        },
        {
            "url": "https://medium.com/feed/@ev"
        },
        {
            "url": "https://medium.com/feed/the-generator"
        }
    ],
    "tags": [
        "artificial-intelligence",
        "data-science"
    ],
    "authors": [
        "@ev"
    ],
    "publications": [
        "the-generator"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/medium-articles-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://medium.com/feed/tag/artificial-intelligence" },
        { "url": "https://medium.com/feed/@ev" },
        { "url": "https://medium.com/feed/the-generator" },
    ],
    "tags": [
        "artificial-intelligence",
        "data-science",
    ],
    "authors": ["@ev"],
    "publications": ["the-generator"],
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/medium-articles-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://medium.com/feed/tag/artificial-intelligence"
    },
    {
      "url": "https://medium.com/feed/@ev"
    },
    {
      "url": "https://medium.com/feed/the-generator"
    }
  ],
  "tags": [
    "artificial-intelligence",
    "data-science"
  ],
  "authors": [
    "@ev"
  ],
  "publications": [
    "the-generator"
  ]
}' |
apify call fetch_cat/medium-articles-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fetch_cat/medium-articles-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/YdwHMCkDq2vgWdw4C/builds/NHu1VZGvmwc2yu0fX/openapi.json
