# Enterprise MCP Gateway — 26 AI Data Servers in One Endpoint (`nexgendata/enterprise-mcp-gateway`) Actor

Single MCP endpoint giving AI agents access to 26 real-world data sources: finance, real estate, news, legal, e-commerce, maps, jobs, weather, sports, and more. One connection. All data.

- **URL**: https://apify.com/nexgendata/enterprise-mcp-gateway.md
- **Developed by:** [Stephan Corbeil](https://apify.com/nexgendata) (community)
- **Categories:** AI, Agents, Automation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Enterprise MCP Gateway — 26 AI Data Servers in One Endpoint

**One connection. All data.** Give your AI agent instant access to 26 real-world data sources through a single MCP endpoint — finance, real estate, news, legal, e-commerce, maps, jobs, weather, sports, and more.

### Why This Exists

Every AI agent needs data. But connecting to dozens of separate APIs means dozens of configurations, auth flows, rate limits, and failure modes. The Enterprise MCP Gateway solves this by aggregating **26 specialized MCP data servers** into a single endpoint. Connect once, access everything.

### What You Get

| Category | Servers | Example Tools |
|----------|---------|---------------|
| **Finance** | Finance & Markets, Yahoo Finance, Crypto Intelligence | Stock quotes, financial statements, crypto prices, market data |
| **Real Estate** | Real Estate, Redfin | Property listings, home values, market trends |
| **News & Media** | News & Media, YouTube & Media | Article search, headlines, video data, transcripts |
| **Business** | HR & Compensation, Job Market, Review Intelligence | Salary data, job listings, reviews, sentiment |
| **Technology** | Developer Tools, GitHub, SEO & Web Analysis, Domain Intel, Web Scraping | NPM packages, repos, SEO metrics, WHOIS, scraping |
| **Social** | Reddit, Social Content | Posts, comments, profiles, trending topics |
| **Location** | Google Maps, Travel, Weather | Business listings, flights, hotels, forecasts |
| **Legal** | Legal Intelligence | Court records, case law, regulations |
| **E-Commerce** | E-Commerce Intelligence | Product search, price comparison, reviews |
| **Research** | Academic Research, Premium Data | Papers, journals, company/person enrichment |
| **Sports** | Sports Data | Live scores, standings, player stats |
| **Automotive** | Automotive Intelligence | Vehicle pricing, specs, dealer inventory |

**75+ tools** across all servers. Full list available via `tools/list`.

### Quick Start

#### Connect via SSE (Recommended)

```json
{
  "mcpServers": {
    "nexgendata-gateway": {
      "url": "https://nexgendata-enterprise-mcp-gateway.apify.actor/sse?token=YOUR_APIFY_TOKEN"
    }
  }
}
````

#### Connect via HTTP

```bash
curl -X POST https://nexgendata-enterprise-mcp-gateway.apify.actor/mcp \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/list"
  }'
```

#### Claude Desktop Configuration

Add to your `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "nexgendata-gateway": {
      "url": "https://nexgendata-enterprise-mcp-gateway.apify.actor/sse?token=YOUR_APIFY_TOKEN"
    }
  }
}
```

### How It Works

1. **You connect** to the Gateway via SSE or HTTP — one endpoint, one auth token
2. **Your AI agent discovers** 75+ tools across all 26 servers via `tools/list`
3. **Agent calls a tool** (e.g., `finance/get_stock_quote` with `{"symbol": "AAPL"}`)
4. **Gateway routes** the request to the correct underlying MCP server
5. **Data returns** through your single connection

Tools are namespaced as `server-id/tool-name` so there are never naming conflicts. For example:

- `finance/get_stock_quote` — Stock data from Finance & Markets
- `yahoo-finance/get_quote` — Stock data from Yahoo Finance
- `real-estate/search_properties` — Property search
- `google-maps/search_places` — Google Maps business data
- `news/search_news` — News article search

### Convenience Endpoints

| Endpoint | Description |
|----------|-------------|
| `GET /health` | Server status, uptime, counts |
| `GET /catalog` | Browse all servers and tools by category |
| `GET /stats` | Usage analytics for the last 24 hours |
| `GET /sse` | MCP SSE transport endpoint |
| `POST /mcp` | MCP HTTP transport endpoint |
| `POST /message?sessionId=X` | MCP message endpoint (used with SSE) |

### Rate Limits

- **60 requests per minute** per API token
- Rate limit resets every 60 seconds
- Enterprise customers: contact for higher limits

### Authentication

All tool executions require an Apify API token. You can provide it in three ways:

1. **SSE query parameter**: `/sse?token=YOUR_TOKEN`
2. **Authorization header**: `Authorization: Bearer YOUR_TOKEN`
3. **Actor input**: Set `apifyToken` in the actor's input configuration

### Example: Multi-Source Research

Ask your AI agent: *"What's the real estate market like in Austin, TX?"*

The agent can use the gateway to:

1. `real-estate/get_market_trends` — Get market overview
2. `redfin/get_market_stats` — Get Redfin-specific data
3. `real-estate/search_properties` — Browse current listings
4. `news/search_news` — Find recent Austin real estate news
5. `weather/get_current_weather` — Check Austin weather
6. `job-market/get_market_trends` — See Austin job market (drives housing demand)

All through **one connection**.

### Built By NexGenData

We maintain **100+ Apify actors** and **26 MCP servers** powering data access for AI agents worldwide. The Enterprise MCP Gateway is the easiest way to access them all.

- **Apify Store**: [apify.com/nexgendata](https://apify.com/nexgendata)
- **Support**: Open an issue on the actor page
- **Enterprise**: Contact us for custom data pipelines and dedicated infrastructure

# Actor input Schema

## `apifyToken` (type: `string`):

Your Apify API token for authenticating tool calls to underlying MCP servers. If not provided, the actor will use the token from the run context. You can also pass it via the SSE connection's Authorization header.

## Actor input object example

```json
{}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/enterprise-mcp-gateway").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/enterprise-mcp-gateway").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{}' |
apify call nexgendata/enterprise-mcp-gateway --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=nexgendata/enterprise-mcp-gateway",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Enterprise MCP Gateway — 26 AI Data Servers in One Endpoint",
        "description": "Single MCP endpoint giving AI agents access to 26 real-world data sources: finance, real estate, news, legal, e-commerce, maps, jobs, weather, sports, and more. One connection. All data.",
        "version": "1.0",
        "x-build-id": "7mizFc4bPxY2kghcN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~enterprise-mcp-gateway/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-enterprise-mcp-gateway",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/nexgendata~enterprise-mcp-gateway/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-enterprise-mcp-gateway",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/nexgendata~enterprise-mcp-gateway/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-enterprise-mcp-gateway",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "apifyToken": {
                        "title": "Apify API Token",
                        "type": "string",
                        "description": "Your Apify API token for authenticating tool calls to underlying MCP servers. If not provided, the actor will use the token from the run context. You can also pass it via the SSE connection's Authorization header."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
