# Grammarly Email Scraper (`email_scraper/grammarly-email-scraper`) Actor

Grammarly Email Scraper extracts public contact emails tied to Grammarly-related profiles and pages by keyword, supporting edtech partnership and SaaS outreach.

- **URL**: https://apify.com/email_scraper/grammarly-email-scraper.md
- **Developed by:** [Email Scraper](https://apify.com/email_scraper) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

### 🔍 Grammarly Email Scraper – Overview

The Grammarly Email Scraper finds public email addresses on Grammarly and turns them into a clean, structured email list. Enter one or more keywords, optionally add a city or country, and the Grammarly Email Scraper collects every email address that appears in public Grammarly results, together with the page title, description and link where it was found.

Grammarly is an AI writing assistant. If you need to reach writers and editors, this Grammarly email extractor replaces hours of manual copy-and-paste and speeds up lead generation. No Grammarly login is required, and your results can be exported as JSON, CSV or Excel or pulled into your own tools through the Apify API. 🚀

> ✨ **Grammarly Email Scraper at a glance**
>
> - **Platform:** Grammarly (grammarly.com)
> - **What you get:** public email addresses of writers and editors
> - **How you search:** keywords, locations and email domains
> - **Data:** email, page title, description, link and lead details
> - **Best for:** B2B lead generation, prospecting and outreach
> - **Export:** JSON, CSV, Excel or the Apify API

***

### ⭐ Grammarly Email Scraper – Key Features

The Grammarly Email Scraper is built for fast, repeatable Grammarly lead generation:

- **All-in-one email finder** – the Grammarly Email Scraper locates Grammarly pages for your keywords and extracts the email addresses shown there, so the Grammarly Email Scraper is both an email finder and an email extractor for Grammarly.
- **Grammarly keyword search** – run several keywords in one go, such as "writer" and "editor", and collect contact data for each.
- **Location targeting** – narrow Grammarly results to a country, state or city, or add a list of extra locations that are each searched on their own.
- **Email domain control** – look for @gmail.com, @yahoo.com, @outlook.com or your own suffixes, accept any address, or keep business emails only.
- **Must-include and exclude words** – keep only Grammarly results that mention the words you need and skip snippets with words you do not want.
- **Limits that protect your budget** – cap the emails per search combination and set one total limit for the whole run.
- **Parallel searches** – the Grammarly Email Scraper can run up to 10 Grammarly searches at the same time to finish long keyword lists sooner.
- **Duplicate-free results** – an email found by several Grammarly searches is saved only once, so your email list stays clean.
- **Do-not-contact list** – keep opted-out addresses and existing contacts out of your dataset.
- **Lead history** – skip emails you already collected in earlier runs, so you only get new leads.
- **Optional extras** – add phone numbers shown in the result text and check email domains before saving.
- **Resumable runs** – an interrupted Grammarly Email Scraper run continues from its saved progress instead of starting over.
- **Only Grammarly results** – results from other websites are dropped, so every row links to a page on Grammarly.

***

### 📊 Grammarly Email Scraper – What Data You Can Extract

The Grammarly Email Scraper saves one row of Grammarly contact data for every unique email address:

| Field | What it contains |
| --- | --- |
| `network` | Source label, `Grammarly.com` |
| `keyword` | The keyword that produced the Grammarly result |
| `title` | Title of the Grammarly result |
| `description` | Result text in which the email appeared |
| `url` | Link to the Grammarly page |
| `email` | The email address |
| `location` | Location used for the search, or null |
| `emailType` | `free` for webmail providers, `business` for other domains |
| `username` | Handle or first path segment of the Grammarly link, when it can be read |
| `followersCount` | Follower count if the result text shows one, otherwise null |
| `influencerTier` | Under 1K, Nano, Micro, Macro or Mega, from the follower count; null if unknown |
| `emailStatus` | Only with email verification: `valid` or `unverified` |
| `phoneNumbers` | Only with phone extraction: numbers found in the result text |

> 💡 **Good to know:** the Grammarly Email Scraper reads the public text shown for each Grammarly result. Only email addresses that are visible there can be found, so results depend on what Grammarly users publish.

***

### 🚀 Grammarly Email Scraper – How to Use It

Getting your first Grammarly email list with the Grammarly Email Scraper takes only a few minutes:

- **Step 1 – Open the Actor:** open the Grammarly Email Scraper in Apify Store and click Start.
- **Step 2 – Add keywords:** enter one or more Grammarly search terms, for example "writer".
- **Step 3 – Set a location (optional):** type a country or city such as San Francisco, or leave the field empty.
- **Step 4 – Choose email types:** keep @gmail.com or add other suffixes, or switch the email mode to any address or business emails only.
- **Step 5 – Set limits:** decide how many emails each combination may collect and, if you like, a total for the run.
- **Step 6 – Run and export:** start the Grammarly Email Scraper, follow the dataset as it fills, then download JSON, CSV or Excel.

***

### 🎯 How to Extract Grammarly Emails by Keyword and Location

Every Grammarly keyword is combined with every location and every email suffix, and each combination is its own search with its own email target. Two keywords, three locations and two suffixes make 12 searches. With the Grammarly Email Scraper, use the total limit to keep large Grammarly runs predictable, and use the extra locations list to cover many cities, for example San Francisco, in a single run. A search for "writer" in San Francisco is one combination, and "editor" in San Francisco is another.

***

### 🧭 Can You Filter Grammarly Email Scraper Results by Email Domain?

Yes. The email mode setting of the Grammarly Email Scraper has three options:

- **Only the domains listed** – the default; finds exactly the suffixes you enter, such as @gmail.com.
- **Any email address** – accepts every address found in Grammarly result text, whatever the domain.
- **Business emails only** – accepts any address except free webmail providers like Gmail, Yahoo or Outlook, which suits B2B outreach on Grammarly.

The two broad modes find addresses a fixed list would miss, but expect fewer results per search and some noise.

***

### 💼 Grammarly Email Scraper – Use Cases

Teams use the Grammarly Email Scraper for:

- **Writing tool outreach** – a ready email list of writers and editors that you can contact right away.
- **Editor recruiting** – search "writer" in San Francisco or any other place and compare the Grammarly results by location.
- **Content partnerships** – export the contact data to your CRM, spreadsheet or B2B outreach tool.
- **Finding freelance writers** – schedule the Grammarly Email Scraper to keep your Grammarly lead generation running.

Because the Grammarly Email Scraper returns structured data, it fits manual research as well as automated lead generation and outreach pipelines.

***

### ⚙️ Grammarly Email Scraper – Input

The Grammarly Email Scraper accepts the fields below. Only `keywords` is required; every other field has a default.

| Field | Type | Default | What it does |
| --- | --- | --- | --- |
| `keywords` | list | `["writer", "editor"]` | Keywords to look for, one per line. Each keyword runs on its own. |
| `location` | text | empty | Optional country, state or city added to every search. |
| `locations` | list | `[]` | Extra places, each searched separately with the same keywords. |
| `emailSearchMode` | text | `domainList` | Which emails to look for: your domain list, any address, or business emails only. |
| `customDomains` | list | `["@gmail.com"]` | Email suffixes to look for, such as @gmail.com or @yahoo.com. |
| `maxEmails` | number | `5` | Emails per search combination (keyword + location + domain). Free accounts: 100 at most. |
| `maxTotalEmails` | number | `0` | Hard stop for the whole run. 0 means no total limit. |
| `maxConcurrentSearches` | number | `5` | How many searches run at the same time (1 to 10). |
| `minFollowers` | number | `0` | Keep only results showing at least this many followers. 0 switches it off. Mostly useful on social profiles. |
| `maxFollowers` | number | `0` | Keep only results showing at most this many followers. 0 switches it off. Mostly useful on social profiles. |
| `profilesOnly` | true/false | `false` | Keep only results whose link looks like a single profile page. Mostly useful on social profiles. |
| `includeWords` | list | `[]` | A result is kept only if it contains at least one of these words. |
| `excludeWords` | list | `[]` | Results containing any of these words are skipped. |
| `extractPhoneNumbers` | true/false | `false` | Also return phone numbers written in the result text. |
| `verifyEmails` | true/false | `false` | Check format, placeholders and mail servers before saving an address. |
| `skipPreviouslyFoundEmails` | true/false | `false` | Skip addresses saved by earlier runs under the same history name. |
| `historyStoreName` | text | `grammarly-email-history` | Name of the saved history (lowercase letters, numbers, hyphens). |
| `excludeEmails` | list | `[]` | Addresses or @domains that must never appear in the results. |

#### 🧪 Example input

```json
{
  "keywords": ["writer", "editor"],
  "location": "San Francisco",
  "emailSearchMode": "domainList",
  "customDomains": ["@gmail.com", "@yahoo.com"],
  "maxEmails": 20,
  "maxTotalEmails": 100,
  "maxConcurrentSearches": 5,
  "excludeWords": ["spam"]
}
```

***

### 📦 Grammarly Email Scraper – Output

Results are written to the run's dataset as they are found, so you can watch the Grammarly list grow. Each item contains the fields described above. A short run summary (unique emails, skipped results by reason, searches finished) is also stored with the run.

#### 🧾 Example output

```json
[
  {
    "network": "Grammarly.com",
    "keyword": "writer",
    "title": "Writer in San Francisco | Grammarly",
    "description": "Example listing for writer in San Francisco. Contact: sample.contact@gmail.com",
    "url": "https://grammarly.com/sample_writer",
    "email": "sample.contact@gmail.com",
    "location": "San Francisco",
    "emailType": "free",
    "username": "sample_writer",
    "followersCount": null,
    "influencerTier": null
  },
  {
    "network": "Grammarly.com",
    "keyword": "editor",
    "title": "Second example result | Grammarly",
    "description": "Another example description with sample.team@yahoo.com in the text.",
    "url": "https://grammarly.com/sample_writer_2",
    "email": "sample.team@yahoo.com",
    "location": "San Francisco",
    "emailType": "free",
    "username": "sample_writer_2",
    "followersCount": null,
    "influencerTier": null
  }
]
```

The data above is example data that shows the structure of Grammarly results.

***

### 💰 Grammarly Email Scraper – Pricing

The Grammarly Email Scraper uses Apify's pay-per-result model: you pay for the Grammarly emails that are saved to your dataset. Duplicates, addresses removed by your filters and addresses that fail verification are not saved or charged.

- **Keep costs predictable:** set `maxEmails`, `maxTotalEmails` and the maximum cost of the run.
- **Free Apify plans:** up to 100 emails per search combination.
- **Current rates:** see the pricing information on the Actor page.

***

### ✅ Grammarly Email Scraper – Tips and Best Practices

Get more from the Grammarly Email Scraper with these habits:

- **Use several specific keywords** – instead of only one broad Grammarly term, try close variations such as "writer" and "editor".
- **Start small** – run the Grammarly Email Scraper with a low `maxEmails` first, check the results, then scale up.
- **Loosen the search if results are sparse** – add more email suffixes, more keywords or clear the location.
- **Use include and exclude words** – they keep the email list relevant and remove noise.
- **Raise parallel searches** – 5 to 10 searches at once finish long runs sooner.
- **Use lead history for repeat runs** – switch on skipping of earlier emails so each run returns new leads only and your outreach never repeats.

***

### ❓ Grammarly Email Scraper – Frequently Asked Questions

#### 💬 What is the Grammarly Email Scraper?

It is an Apify Actor and email finder that extracts public email addresses from Grammarly based on your keywords and saves them as structured data, ready for outreach.

#### 💬 Who is the Grammarly Email Scraper for?

It is for anyone who needs contact data for writers and editors: sales teams, recruiters, agencies and researchers. Typical goals are writing tool outreach and editor recruiting.

#### 💬 How does the Grammarly Email Scraper find emails on Grammarly?

It searches public results for Grammarly pages with each keyword and reads the email addresses shown in the result title and description. Results from other websites are skipped.

#### 💬 Do I need to log in to Grammarly to use the Grammarly Email Scraper?

No. The Grammarly Email Scraper works without any Grammarly login or account.

#### 💬 Can I extract Grammarly emails for a specific city or country?

Yes. Use the location field for one place or the locations list for several, for example San Francisco. Each location is searched separately.

#### 💬 What data does the Grammarly Email Scraper return?

Each row has the email address, the keyword, the page title, description and link, the location, the email type and optional follower, phone and verification fields.

#### 💬 Can the Grammarly Email Scraper get phone numbers from Grammarly as well?

Yes, optionally. Switch on phone extraction and the Grammarly Email Scraper adds the numbers written in the result text to the `phoneNumbers` field.

#### 💬 Why did my Grammarly run return fewer emails than expected?

The Grammarly Email Scraper can only find addresses that are publicly shown for Grammarly results. Try more keywords, more email suffixes, a broader location or the any-address mode.

#### 💬 How do I export Grammarly emails to CSV or Excel?

Open the run's dataset and choose CSV, Excel or JSON, or fetch the email list through the Apify API.

#### 💬 Is the Grammarly Email Scraper an email finder or an email extractor?

Both. The Grammarly Email Scraper finds Grammarly pages for your keywords and extracts the email addresses shown there, so it works as an email finder and an email extractor for Grammarly.

***

### 🤝 Support

Questions, ideas or a custom scraper for Grammarly? The Grammarly Email Scraper is actively maintained, so get in touch:

- contact me by email : alphascraper69@gmail.com

# Actor input Schema

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

A list of keywords or queries to search for.

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

Optional country, state or city used to narrow the search. Leave it empty to search without a geographic filter.

## `locations` (type: `array`):

Optional extra countries, states or cities, so one run can cover many places, for example: Miami, Austin, Denver. Every location is searched on its own with the same keywords and domains, in addition to the Region / Location field above if that is filled in. Each keyword + location + domain combination gets its own email limit. The searches multiply: 3 keywords × 5 locations × 2 domains = 30 combinations, so pair a long list with the total email limit below. An email found under more than one location is only saved once.

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

Controls how email addresses are matched. 'Only the domains listed' searches for exactly the suffixes you enter in the field below (the original behaviour). 'Any email address' accepts every address found in a profile description, whatever the domain. 'Business emails only' accepts any address except those from free webmail providers (Gmail, Yahoo, Outlook, Hotmail, iCloud, AOL, Proton and similar), which is the better choice for B2B outreach. The two broad modes find emails that a fixed domain list would miss, but expect fewer results per search and some noise, so combine them with 'Verify email domains' and consider adding Exclude words.

## `customDomains` (type: `array`):

List of custom email domains. Used when 'Which emails to look for' is set to 'Only the domains listed'; ignored in the 'Any email address' and 'Business emails only' modes.

## `maxEmails` (type: `integer`):

How many addresses each search keyword + domain suffix combination may collect before the finder moves on to the next one. This is a per-combination target, not a run-wide total: with 3 keyword and 2 Domains and a limit of 20, the run works through all 6 combinations and aims for up to 20 addresses in each, so up to 120 overall. Lower values finish sooner and cost less; higher values dig deeper but never guarantee a fuller result, since the run can only find what is publicly listed. In the 'Any email address' and 'Business emails only' modes there is no domain to combine with, so the limit applies per keyword.

## `maxTotalEmails` (type: `integer`):

A hard stop for the entire run, across every keyword and domain combination. Once this many emails have been collected the run finishes cleanly and keeps everything found so far. Use it to keep pay-per-result costs predictable: for example, 20 keywords with a per-combination limit of 50 could otherwise return up to 1,000 emails. Leave at 0 to rely only on the per-combination limit above.

## `maxConcurrentSearches` (type: `integer`):

Every keyword + location + domain combination is its own search, and the searches do not depend on each other, so the Actor can run several at the same time instead of one after another. Most of a search is spent waiting for Google, so 4 searches at a time finish a long list roughly 3 to 4 times sooner, at the same cost per result. Limits, duplicate removal, filters and the total limit work exactly as before: an email found by two searches at once is still saved only once, and the total limit is never exceeded. What changes is the order: rows arrive as searches finish, and an email that several searches find is credited to whichever found it first. Set 1 to run one search at a time in the original order. Higher numbers finish sooner but send more requests at once, which can slow Google's answers down; 10 is the maximum. It makes no difference when there is only one search.

## `minFollowers` (type: `integer`):

Only keep profiles with at least this many followers. Handy for skipping empty or brand-new accounts. When a follower filter is set, results whose follower count Google does not show (and all posts and reels) are skipped, so expect fewer rows than without the filter.

## `maxFollowers` (type: `integer`):

Only keep profiles with at most this many followers. Combine with the minimum to target a range, for example 10,000 to 100,000 for micro-influencers. Profiles for which Google shows no follower count are skipped when this filter is set.

## `profilesOnly` (type: `boolean`):

Most Google results for Grammarly are not profiles: they are individual posts, reels, explore / tag pages, and they are often job ads or captions rather than a person you can contact. Switch this on to keep only results that point to a profile page (grammarly.com/username), so every saved row is one account and nothing else is saved or charged. Recommended for influencer and B2B lead lists. It is ticked by default when you start a run in the Console; API calls and saved tasks keep it off unless you set it, so existing setups behave as before.

## `includeWords` (type: `array`):

Words or phrases that must appear in the profile's title or description snippet. A result is kept only if it contains at least one of them, for example: coach, agency, booking, collab. Matching ignores letter case, and single words only match as whole words. Leave empty to keep every result. This is stricter than the search keywords, which Google matches loosely. If a result contains both an include word and an exclude word, it is skipped.

## `excludeWords` (type: `array`):

Words or phrases you do not want to see, for example: crypto, onlyfans. If any of them appears in a profile's description snippet, that whole snippet is skipped and no email address is taken from it. Matching ignores letter case, and single words only match as whole words. Leave empty to keep every snippet.

## `extractPhoneNumbers` (type: `boolean`):

Also pick up phone and WhatsApp numbers that are written in the profile description and return them in a phoneNumbers field next to the email. Off by default because phone numbers are personal data and some number-like text can be misread, so review them before use.

## `verifyEmails` (type: `boolean`):

Checks every address before it is saved: it must be a well-formed address, must not be an obvious placeholder (such as example@gmail.com or yourname@gmail.com), and its domain must have working mail servers (DNS MX lookup). Addresses that fail are dropped, so they are not saved or charged. Saved rows get an emailStatus of 'valid' or 'unverified' (when the DNS lookup could not be completed). This does not confirm that the individual mailbox exists. It is most useful with 'Any email address' and 'Business emails only', where domains vary.

## `skipPreviouslyFoundEmails` (type: `boolean`):

When switched on, the run loads the list of emails saved under the history name below, skips any address already on it, and adds every new address to it. The result is a dataset that contains only new leads. Off by default, so every run starts from scratch.

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

Name of the saved history used by 'Skip emails found in earlier runs'. Use the same name across runs to share one history, or a different name for each campaign to keep campaigns separate. Only lowercase letters, numbers and hyphens, 3–63 characters. The history is kept in a named Apify storage that stays in your account until you delete it.

## `excludeEmails` (type: `array`):

Addresses or whole domains that must never appear in the results, for example people who asked not to be contacted, existing customers, or contacts already in your CRM. Enter full addresses (jane@brand.com) or domains (@brand.com). Matching ignores letter case. A skipped address is not saved and not charged.

## Actor input object example

```json
{
  "keywords": [
    "writer",
    "editor"
  ],
  "location": "",
  "locations": [],
  "emailSearchMode": "anyDomain",
  "customDomains": [
    "@gmail.com"
  ],
  "maxEmails": 5,
  "maxTotalEmails": 0,
  "maxConcurrentSearches": 5,
  "minFollowers": 0,
  "maxFollowers": 0,
  "profilesOnly": false,
  "includeWords": [],
  "excludeWords": [],
  "extractPhoneNumbers": false,
  "verifyEmails": false,
  "skipPreviouslyFoundEmails": false,
  "historyStoreName": "grammarly-email-history",
  "excludeEmails": []
}
```

# Actor output Schema

## `dataset` (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 = {
    "keywords": [
        "writer",
        "editor"
    ],
    "location": "",
    "locations": [],
    "customDomains": [
        "@gmail.com"
    ],
    "profilesOnly": false,
    "includeWords": [],
    "excludeWords": [],
    "excludeEmails": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("email_scraper/grammarly-email-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 = {
    "keywords": [
        "writer",
        "editor",
    ],
    "location": "",
    "locations": [],
    "customDomains": ["@gmail.com"],
    "profilesOnly": False,
    "includeWords": [],
    "excludeWords": [],
    "excludeEmails": [],
}

# Run the Actor and wait for it to finish
run = client.actor("email_scraper/grammarly-email-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 '{
  "keywords": [
    "writer",
    "editor"
  ],
  "location": "",
  "locations": [],
  "customDomains": [
    "@gmail.com"
  ],
  "profilesOnly": false,
  "includeWords": [],
  "excludeWords": [],
  "excludeEmails": []
}' |
apify call email_scraper/grammarly-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,email_scraper/grammarly-email-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/xbTshLK6UYbvsgdsa/builds/Cy9d1NY6p3HBNpjL6/openapi.json