# GoodFirms Email Scraper (`email_scraper/goodfirms-email-scraper`) Actor

GoodFirms Email Scraper extracts publicly indexed business emails using targeted keywords, locations, and custom email domains. Build structured GoodFirms leads with titles, descriptions, URLs, and emails for lead generation, prospecting, and business research.

- **URL**: https://apify.com/email\_scraper/goodfirms-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

### 🔍 GoodFirms Email Scraper

**GoodFirms Email Scraper** is an Apify Actor designed to discover publicly indexed email addresses associated with GoodFirms search results using targeted keywords, optional locations, and selected email-domain suffixes. It helps turn focused search terms into a structured dataset containing keyword, title, description, URL, and email information.

With **GoodFirms Email Scraper**, users can search for business categories, professional services, company types, or other relevant terms. The Actor searches for GoodFirms-related results matching the supplied keyword and email domain, then extracts matching email addresses from available search-result descriptions.

The **GoodFirms Email Scraper** supports multiple keywords and multiple custom email domains. Location targeting can also be used when the research needs to focus on a particular country, state, or city.

The result is a structured dataset suitable for **GoodFirms leads**, business research, prospecting, market research, and contact discovery. Results are added incrementally to the Apify dataset, while duplicate email addresses are avoided during the run.

> **SEO Description:** GoodFirms Email Scraper extracts publicly indexed business emails using targeted keywords, locations, and custom email domains. Build structured GoodFirms leads with titles, descriptions, URLs, and emails for lead generation, prospecting, and business research.

### ⚡ GoodFirms Email Scraper Key Features

| Feature                      | Description                                                                 | User Benefit                                             |
| ---------------------------- | --------------------------------------------------------------------------- | -------------------------------------------------------- |
| Keyword-based search         | Searches GoodFirms-related results using supplied keywords or queries.      | Target specific niches and search intent.                |
| Multiple keywords            | Accepts a list of search terms in one run.                                  | Expand research coverage without separate runs.          |
| Location targeting           | Optionally adds a country, state, or city to the search.                    | Focus research on a geographic market.                   |
| Custom email domains         | Supports multiple email-domain suffixes such as `@gmail.com`.               | Target the contact types most relevant to your workflow. |
| Per-combination email target | `maxEmails` controls the target for each keyword + domain combination.      | Control the depth of each search combination.            |
| Exclude words                | Skips search-result descriptions containing specified words or phrases.     | Reduce unwanted results.                                 |
| Email deduplication          | Previously collected email addresses are not added again during the run.    | Keep the dataset cleaner.                                |
| Incremental dataset output   | Results are pushed to the Apify dataset as they are collected.              | Review collected data progressively.                     |
| Resume support               | Run progress is persisted so processing can continue after an interruption. | Reduce the need to restart completed work.               |

### 📊 What Data Can You Extract?

**GoodFirms Email Scraper** returns structured information for every successfully discovered email address. The dataset is centered on the search context and the organic result where the email was identified.

The available data includes:

- **Keyword** — the keyword used for the search.
- **Title** — the title of the organic search result.
- **Description** — the search-result description or snippet associated with the result.
- **URL** — the URL returned by the search result.
- **Email** — the email address matching the selected domain suffix.
- **Network** — the output generated by the Actor identifies the network as `GoodFirms.com`.

The default Apify dataset view displays `keyword`, `title`, `description`, `url`, and `email`. The `network` field is also generated in the Actor output.

The email is extracted from the available search-result description. Therefore, results depend on what is publicly indexed and visible through the relevant search results.

### 🎯 Why Use GoodFirms Email Scraper?

Manual research can require repeatedly searching for different service categories, locations, and email-domain patterns. **GoodFirms Email Scraper** automates this repetitive search-oriented workflow and organizes discovered information into a structured Apify dataset.

It is particularly useful when your research requires combinations such as `Cybersecurity + @gmail.com`, `Software Development + @outlook.com`, or a service keyword combined with a geographic location.

Instead of collecting individual search-result details manually, users can define their search strategy through the Actor input and review the resulting structured lead data.

### 🔄 How GoodFirms Email Scraper Works

The user-facing workflow is straightforward:

1. Enter one or more keywords or queries.
2. Optionally specify a country, state, or city.
3. Add the email-domain suffixes you want to search for.
4. Set the maximum email target for each keyword + domain combination.
5. Optionally provide words or phrases to exclude.
6. Start the Actor.
7. Review the resulting Apify dataset.

The Actor searches for GoodFirms-related results matching the selected search terms and email-domain suffixes. Matching email addresses found in result descriptions are added to the dataset.

The process focuses on publicly indexed search information rather than claiming that every GoodFirms listing or profile will be discovered.

### 📥 GoodFirms Email Scraper Input

The required input is `keywords`. The other fields provide optional control over location, email domains, result targets, and filtering.

| Field           | Type             | Required | Default                                     | Description                                                                           |
| --------------- | ---------------- | -------- | ------------------------------------------- | ------------------------------------------------------------------------------------- |
| `keywords`      | Array of strings | Yes      | `["Cybersecurity", "Software Development"]` | Search keywords or queries.                                                           |
| `location`      | String           | No       | `""`                                        | Optional country, state, or city used to narrow the search.                           |
| `customDomains` | Array of strings | No       | `["@gmail.com"]`                            | Email-domain suffixes to search for.                                                  |
| `maxEmails`     | Integer          | No       | `5`                                         | Target number of emails for each keyword + domain combination. Valid range: 1–10,000. |
| `excludeWords`  | Array of strings | No       | `[]`                                        | Words or phrases that cause matching search-result descriptions to be skipped.        |

For `keywords`, use specific terms when possible. For example, several focused phrases such as `Cybersecurity Consultant`, `Cybersecurity Company`, and `Cybersecurity Services` can provide different search intent than one broad term.

The `location` field can be left empty when geographic targeting is unnecessary.

### 🧾 GoodFirms Email Scraper Input Example

```json
{
  "keywords": [
    "Cybersecurity",
    "Software Development",
    "Mobile App Development"
  ],
  "location": "United States",
  "customDomains": [
    "@gmail.com",
    "@outlook.com",
    "@yahoo.com"
  ],
  "maxEmails": 10,
  "excludeWords": [
    "crypto"
  ]
}
```

This example uses only fields supported by the Actor. `keywords` is the only required property.

### 📤 GoodFirms Email Scraper Output

The Actor writes discovered records to the Apify dataset incrementally. Each successful record represents an email address associated with a matching search result.

| Field         | Description                                                           |
| ------------- | --------------------------------------------------------------------- |
| `network`     | Identifies the source network as `GoodFirms.com`.                     |
| `keyword`     | Search keyword responsible for the result.                            |
| `title`       | Organic search-result title.                                          |
| `description` | Search-result description or snippet containing the discovered email. |
| `url`         | URL returned by the organic search result.                            |
| `email`       | Extracted email address matching the configured domain suffix.        |

The default dataset table presents the primary lead fields as **Keyword, Title, Description, Url, and Email**.

The `url` should be understood as the URL returned by the search result. It should not be interpreted as a guarantee that every returned URL represents a specific GoodFirms profile page.

### 🧾 GoodFirms Email Scraper Output Example

The following is an illustrative structure showing the fields produced by the Actor:

```json
{
  "network": "GoodFirms.com",
  "keyword": "Cybersecurity",
  "title": "Example Search Result",
  "description": "Example search result description containing contact@example.com",
  "url": "https://www.goodfirms.co/",
  "email": "contact@example.com"
}
```

Actual titles, descriptions, URLs, and email addresses depend on the publicly indexed search results available for the selected inputs.

### 🗂️ GoodFirms Email Scraper Data Structure

The resulting dataset is designed around straightforward **contact data** and search context.

A typical workflow can use `keyword` to identify the research topic, `title` and `description` to understand the result context, `url` to revisit the source, and `email` for contact discovery.

The `network` field identifies the source as GoodFirms.com and is generated in the Actor's output even though it is not part of the default transformed dataset view.

This structure makes the dataset useful for filtering, reviewing, validating, and organizing **GoodFirms business listings** discovered through targeted searches.

### 💡 GoodFirms Email Scraper Benefits

The main benefit of **GoodFirms Email Scraper** is reducing repetitive search and copy-paste work.

Practical benefits include:

- Automated keyword-based research.
- Structured output instead of manually collected search notes.
- Support for multiple search terms.
- Optional geographic targeting.
- Custom email-domain targeting.
- Search-result filtering through `excludeWords`.
- Incremental dataset collection.
- Duplicate email prevention.
- Search combinations that can be tailored to specific niches.
- Data suitable for further business research and prospecting.

The Actor can therefore support **B2B lead generation**, **company research**, **service provider discovery**, and other workflows where publicly indexed contact information is relevant.

### 🏆 GoodFirms Email Scraper Advantages

| Advantage              | Explanation                                                                            |
| ---------------------- | -------------------------------------------------------------------------------------- |
| Focused search intent  | Keywords can be tailored to specific industries, services, or professional categories. |
| Flexible targeting     | Location and email-domain settings allow more controlled searches.                     |
| Structured data        | Results are organized into consistent dataset fields.                                  |
| Filtering              | Exclusion terms can remove unwanted search-result snippets.                            |
| Duplicate control      | Previously collected email addresses are not added again during the run.               |
| Incremental collection | Results are sent to the dataset as they are discovered.                                |

These characteristics make **GoodFirms Email Scraper** useful for users who need targeted **business contacts** rather than an unstructured collection of general web pages.

### ⚖️ GoodFirms Email Scraper vs Alternative Approaches

| Capability                | This Actor         | Manual / Typical Alternative       |
| ------------------------- | ------------------ | ---------------------------------- |
| Keyword-based research    | Supported          | Requires repeated manual searches  |
| Multiple keywords         | Supported          | Usually handled individually       |
| Email-domain targeting    | Supported          | Requires manual search refinement  |
| Location targeting        | Supported          | Requires manual query construction |
| Exclude-word filtering    | Supported          | Usually performed manually         |
| Structured dataset        | Supported          | May require manual formatting      |
| Duplicate email handling  | Built into the run | Often requires spreadsheet cleanup |
| Incremental Apify dataset | Supported          | Not inherent to manual research    |

This comparison describes workflow differences rather than claiming that one approach is universally better.

### 📈 GoodFirms Email Scraper Pros and Cons

| Pros                            | Cons                                                              |
| ------------------------------- | ----------------------------------------------------------------- |
| Supports multiple keywords      | Results depend on publicly indexed search information             |
| Supports multiple email domains | Not every GoodFirms listing will necessarily expose an email      |
| Optional location targeting     | Narrow searches may return fewer results                          |
| Exclude-word filtering          | Search-result descriptions can vary                               |
| Structured dataset output       | Extracted information should be validated for important workflows |
| Duplicate email prevention      | Requested targets are not guarantees of available results         |

### 🛠️ How to Use GoodFirms Email Scraper

For a first run, start with a small and specific search configuration.

1. Add relevant terms to `keywords`.
2. Leave `location` empty if you want broader geographic coverage.
3. Add one or more email suffixes to `customDomains`.
4. Use a modest `maxEmails` value for testing.
5. Add `excludeWords` only when you know which result descriptions should be skipped.
6. Run the Actor and inspect the dataset.
7. Broaden keywords, domains, or location settings if the result volume is lower than expected.

For example, instead of relying only on `Fitness`, consider more specific terms such as `Fitness Coach`, `Fitness Trainer`, or `Online Fitness Coach`.

### 🎯 GoodFirms Email Scraper Use Cases

**GoodFirms Email Scraper** can support several research and prospecting workflows:

- **B2B lead generation** — identify publicly indexed business email addresses related to targeted service categories.
- **Agency prospecting** — research agencies and service providers using focused industry terms.
- **Software company research** — search for companies associated with software development and related services.
- **Cybersecurity research** — investigate cybersecurity businesses using targeted keyword combinations.
- **Mobile app development research** — discover search results related to mobile development services.
- **Local business prospecting** — combine keywords with a country, state, or city.
- **Company research** — collect structured search-result information for market analysis.
- **Market research** — build datasets around specific business categories.
- **Contact discovery** — identify publicly indexed emails matching selected domain suffixes.
- **Prospect list building** — organize discovered contact information into a structured dataset.

Results should be reviewed and validated before being used for important business decisions or outreach.

### 🔎 How to Find GoodFirms Emails by Keyword

Effective **keyword targeting** is important because the Actor searches according to the terms supplied by the user.

Broad terms may produce a wide range of results, while specific phrases can better represent a particular **search intent**.

Useful strategies include:

- Combine job roles with service categories.
- Use industry-specific terminology.
- Create several closely related keyword variations.
- Separate different niches into individual keyword entries.
- Test broad and narrow terms in separate runs.
- Review the first results before expanding a large run.

Using several relevant terms can improve coverage while keeping the research strategy understandable.

### 📍 How to Target GoodFirms Leads by Location

The optional `location` field adds geographic context to the search. You can enter a country, state, or city manually.

For example, a research workflow might use:

```json
{
  "keywords": [
    "Cybersecurity Company",
    "Cybersecurity Services"
  ],
  "location": "United States"
}
```

If location-specific results are too limited, leaving `location` blank can broaden the search.

Geographic targeting is particularly useful for **local business prospecting**, regional market research, and location-focused service-provider discovery.

### ✉️ How to Search Multiple Email Domains

`customDomains` accepts multiple email-domain suffixes.

For example:

```json
{
  "keywords": [
    "Software Development"
  ],
  "customDomains": [
    "@gmail.com",
    "@outlook.com",
    "@yahoo.com"
  ]
}
```

The Actor processes each keyword + domain combination independently according to the configured target.

The selected domain must correspond to the email pattern you want to find. Adding relevant domains can broaden **publicly indexed emails** available to the search.

### 🚫 How to Filter GoodFirms Search Results

The `excludeWords` field can be used to skip search-result descriptions containing unwanted terms.

Single words are matched without regard to letter case and use whole-word matching. Phrases are matched case-insensitively as phrases.

For example:

```json
{
  "excludeWords": [
    "crypto",
    "onlyfans"
  ]
}
```

When an exclusion term is found in a result description, that entire result is skipped and no email is extracted from it.

### 💰 GoodFirms Email Scraper Limits and Run Considerations

The `maxEmails` field accepts values from **1 to 10,000** and applies to each keyword + domain combination.

For example, three keywords and two domains create six keyword-domain combinations. A target of 20 applies independently to those combinations, subject to available results and duplicate handling.

On the free tier, the Actor applies a maximum of **100 emails per keyword + domain combination** when the requested target is higher than that limit or is not specified.

The configured target is not a guarantee. The Actor can only collect email addresses that are available in the relevant publicly indexed search information.

### ⚠️ GoodFirms Email Scraper Limitations

There are several important considerations when using **GoodFirms Email Scraper**:

- Results depend on publicly indexed search information.
- A keyword may not produce enough relevant results to reach its requested target.
- Not every GoodFirms-related result contains an email address.
- Narrow keywords can produce sparse results.
- Location filters can reduce the available search coverage.
- Exclusion terms can intentionally remove otherwise matching results.
- Duplicate email addresses are not collected repeatedly.
- Search-result descriptions and available information can change over time.
- The output URL represents the organic search result URL and should be reviewed before relying on it as a specific profile reference.

These limitations are normal considerations for search-based contact discovery.

### ✅ GoodFirms Email Scraper Best Practices

For better-quality research, consider these practices:

- Start with a small run and inspect the dataset.
- Use specific keywords instead of relying on one broad term.
- Add related keyword variations for broader coverage.
- Use location only when geographic targeting is important.
- Add relevant email domains based on your research objective.
- Keep `maxEmails` reasonable during testing.
- Use `excludeWords` to remove clearly unwanted result categories.
- Review titles and descriptions alongside email addresses.
- Validate important contact information before business use.
- Broaden the search when the Actor returns fewer results than expected.

### 🧰 GoodFirms Email Scraper Troubleshooting

**Empty or sparse results:** Try broader or more specific keyword variations. You can also remove the location filter or add additional email domains.

**Missing email addresses:** The search result may not contain a publicly indexed email matching your selected domain suffix.

**Too few results:** Increase relevant keyword coverage, broaden the geographic scope, or test additional domain suffixes.

**Unexpected exclusions:** Check `excludeWords`. A matching word or phrase in a result description causes the entire result to be skipped.

**Partial results:** Review whether the selected search terms are too narrow or whether the available indexed results contain enough matching email information.

**Large runs:** Wide searches can take longer. The actor input documentation recommends increasing the run timeout from its default when necessary.

### ❓ GoodFirms Email Scraper FAQ

**What does GoodFirms Email Scraper do?**

- It searches for GoodFirms-related search results using supplied keywords and email-domain suffixes and extracts matching publicly indexed email addresses from result descriptions.

**What inputs are required?**

- `keywords` is required. `location`, `customDomains`, `maxEmails`, and `excludeWords` are optional.

**Can I use multiple keywords?**

- Yes. The `keywords` field accepts an array of search terms or queries.

**Can I search by country or city?**

- Yes. Enter a country, state, or city in the optional `location` field.

**Can I search multiple email domains?**

- Yes. `customDomains` accepts multiple email-domain suffixes.

**What does maxEmails mean?**

- It is the target for each keyword + domain combination, not one shared target for the entire configuration.

**Does the Actor guarantee the requested number of emails?**

- No. The target depends on the availability of matching publicly indexed search information.

**Does GoodFirms Email Scraper remove duplicate emails?**

- Yes. Email addresses already collected during the run are not added again.

**What happens when excludeWords matches a result?**

- The complete search-result description is skipped, so no email is extracted from that result.

**What does the output contain?**

- The Actor generates `network`, `keyword`, `title`, `description`, `url`, and `email` fields.

**Can I use the Actor for lead generation?**

- Yes. Its structured contact data can support lead research, prospecting, company research, and related workflows, subject to appropriate validation and use.

### 🧠 NLP Keywords

- GoodFirms leads
- GoodFirms business listings
- GoodFirms contacts
- business email extraction
- email addresses
- public contact emails
- search results
- search snippets
- keyword search
- location targeting
- custom email domains
- email scraper
- lead generation
- sales prospecting
- business research
- contact data
- structured dataset
- result filtering
- email deduplication
- search intent

### 🔗 Related Keywords

- B2B lead generation
- local business prospecting
- company research
- service provider discovery
- agency prospecting
- software company research
- cybersecurity companies
- mobile app development companies
- business directory data
- publicly indexed emails
- targeted queries
- geographic search
- prospect list building
- contact discovery
- outreach preparation
- market research
- niche targeting
- business contacts
- keyword targeting
- structured lead data

### 🚀 Final Overview

**GoodFirms Email Scraper** provides a focused way to turn keyword-driven GoodFirms search research into structured contact data. With support for multiple keywords, geographic targeting, custom email domains, exclusion filters, per-combination targets, duplicate prevention, and incremental dataset output, it can support targeted business research and prospecting workflows.

The most effective approach is to start with focused keywords, test a small configuration, review the returned data, and then expand the search strategy based on the quality and availability of publicly indexed results.

*Contact me:* <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.

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

List of custom email domains

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

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

Words or phrases you do not want to see.

## Actor input object example

```json
{
  "keywords": [
    "Cybersecurity",
    "Software Development"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com"
  ],
  "maxEmails": 5,
  "excludeWords": []
}
```

# 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": [
        "Cybersecurity",
        "Software Development"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com"
    ],
    "excludeWords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("email_scraper/goodfirms-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": [
        "Cybersecurity",
        "Software Development",
    ],
    "location": "",
    "customDomains": ["@gmail.com"],
    "excludeWords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("email_scraper/goodfirms-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": [
    "Cybersecurity",
    "Software Development"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com"
  ],
  "excludeWords": []
}' |
apify call email_scraper/goodfirms-email-scraper --silent --output-dataset

```

## MCP server setup

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