# Reddit Keyword Monitor - Brand Mentions, Leads, Alerts (`offgrid-labs/reddit-keyword-monitor`) Actor

Reddit keyword monitor for brand, competitor and buying-intent mentions: new Reddit posts and comments matching your keywords since the last run, with highlighted snippets, sentiment and webhook-ready alerts. Your own Reddit app key or proxies (shared pools 403 keyless). $0.50 per 1,000 matches.

- **URL**: https://apify.com/offgrid-labs/reddit-keyword-monitor.md
- **Developed by:** [OFFGRID LABS](https://apify.com/offgrid-labs) (community)
- **Categories:** Social media, Automation, Lead generation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 matching posts

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

### Reddit keyword monitor: brand mentions, competitor mentions and leads from new posts and comments

**TL;DR:** Reddit Keyword Monitor finds **new Reddit posts and comments that mention your keywords** (brand, product, competitors or buying-intent phrases) since its previous run, in chosen subreddits or across all of Reddit. Each match comes with the matched keywords, a **highlighted snippet**, optional **sentiment** and a one-line **alert text** ready for Slack, email or webhooks. It reads **Reddit's public JSON endpoints** out of the box, or **Reddit's official Data API** when you add your app credentials, with **built-in proxy routing** (rotation, fail-over, per-proxy health) for reliable access. You pay **$0.50 per 1,000 new matches**; scanned items that don't match are free.

Schedule it every 15 minutes, hourly or daily: the monitor keeps its position in a **named key-value store**, so every run returns only items it has not returned before.

### What data you get

One dataset row per **new** matching post or comment.

| Field | What it is | Example |
|---|---|---|
| `recordType` | `post` or `comment` (one charged event each) | `comment` |
| `matchedKeywords` | Keywords found (whole words / phrases, case-insensitive) | `["acme"]` |
| `highlight` | Snippet around the first match, matches wrapped in `**` | `I switched to **acme** last month...` |
| `sentiment`, `sentimentScore` | Lexicon sentiment `positive` / `negative` / `neutral` and score -1..1 | `positive`, `0.71` |
| `alertText` | One-line alert for Slack / webhooks | `[r/SaaS] comment by u/x matching "acme": ... - https://...` |
| `subreddit`, `author`, `title`, `body` | Where, who and what | `SaaS`, `some_user` |
| `url`, `postId`, `postTitle`, `parentId` | Permalink and thread context | `https://www.reddit.com/r/...` |
| `score`, `numComments`, `createdAt`, `createdUtc` | Engagement and time | `12`, `2026-11-03T10:15:00.000Z` |
| `monitorId`, `source`, `sourceUrl` | Monitor state key, stream and API endpoint | `acme-brand`, `new-comments:r/SaaS` |
| `demo`, `scrapedAt` | `true` only for the uncharged demo sample; read time | `false` |

Plus the full unified Reddit schema shared with **Reddit Scraper API** (flags, flair, deleted/removed state). `RUN_SUMMARY` holds the window start, new posts/comments, items scanned, duration, API requests, retries, HTTP 429 count and coverage notes.

| Mode | Posts | Comments | Coverage |
|---|---|---|---|
| **Chosen subreddits** | Every new post (`/r/a+b/new`) back to the last run, matched locally | Every new comment (`/r/a+b/comments`) back to the last run | Complete, up to **Max items scanned** per run |
| **All of Reddit** (Subreddits empty) | Reddit search per keyword, newest first, re-checked locally | Newest comments across r/all | Posts: as good as Reddit search. Comments: partial (no comment search exists; r/all's stream covers only the last few minutes) |

### Use cases

- **Brand monitoring**: every new mention of your product in the communities your customers use, with sentiment.
- **Competitor tracking**: mentions of competitors next to words like "alternative", "switch" or "pricing".
- **Lead generation**: buying-intent phrases such as `"looking for a tool"` or `"any recommendations for"` in niche subreddits.
- **Support and PR alerts**: negative mentions to Slack within minutes on a 15-minute schedule.
- **Community research**: a running log of how a topic is discussed over time.

### How to monitor Reddit for keywords

1. (Optional) To use the official Data API, create a Reddit app at <https://www.reddit.com/prefs/apps> → **create another app** → type **web app** (or script), any redirect URI (e.g. `http://localhost`). Copy the **client ID** and **secret**, then paste them into **Reddit client ID** and **Reddit client secret**. Leave both empty to use the public JSON path instead.
2. For reliable live access, either add your own proxies under **Proxy routing** (any HTTP/SOCKS list; rotation, fail-over and per-proxy health checks are built in — see the [PROXY.md](../../reddit-scraper/PROXY.md) guide), or create a free Reddit app (step 1, 2 minutes) and use the official Data API.
3. Add **Keywords** (and optional **Exclude keywords**). A trailing `*` matches word prefixes (`scrap*` = scraper, scraping).
4. Add **Subreddits** for complete coverage, or leave empty for all of Reddit.
5. Run once (looks back **First-run look-back** hours, default 24), then add a **Schedule** (e.g. every 15 minutes). Each run returns only new matches.
6. Optional: connect a **webhook** or the Slack/email integration on "run succeeded" and post `alertText` of each row.

Turn on **Demo mode** to get fixed sample matches built from your keywords (`demo: true`, never charged, state untouched).

### Input example

```json
{
  "clientId": "<optional: your Reddit app client ID>",
  "clientSecret": "<optional: your Reddit app secret>",
  "keywords": ["acme", "acme.io", "\"looking for a crm\""],
  "excludeKeywords": ["hiring"],
  "subreddits": ["SaaS", "startups", "smallbusiness"],
  "monitorId": "acme-brand",
  "lookbackHours": 24,
  "sentiment": true,
  "publicRequestBudget": 300
}
```

### Output example

```json
{
  "recordType": "comment",
  "id": "demom02",
  "subreddit": "demo",
  "author": "demo_user_2",
  "body": "I switched to apify last month and I love it, setup was fast and support was helpful. (Demo data: ...)",
  "url": "https://www.reddit.com/wiki/api/",
  "createdAt": "2026-11-03T00:02:00.000Z",
  "monitorId": "kw-3f1c0a9b2d4e",
  "matchedKeywords": ["apify"],
  "highlight": "I switched to **apify** last month and I love it, setup was fast and support was helpful...",
  "sentiment": "positive",
  "sentimentScore": 1,
  "alertText": "[r/demo] comment by u/demo_user_2 matching \"apify\": I switched to **apify** last month ... - https://www.reddit.com/wiki/api/",
  "source": "demo",
  "demo": true
}
```

(Shortened demo row; live rows have `demo: false`, real permalinks and the endpoint used in `sourceUrl`.)

### Pricing: how much does Reddit monitoring cost?

Pay per event, flat on every Apify plan:

| Event | Price | Per 1,000 |
|---|---|---|
| New matching post | $0.0005 | **$0.50** |
| New matching comment | $0.0005 | **$0.50** |
| Actor start | $0.00005 | Apify default |

- Only **new matches** are charged. Scanned non-matching items, items already returned by an earlier run, deleted/removed items, excluded matches and demo rows are free.
- Example: 40 new mentions a day on a 15-minute schedule ≈ $0.02 + 96 starts × $0.00005 ≈ **$0.025 per day (~$0.75/month)**.
- If **Maximum cost per run** cuts a run short, the monitor saves its position at the last returned item, so nothing is skipped next run.

### Speed and reliability

- **Speed**: each API request returns up to 100 posts or comments; with your own OAuth client, Reddit's documented limit is about **100 requests per minute**. Matching, highlighting and sentiment run locally in microseconds. Every run reports items scanned per second in `RUN_SUMMARY`.
- **Public path budget**: when running without credentials, the actor uses a rotating, descriptive User-Agent and a hard per-run request budget (**Public path request budget**, default 300). Reaching the budget ends the run cleanly with whatever was collected.
- **No duplicates**: a time watermark plus a 10-minute overlap window and a set of the last 5,000 returned IDs per monitor.
- **Rate limits**: reads `X-Ratelimit-Remaining` / `X-Ratelimit-Reset` when present, pauses before the window runs out, waits on HTTP 429 and retries 5xx with exponential back-off. If a run fails, the state is not advanced, so the next run covers the same window.
- **Clean failures**: if OAuth credentials are rejected the run falls back to the public path; a hard failure leaves state unchanged, so the next run covers the same window. Health-checked every 6 hours on the Apify platform.

### Proxy & routing

**We tested every Apify proxy pool so you don't have to** (Nov 3, 2026). Reddit currently refuses unauthenticated requests from *all* of Apify's shared pools — datacenter, residential, and Unblocker alike — and a browser User-Agent doesn't change that: the refusal comes back in ~30 ms, straight from the edge. So if you want keyless operation, bring your own premium proxies in `proxyList` — high-end residential pools sit outside Reddit's block ranges, and the router handles rotation, fail-over and per-proxy health for you. The zero-infrastructure route is a free Reddit app key (2 minutes, step 1 above), which talks to the official API and works from any IP. And if every request in a run is refused, the actor says exactly this in the run log and charges you nothing — no silent empty results.

Want requests to leave from your own IPs, or rotate exit IPs to spread load? Both the OAuth and
public-JSON paths route through an optional proxy router (`src/proxy.js`); demo mode stays network-free.

- **Sources (precedence)**: your `proxyList` (`http(s)://user:pass@host:port` or `host:port`, one per line) > Apify-managed proxy (`useApifyProxy` + `proxyGroups`) > direct connection.
- **Rotation**: `round_robin` (default), `random`, or `sticky_window` (hold one proxy for `stickyWindow` requests, default 15).
- **Failover & health**: on `403`/`429`/`5xx`/timeout the request retries on the next healthy proxy (up to `proxyMaxRetries`, default 2); proxies cool down with exponential back-off (base 30 s, cap 10 min) and are blacklisted after `proxyMaxFailures` (default 5) consecutive failures or a proxy-auth rejection (HTTP 407 / 401 with a proxy-auth header).
- **Safety**: proxy credentials are memory-only — the summary shows a masked host:port and an `effective_proxy_count`; credentials are never logged or stored.

All proxy fields are optional; leave them empty for the direct path. Full details: [`PROXY.md`](./PROXY.md).

### How it compares

| Approach | Setup | Only new items | Output | Cost |
|---|---|---|---|---|
| **This actor** | Optional app credentials (2 min), or none | Yes, saved state per monitor | Highlight, sentiment, alert text, full post/comment fields | $0.50 / 1k new matches |
| Reddit's own notifications | Logged-in account | Partly | Notifications, no export | Free, manual |
| DIY script on the official API | App + code + server + state store | You build it | Whatever you build | Your time and servers |
| Social listening suites | Contract | Yes | Dashboards | Usually monthly subscriptions |

### FAQ

#### How do I get alerts when my brand is mentioned on Reddit?

Add your brand names as keywords, run the actor on a Schedule (every 15 minutes to daily) and attach a webhook or Slack integration to "run succeeded". Each row's `alertText` is a ready-made message.

#### Does it return the same post twice?

No. State is kept per **Monitor ID** in a named key-value store (`reddit-keyword-monitor-state` by default). Use different Monitor IDs for independent monitors, or **Reset state** to start over.

#### Can it monitor Reddit comments, not just posts?

Yes. With chosen subreddits every new comment is checked. Across all of Reddit only the newest r/all comments are scanned, because no comment search exists; choose subreddits for complete comment coverage.

#### Do I need a Reddit API key?

No key is required if you bring your own proxies (`proxyList`). Note that we tested Apify's managed proxy pools on Nov 3, 2026 and Reddit currently refuses them all — so the most reliable zero-infrastructure route is a free Reddit app: create one at <https://www.reddit.com/prefs/apps>, paste the client ID and secret, and the actor uses the official Data API from any IP. Demo mode returns a small uncharged sample either way.

#### How is sentiment calculated?

A small built-in word list (positive/negative words, simple negation such as "not great"). It is a quick triage signal, not an AI model; turn it off with **Add simple sentiment**.

#### How do keywords match?

Case-insensitive, whole words and phrases (`acme` does not match `acmes`), flexible spacing in phrases, and prefix wildcards with `*`. **Exclude keywords** drop an item if any appears.

#### Can an AI agent use this Reddit monitor?

Yes. Through the Apify MCP server an agent can call it, for example "what did Reddit say about our product since yesterday?". See **Integrations**.

#### Something wrong?

Open an issue on the Issues tab; we aim to respond within 24 hours.

### Integrations

- **API**: `POST https://api.apify.com/v2/acts/offgrid-labs~reddit-keyword-monitor/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>` with the input JSON returns the new matches directly.
- **Webhooks**: add an `ACTOR.RUN.SUCCEEDED` webhook; read `resource.defaultDatasetId` and post each `alertText`.
- **Python / JavaScript**: `client.actor("offgrid-labs/reddit-keyword-monitor").call(run_input={...})` with `apify-client`.
- **No-code**: **Make**, **Zapier**, **n8n**, Slack, Google Sheets and Schedules.
- **MCP / AI agents**: `https://mcp.apify.com?tools=offgrid-labs/reddit-keyword-monitor`.

### Changelog

- **2026-11-03** · First release: chosen-subreddit and all-Reddit modes, posts and comments, whole-word/phrase/prefix matching with excludes, highlighted snippets, lexicon sentiment, alert text, named key-value store state with watermark + dedupe, rate-limit handling, demo mode. Credentials optional — official OAuth Data API when supplied, public JSON path with a request budget otherwise.

### Related actors

| Actor | What it does |
|---|---|
| Reddit Scraper API | Posts and full comment trees from subreddits, search, post URLs and user profiles |
| Tech Stack Detector | Technologies used by the companies that mention you |
| Company Registry Lookup (KYB) | Official company records for leads you find |

***

```
// OFFGRID LABS ─────────────────────────────────────────────
// status: monitored 24/7 by a self-hosted agent swarm
// health checks: every 6h · auto-repair + rollback on failure
// sources: official public APIs and open data only
// support: open an issue — human-reviewed response within 24h
// ───────────────────────────────────────────────────────────
```

# Actor input Schema

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

Optional. Client ID of your own Reddit app (the string under the app name at https://www.reddit.com/prefs/apps). Used only for application-only OAuth (client_credentials grant, read-only). Leave empty with the secret to use the public JSON path. Example: p-jcoLKBynTLew

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

Optional. Secret of the same Reddit app (field labelled "secret" at https://www.reddit.com/prefs/apps). Stored encrypted by Apify; never logged. If the ID/secret is rejected, the actor falls back to the public JSON path.

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

Name of your Reddit app, sent as a descriptive User-Agent when OAuth credentials are provided. Example: my-brand-monitor

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

Optional. Reddit username that owns the app; appended to the User-Agent as (by /u/<name>). Not used to log in.

## `keywords` (type: `array`):

Brand names, product names, competitor names or buying-intent phrases, one per line (max 50). Case-insensitive whole-word / whole-phrase match in post titles, post text and comments; a trailing \* matches word prefixes (scrap\* = scraper, scraping). Example: apify, "looking for a scraper"

## `excludeKeywords` (type: `array`):

Optional. Items containing any of these words/phrases are dropped (not saved, not charged). Example: hiring, job offer

## `subreddits` (type: `array`):

Optional. Subreddits to watch, one per line (webscraping, r/webscraping or the URL). With subreddits, every new post and comment in them is read back to the last run and matched locally (complete coverage). Empty = all of Reddit: posts via Reddit search per keyword, comments from the newest r/all comment stream (partial, see README).

## `searchPosts` (type: `boolean`):

Find new posts whose title or text matches. Default true.

## `scanComments` (type: `boolean`):

Find new comments whose text matches. Default true.

## `lookbackHours` (type: `integer`):

How far back the FIRST run of a monitor looks. Later runs return only items newer than the previous run (state is kept in a named key-value store). Default 24. Example: 72

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

Optional. Name of this monitor's saved state, so several schedules can watch different keyword sets independently. Empty = derived from the keywords + subreddits (changing them starts a new monitor). Example: acme-brand

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

Named key-value store (in your Apify account) that keeps the last-seen position per Monitor ID. Default reddit-keyword-monitor-state.

## `resetState` (type: `boolean`):

If true, ignore the saved state for this Monitor ID and look back First-run look-back hours again. Default false.

## `maxPostsPerKeyword` (type: `integer`):

All-of-Reddit mode: maximum search results read per keyword per run (Reddit search stops at about 1,000). Default 250.

## `maxItemsScanned` (type: `integer`):

Maximum posts or comments read from each new-posts / new-comments stream per run (each 100 items = 1 API request). Only matching items are saved and charged. Default 1000.

## `caseSensitive` (type: `boolean`):

If true, keywords match only with the same capitalisation. Default false.

## `sentiment` (type: `boolean`):

If true (default), each match gets a lexicon-based sentiment (positive/negative/neutral) and score from -1 to 1. Free; computed locally, no AI service.

## `skipNsfw` (type: `boolean`):

If true, NSFW posts/comments are skipped and not charged. Default false.

## `demo` (type: `boolean`):

If true, the actor returns a small fixed sample built from your keywords (demo: true) without contacting Reddit, and never charges or changes monitor state. Turn it off for live monitoring (public JSON path or your own OAuth credentials).

## `publicRequestBudget` (type: `integer`):

Maximum HTTP requests the public (no-credential) JSON path may make per run. Reaching it ends the run cleanly with whatever was collected. Ignored when OAuth credentials are used. Default 300.

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

One proxy per line (or comma-separated), as http(s)://user:pass@host:port or host:port (credentials optional). The actor rotates across them and fails over to the next healthy one on 403/429/5xx/timeout. Leave empty to connect directly (or pair with Use Apify proxy).

## `useApifyProxy` (type: `boolean`):

If true (and no proxy list is supplied), route requests through Apify's managed proxy using the group chosen below. Requires Apify proxy to be enabled for this actor. Default false.

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

Apify proxy pool: DATACENTERS (fastest), RESIDENTIAL (rotating IPs), or UNBLOCKER (most reliable against blocking).

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

How proxies are chosen. round_robin cycles in order (default); random picks uniformly; sticky_window holds one proxy for the configured window then moves on. Default round_robin.

## `stickyWindow` (type: `integer`):

Requests per proxy before rotating, when rotation strategy is sticky_window. Default 15.

## `proxyMaxRetries` (type: `integer`):

How many additional proxies to try after a request fails (403/429/5xx/timeout) before giving up on that request. Default 2.

## `proxyMaxFailures` (type: `integer`):

Consecutive failures after which a proxy is blacklisted (skipped) for the rest of the run. A proxy-auth rejection (407/401) blacklists immediately. Default 5.

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

Optional. Overrides the default User-Agent sent on the public JSON path (ignored on the official Data API path).

## Actor input object example

```json
{
  "appName": "my-brand-monitor",
  "keywords": [
    "web scraping api",
    "apify"
  ],
  "searchPosts": true,
  "scanComments": true,
  "lookbackHours": 24,
  "stateStoreName": "reddit-keyword-monitor-state",
  "resetState": false,
  "maxPostsPerKeyword": 250,
  "maxItemsScanned": 1000,
  "caseSensitive": false,
  "sentiment": true,
  "skipNsfw": false,
  "demo": true,
  "publicRequestBudget": 300,
  "useApifyProxy": false,
  "proxyGroups": "RESIDENTIAL",
  "proxyRotation": "round_robin",
  "stickyWindow": 15,
  "proxyMaxRetries": 2,
  "proxyMaxFailures": 5
}
```

# Actor output Schema

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

Compact table of new matches: type, subreddit, matched keywords, highlighted snippet, sentiment, author, time, permalink, demo flag.

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

Every new matching post/comment with the unified Reddit schema plus matchedKeywords, highlight, sentiment, sentimentScore, alertText and monitorId.

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

RUN_SUMMARY: mode, monitor ID, window start, new posts/comments, items scanned, charged events, duration, API requests, retries, HTTP 429 count, coverage notes.

# 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 = {
    "appName": "my-brand-monitor",
    "keywords": [
        "web scraping api",
        "apify"
    ],
    "lookbackHours": 24,
    "demo": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("offgrid-labs/reddit-keyword-monitor").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 = {
    "appName": "my-brand-monitor",
    "keywords": [
        "web scraping api",
        "apify",
    ],
    "lookbackHours": 24,
    "demo": True,
}

# Run the Actor and wait for it to finish
run = client.actor("offgrid-labs/reddit-keyword-monitor").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 '{
  "appName": "my-brand-monitor",
  "keywords": [
    "web scraping api",
    "apify"
  ],
  "lookbackHours": 24,
  "demo": true
}' |
apify call offgrid-labs/reddit-keyword-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,offgrid-labs/reddit-keyword-monitor"
        }
    }
}
```

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/UbbSf8z142H3F9cBk/builds/5GhoLvg7XNNIoeZww/openapi.json