# Neuton Actors MCP Server (`neuton/neuton-actors-mcp-server`) Actor

Use Neuton's public data Actors from ChatGPT, Claude, Cursor, and other MCP clients through one searchable, cost-controlled gateway.

- **URL**: https://apify.com/neuton/neuton-actors-mcp-server.md
- **Developed by:** [Ashwin Prasad](https://apify.com/neuton) (community)
- **Categories:** AI, Automation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 workflow results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Neuton Actors MCP Server

Give ChatGPT, Claude, Cursor, VS Code, or another MCP client one endpoint for Neuton's public data Actors. Search the live catalog, inspect the right input, run an Actor with a spending cap, and receive structured rows without adding every scraper separately.

**MCP endpoint:** `https://neuton--neuton-actors-mcp-server.apify.actor/mcp`

### Connect and test

1. Add the endpoint above as a remote Streamable HTTP MCP server.
2. Authenticate with Apify OAuth or keep your Apify token in the client's secure connector settings.
3. Ask: `Find a Neuton Actor for Greenhouse jobs, inspect its input, then run it for Stripe with at most 5 results and a $0.25 charge cap.`

The server exposes five tools. Search and inspection are free; gateway-funded runs cost $5 per 1,000 returned workflow results. Clients that send their own customer token pay the selected Actor's normal Store price instead.

The catalog covers jobs and recruiting, company and compliance research, finance and government data, academic publications, apps and reviews, automotive and local data, ecommerce, and developer or RAG workflows.

### Why use this instead of adding every Actor separately?

AI clients perform better with a small, stable tool set. This server exposes five tools while discovering newly published Neuton Actors automatically:

- `search_neuton_actors`: find the right Actor for a goal or data source.
- `get_neuton_actor`: inspect example input, pricing, and the Store page.
- `list_neuton_categories`: browse the current portfolio by data lane.
- `run_neuton_actor`: start an allowlisted Actor with a hard spending cap.
- `get_neuton_run`: poll a run and retrieve a bounded result sample.

Only healthy public Actors owned by `neuton` can run through this gateway. Under-maintenance Actors are excluded automatically.

Always inspect an Actor before the first run. Keep the first result limit small and set `max_total_charge_usd` for every call.

### Connect from ChatGPT

1. Open **Settings > Apps & Connectors > Advanced settings** and enable Developer mode.
2. Choose **Create** and enter the MCP URL shown on this Actor's Apify page, ending in `/mcp`.
3. Select OAuth or Apify bearer-token authentication when prompted.
4. Add the connector, start a new chat, and select **Neuton Actors** from the tools menu.
5. Ask the first-workflow prompt above before increasing limits.

ChatGPT fixes the available tool list when a connector is created. Recreate the connector only if this server adds or removes MCP tools; newly published Neuton Actors appear without recreating it.

### Connect from Claude Desktop

Add a remote MCP connection using the Actor's `/mcp` URL and your Apify API token as a bearer token. Clients that support custom headers may also send `X-Apify-Customer-Token`; this makes downstream runs use that Apify account directly. Without the extra header, the gateway runs the selected Actor and bills only returned workflow results through this MCP Actor.

Never paste an API token into a prompt or commit it to source control. Store it in the client's secure connector or environment settings.

### Generic MCP configuration

Use these values in any MCP client that supports remote Streamable HTTP:

```json
{
  "name": "neuton-actors",
  "url": "https://neuton--neuton-actors-mcp-server.apify.actor/mcp",
  "transport": "streamable-http",
  "headers": {
    "Authorization": "Bearer ${APIFY_TOKEN}",
    "X-Apify-Customer-Token": "${APIFY_TOKEN}"
  }
}
```

The final public URL is verified after deployment. Use the URL displayed on the Actor page if it differs from this standard Apify hostname.

### Output

Tool responses are structured JSON. Search returns ranked Actor names, categories, descriptions, and Store URLs. Inspection returns example input and pricing. Run and poll responses return the Actor name, run ID, status, dataset ID, billing mode, item count, a bounded result sample, and the Console run URL for debugging.

### Authentication, cost, and privacy

- ChatGPT and OAuth clients use gateway billing at $0.005 per returned workflow result. Discovery and Actor inspection are not charged events.
- Clients that securely send `X-Apify-Customer-Token` use customer-funded mode and pay the selected Neuton Actor's published price directly.
- Neuton's private owner token is supplied only by the Apify runtime and is never embedded in this server or returned to a client.
- `run_neuton_actor` defaults to a $1 total charge cap and rejects caps over $25.
- Result previews are limited to 100 dataset rows. Use the returned dataset ID for larger authorized workflows.
- The server does not accept arbitrary third-party Actor IDs.
- Use public data responsibly and follow applicable laws, privacy rules, website terms, and platform policies.

### Responsible use

Use the gateway only for lawful public-data workflows. Do not use it to collect sensitive personal data, evade access controls, violate website terms, or make automated high-impact decisions without appropriate review.

### Search and SEO terms

Relevant terms include Apify MCP server, ChatGPT scraping MCP, Claude data tools, jobs data MCP, academic research MCP, compliance data MCP, app reviews MCP, automotive data MCP, and structured data for AI agents.

### Local development

```bash
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
python -m unittest discover -s tests -v
APIFY_TOKEN="your-token" python -m src
```

The local endpoint is `http://127.0.0.1:4321/mcp` unless `APIFY_CONTAINER_PORT` specifies another port. The server uses the lightweight Apify API client because it orchestrates existing Actors and does not scrape pages itself.

# Actor input Schema

## Actor input object example

```json
{}
```

# Actor output Schema

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

// Run the Actor and wait for it to finish
const run = await client.actor("neuton/neuton-actors-mcp-server").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("neuton/neuton-actors-mcp-server").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 '{}' |
apify call neuton/neuton-actors-mcp-server --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,neuton/neuton-actors-mcp-server"
        }
    }
}

```

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/zSHGfXaLzaLVQFCby/builds/KZvILfRdmZMW4nXIM/openapi.json