webdata-tools-mcp 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 tacps126
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,105 @@
-# Temporary Holding Version
+# webdata-tools-mcp
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+An [MCP](https://modelcontextprotocol.io) server that gives AI agents ten web-data tools: job
+postings, hiring signals, Google News, Trustpilot and app-store reviews, Reddit mentions, website
+contacts, German property listings and Shopify products.
+
+Each tool runs a ready-made [Apify](https://apify.com/tacps126) Actor and returns clean JSON. You
+pay Apify per result (about $1–3 per 1,000 results); there is no subscription and nothing is sent
+anywhere except Apify.
+
+## Tools
+
+| Tool | What it returns | Cost (approx.) | Actor |
+|------|-----------------|----------------|-------|
+| `search_google_news` | News articles with the publisher's real URL, date, related coverage | $2 / 1,000 articles | [google-news](https://apify.com/tacps126/google-news) |
+| `find_hiring_companies` | Which companies are hiring for given roles (buying-intent signal) | 1¢ per company with a signal | [hiring-signals](https://apify.com/tacps126/hiring-signals) |
+| `get_company_jobs` | All open jobs from career pages (Greenhouse, Lever, Ashby, Workday, …) | $1 / 1,000 jobs | [jobs-harvester](https://apify.com/tacps126/jobs-harvester) |
+| `search_indeed_jobs` | Indeed listings in 9 countries | $3 / 1,000 jobs | [indeed-jobs](https://apify.com/tacps126/indeed-jobs) |
+| `get_trustpilot_reviews` | Reviews, TrustScore and company profile | $0.50 / 1,000 reviews | [trustpilot-reviews](https://apify.com/tacps126/trustpilot-reviews) |
+| `get_app_reviews` | App Store and Google Play reviews | $0.20 / 1,000 reviews | [app-reviews](https://apify.com/tacps126/app-reviews) |
+| `search_reddit` | Reddit posts and comments by keyword or subreddit | $1 / 1,000 items | [reddit-monitor](https://apify.com/tacps126/reddit-monitor) |
+| `find_website_contacts` | Emails, phones, socials from websites | $2 / 1,000 sites with contacts | [contact-details](https://apify.com/tacps126/contact-details) |
+| `search_german_property_listings` | Rent/buy listings in Germany (ImmoScout24) | $1 / 1,000 listings | [immobilienscout24-scraper](https://apify.com/tacps126/immobilienscout24-scraper) |
+| `get_shopify_products` | Prices, discounts, stock, variants from Shopify stores | $1 / 1,000 products | [shopify-products](https://apify.com/tacps126/shopify-products) |
+
+Every tool also takes an optional `extra_input` object for any other field the Actor documents.
+
+## Setup
+
+1. Create a free [Apify account](https://apify.com) and copy your API token from
+   **Console → Settings → API & Integrations**.
+2. Add the server to your client. The token goes in `APIFY_TOKEN`.
+
+**Claude Desktop / Cursor / Windsurf** (`mcpServers` config):
+
+```json
+{
+  "mcpServers": {
+    "webdata": {
+      "command": "npx",
+      "args": ["-y", "webdata-tools-mcp"],
+      "env": { "APIFY_TOKEN": "<your Apify token>" }
+    }
+  }
+}
+```
+
+**Claude Code:**
+
+```bash
+claude mcp add webdata -e APIFY_TOKEN=<your Apify token> -- npx -y webdata-tools-mcp
+```
+
+Requires Node.js 18 or newer.
+
+## Try it
+
+- "Which of these companies are hiring data engineers right now? https://boards.greenhouse.io/stripe, https://jobs.lever.co/spotify"
+- "Show the 1 and 2 star Trustpilot reviews of example.com from the last 30 days and group the complaints."
+- "Find news from the last 7 days about open-source LLM licensing, with the real publisher links."
+- "Get contact emails for these 20 agency websites." (use only for lawful business outreach)
+
+## Cost safety
+
+- Every call is capped at **$0.50** of Apify spend (`WEBDATA_MAX_CHARGE_USD` changes it). Apify stops
+  the run when the cap is reached.
+- `max_items` defaults to small numbers (20–100) and has a hard maximum per tool.
+- Long text fields are shortened to 600 characters, and one result is limited to about 60,000
+  characters, so a call cannot flood the agent's context.
+
+## No install: Apify's hosted MCP server
+
+You can also use Apify's own server with these Actors selected, with nothing to install:
+
+```json
+{
+  "mcpServers": {
+    "apify": { "url": "https://mcp.apify.com?tools=tacps126/google-news,tacps126/hiring-signals,tacps126/trustpilot-reviews" }
+  }
+}
+```
+
+It signs you in with OAuth. The tools take the Actors' raw input fields instead of the simplified
+arguments above.
+
+## Development
+
+```bash
+npm install
+npm test                                  # offline: mapping, errors, size limits, MCP handshake
+node scripts/sync-actor-inputs.mjs        # refresh test/fixtures from the published Actors
+APIFY_TOKEN=... node scripts/smoke.mjs    # live check, a few cents
+```
+
+`test/fixtures/actor-inputs.json` lists the input fields of each published Actor; the tests fail if
+a tool sends a field the Actor does not accept.
+
+## Responsible use
+
+The Actors read publicly available pages. You are responsible for following each site's terms and
+the law that applies to you (GDPR, CAN-SPAM) when you use the data, especially contact details.
+
+## License
+
+MIT

package/package.json

@@ -1,6 +1,48 @@
 {
   "name": "webdata-tools-mcp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "mcpName": "io.github.tacps126/webdata-tools-mcp",
+  "description": "MCP server for AI agents: job postings, hiring signals, Google News, Trustpilot and app reviews, Reddit mentions, website contacts, German real estate and Shopify products. Runs ready-made Apify Actors with your own Apify token.",
+  "type": "module",
+  "bin": {
+    "webdata-tools-mcp": "src/index.js"
+  },
+  "main": "src/index.js",
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "start": "node src/index.js",
+    "test": "node --test test/*.test.js"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "apify",
+    "web-scraping",
+    "jobs",
+    "hiring-signals",
+    "google-news",
+    "trustpilot",
+    "reviews",
+    "lead-generation"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tacps126/webdata-tools-mcp.git"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.32.1",
+    "zod": "^4.6.7"
+  },
+  "homepage": "https://github.com/tacps126/webdata-tools-mcp#readme",
+  "bugs": {
+    "url": "https://github.com/tacps126/webdata-tools-mcp/issues"
+  }
+}

package/src/apify.js

@@ -0,0 +1,103 @@
+// Thin Apify client: run one Actor synchronously and return its dataset items.
+//
+// Uses `POST /v2/acts/{owner}~{name}/run-sync-get-dataset-items`, which runs the Actor and
+// returns the results in the same response (Apify caps this at 300 s). Billing happens on the
+// caller's Apify account; `maxTotalChargeUsd` makes Apify stop the run at a spend ceiling, so a
+// confused agent cannot run up a bill.
+
+const DEFAULT_API_BASE = 'https://api.apify.com';
+
+export class ApifyError extends Error {
+  constructor(message, status) {
+    super(message);
+    this.name = 'ApifyError';
+    this.status = status;
+  }
+}
+
+/**
+ * @param {object} o
+ * @param {string} o.actor           "owner/name"
+ * @param {object} o.input           Actor input
+ * @param {number} o.limit           max dataset items to return
+ * @param {string} o.token           Apify API token
+ * @param {number} o.maxChargeUsd    spend ceiling for this run
+ * @param {number} [o.timeoutSecs]   Actor run timeout (<= 300)
+ * @param {typeof fetch} [o.fetchImpl]
+ * @param {string} [o.apiBase]
+ * @returns {Promise<{items: object[], runId: string|null}>}
+ */
+export async function runActorSync({
+  actor,
+  input,
+  limit,
+  token,
+  maxChargeUsd,
+  timeoutSecs = 150,
+  fetchImpl = fetch,
+  apiBase = process.env.APIFY_API_BASE || DEFAULT_API_BASE,
+}) {
+  if (!token) {
+    throw new ApifyError(
+      'APIFY_TOKEN is not set. Create a free Apify account, copy your API token from ' +
+        'Console > Settings > API & Integrations, and pass it to this server as the ' +
+        'APIFY_TOKEN environment variable.',
+      401,
+    );
+  }
+  const [owner, name] = actor.split('/');
+  const url = new URL(`${apiBase}/v2/acts/${owner}~${name}/run-sync-get-dataset-items`);
+  url.searchParams.set('timeout', String(timeoutSecs));
+  url.searchParams.set('limit', String(limit));
+  url.searchParams.set('maxTotalChargeUsd', String(maxChargeUsd));
+
+  let res;
+  try {
+    res = await fetchImpl(url, {
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        authorization: `Bearer ${token}`,
+      },
+      body: JSON.stringify(input),
+      signal: AbortSignal.timeout((timeoutSecs + 20) * 1000),
+    });
+  } catch (err) {
+    throw new ApifyError(`Could not reach Apify: ${err.message}`, 0);
+  }
+
+  const text = await res.text();
+  if (!res.ok) throw new ApifyError(describeFailure(res.status, text, actor), res.status);
+
+  let items;
+  try {
+    items = JSON.parse(text);
+  } catch {
+    throw new ApifyError('Apify returned a response that is not JSON.', res.status);
+  }
+  if (!Array.isArray(items)) items = [items];
+  return { items, runId: res.headers.get('x-apify-run-id') };
+}
+
+function describeFailure(status, body, actor) {
+  let detail = '';
+  try {
+    detail = JSON.parse(body)?.error?.message ?? '';
+  } catch {
+    detail = body.slice(0, 200);
+  }
+  switch (status) {
+    case 401:
+      return 'Apify rejected the API token. Check APIFY_TOKEN.';
+    case 402:
+      return `Not enough Apify credit to run ${actor}. ${detail}`.trim();
+    case 404:
+      return `Actor ${actor} was not found. ${detail}`.trim();
+    case 408:
+      return `${actor} did not finish in time. Try a smaller max_items. ${detail}`.trim();
+    case 429:
+      return 'Apify rate limit hit. Wait a few seconds and retry.';
+    default:
+      return `Apify error ${status}${detail ? `: ${detail}` : ''}`;
+  }
+}

package/src/index.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+// webdata-tools-mcp: MCP server (stdio) that exposes ready-made Apify Actors as typed tools.
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { buildServer } from './server.js';
+
+await buildServer().connect(new StdioServerTransport());

package/src/server.js

@@ -0,0 +1,73 @@
+// MCP server definition: one typed tool per Apify Actor.
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { ApifyError, runActorSync } from './apify.js';
+import { extraInput, TOOLS } from './tools.js';
+
+const DEFAULT_MAX_CHARGE_USD = 0.5;
+const MAX_TEXT_CHARS = 60_000; // keep one tool result inside a sane context budget
+const MAX_FIELD_CHARS = 600;
+
+/** Truncate very long string fields (job descriptions, review bodies) so results stay readable. */
+export function shrink(value) {
+  if (typeof value === 'string') {
+    return value.length > MAX_FIELD_CHARS ? `${value.slice(0, MAX_FIELD_CHARS)}…` : value;
+  }
+  if (Array.isArray(value)) return value.map(shrink);
+  if (value && typeof value === 'object') {
+    return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, shrink(v)]));
+  }
+  return value;
+}
+
+/** Format dataset items as the text an agent reads, dropping rows if the result is too big. */
+export function formatResult(tool, items) {
+  const rows = items.map(shrink);
+  let kept = rows.length;
+  let body = JSON.stringify(rows, null, 1);
+  while (body.length > MAX_TEXT_CHARS && kept > 1) {
+    kept = Math.max(1, Math.floor(kept * 0.7));
+    body = JSON.stringify(rows.slice(0, kept), null, 1);
+  }
+  const note =
+    kept < rows.length
+      ? ` Showing the first ${kept} of ${rows.length} (output size limit); ask for fewer items.`
+      : '';
+  return `${tool.title}: ${rows.length} result(s).${note}\n${body}`;
+}
+
+export function buildServer({ env = process.env, fetchImpl = fetch } = {}) {
+  const server = new McpServer({ name: 'webdata-tools-mcp', version: '0.1.0' });
+  const maxCharge = Number(env.WEBDATA_MAX_CHARGE_USD) || DEFAULT_MAX_CHARGE_USD;
+
+  for (const tool of TOOLS) {
+    server.registerTool(
+      tool.name,
+      {
+        title: tool.title,
+        description: `${tool.description} Runs the Apify Actor ${tool.actor} on your Apify account (${tool.price}; spend per call is capped at $${maxCharge}).`,
+        inputSchema: { ...tool.shape, extra_input: extraInput },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+      },
+      async (args) => {
+        const problem = tool.check?.(args);
+        if (problem) return { isError: true, content: [{ type: 'text', text: problem }] };
+        try {
+          const { items } = await runActorSync({
+            actor: tool.actor,
+            input: { ...tool.map(args), ...args.extra_input },
+            limit: tool.limit(args),
+            token: env.APIFY_TOKEN,
+            maxChargeUsd: maxCharge,
+            fetchImpl,
+          });
+          return { content: [{ type: 'text', text: formatResult(tool, items) }] };
+        } catch (err) {
+          const text = err instanceof ApifyError ? err.message : `Unexpected error: ${err.message}`;
+          return { isError: true, content: [{ type: 'text', text }] };
+        }
+      },
+    );
+  }
+  return server;
+}

package/src/tools.js

@@ -0,0 +1,305 @@
+// Tool catalogue. Each tool maps a small, agent-friendly argument set onto one Actor's input.
+// `extra_input` lets an agent pass any other documented Actor input field through unchanged.
+
+import { z } from 'zod';
+
+const maxItems = (def, max = 500) =>
+  z
+    .number()
+    .int()
+    .min(1)
+    .max(max)
+    .default(def)
+    .describe(`Maximum results to return (default ${def}, max ${max}). Cost scales with this.`);
+
+export const extraInput = z
+  .record(z.string(), z.unknown())
+  .optional()
+  .describe('Advanced: extra Actor input fields, merged over the defaults.');
+
+const strings = (desc) => z.array(z.string().min(1)).min(1).describe(desc);
+
+const clean = (obj) =>
+  Object.fromEntries(
+    Object.entries(obj).filter(
+      ([, v]) => v !== undefined && v !== null && !(Array.isArray(v) && v.length === 0),
+    ),
+  );
+
+/** Each tool: name, actor, title, description, price note, input shape, map(args) -> Actor input. */
+export const TOOLS = [
+  {
+    name: 'search_google_news',
+    actor: 'tacps126/google-news',
+    title: 'Search Google News',
+    price: 'about $0.002 per article',
+    description:
+      'Search Google News (any language and country) and return articles with the publisher\'s real article URL, publisher, date and related coverage. Supports Google operators ("exact phrase", -exclude, OR, intitle:) and site filters.',
+    shape: {
+      query: z.string().min(1).describe('Search query, e.g. "generative AI" or "tesla -musk".'),
+      country: z.string().length(2).default('US').describe('Two-letter edition country, e.g. US, GB, DE.'),
+      language: z.string().min(2).default('en').describe('Language code, e.g. en, de, fr.'),
+      timeframe: z.enum(['1h', '1d', '7d', '30d', '1y']).optional().describe('Only articles newer than this.'),
+      sites: z.array(z.string()).optional().describe('Limit to these publisher domains, e.g. ["reuters.com"].'),
+      max_items: maxItems(20, 200),
+    },
+    map: (a) =>
+      clean({
+        queries: [a.query],
+        country: a.country,
+        language: a.language,
+        timeframe: a.timeframe,
+        sites: a.sites,
+        maxItems: a.max_items,
+      }),
+    limit: (a) => a.max_items,
+  },
+  {
+    name: 'find_hiring_companies',
+    actor: 'tacps126/hiring-signals',
+    title: 'Find companies hiring for given roles',
+    price: 'about $0.01 per company with a matching signal; companies without one are free',
+    description:
+      'Buying-intent signal: which companies are hiring for the roles you care about, how many roles, how fresh, and seniority/locations. Give target accounts (their jobs-page URLs on Greenhouse, Lever, Ashby, Workday, SmartRecruiters, Recruitee, Personio, Teamtailor) and/or job-search phrases to discover companies.',
+    shape: {
+      role_keywords: z
+        .array(z.string())
+        .optional()
+        .describe('A role counts when its title contains any of these words, e.g. ["data engineer","security"]. Empty = every role.'),
+      companies: z
+        .array(z.string())
+        .optional()
+        .describe('Target accounts\' jobs-page URLs, e.g. "https://boards.greenhouse.io/stripe".'),
+      searches: z
+        .array(z.string())
+        .optional()
+        .describe('Job-search phrases to discover companies you do not know yet, e.g. "head of security".'),
+      locations: z.array(z.string()).optional().describe('Keep roles in these locations.'),
+      posted_within_days: z.number().int().min(1).max(365).default(30).describe('Only roles posted in the last N days.'),
+      max_items: maxItems(50, 500),
+    },
+    check: (a) =>
+      (a.companies?.length || a.searches?.length)
+        ? null
+        : 'Provide at least one of: companies (jobs-page URLs) or searches (job-search phrases).',
+    map: (a) =>
+      clean({
+        companies: a.companies,
+        searches: a.searches,
+        roleKeywords: a.role_keywords,
+        locations: a.locations,
+        postedWithinDays: a.posted_within_days,
+        maxItems: a.max_items,
+      }),
+    limit: (a) => a.max_items,
+  },
+  {
+    name: 'get_company_jobs',
+    actor: 'tacps126/jobs-harvester',
+    title: 'Get all open jobs from company career pages',
+    price: 'about $0.001 per job',
+    description:
+      'All open jobs from company career pages in one normalized format (title, company, location, remote/hybrid, seniority, salary, apply URL, posted date). Paste career-page URLs from Greenhouse, Lever, Ashby, Workable, SmartRecruiters, Recruitee, Workday, Personio or Teamtailor; the board type is detected automatically.',
+    shape: {
+      career_page_urls: strings('Career page URLs, e.g. "https://jobs.lever.co/spotify".'),
+      title_includes: z.array(z.string()).optional().describe('Keep jobs whose title contains any of these.'),
+      location_includes: z.array(z.string()).optional().describe('Keep jobs in these locations.'),
+      remote_only: z.boolean().optional().describe('Only remote jobs.'),
+      posted_within_days: z.number().int().min(1).max(365).optional().describe('Only jobs posted in the last N days.'),
+      max_items: maxItems(50),
+    },
+    map: (a) =>
+      clean({
+        careerPageUrls: a.career_page_urls,
+        titleIncludes: a.title_includes,
+        locationIncludes: a.location_includes,
+        remoteOnly: a.remote_only,
+        postedWithinDays: a.posted_within_days,
+        maxItems: a.max_items,
+      }),
+    limit: (a) => a.max_items,
+  },
+  {
+    name: 'search_indeed_jobs',
+    actor: 'tacps126/indeed-jobs',
+    title: 'Search Indeed jobs',
+    price: 'about $0.003 per job',
+    description:
+      'Search Indeed job listings by keyword and location in 9 countries (us, uk, ca, au, ie, de, fr, nl, sg): title, company, location, salary, job type, benefits, skills and apply link.',
+    shape: {
+      query: z.string().min(1).describe('Job title, skill or company, e.g. "react developer".'),
+      location: z.string().optional().describe('City, state, postcode or "Remote". Empty = whole country.'),
+      country: z.enum(['us', 'uk', 'ca', 'au', 'ie', 'de', 'fr', 'nl', 'sg']).default('us').describe('Indeed country site.'),
+      date_posted_days: z.enum(['1', '3', '7', '14']).optional().describe('Only jobs posted in the last N days.'),
+      job_type: z.enum(['fulltime', 'parttime', 'contract', 'temporary', 'internship']).optional(),
+      max_items: maxItems(30),
+    },
+    map: (a) =>
+      clean({
+        queries: [a.query],
+        locations: a.location ? [a.location] : undefined,
+        country: a.country,
+        datePosted: a.date_posted_days,
+        jobType: a.job_type,
+        maxItems: a.max_items,
+      }),
+    limit: (a) => a.max_items,
+  },
+  {
+    name: 'get_trustpilot_reviews',
+    actor: 'tacps126/trustpilot-reviews',
+    title: 'Get Trustpilot reviews and company rating',
+    price: 'about $0.0005 per review; company profile free',
+    description:
+      'Trustpilot reviews for one or more companies (rating, title, text, reviewer, country, date, company reply) plus the company\'s TrustScore and review counts. Filter by stars, language, verified and date period.',
+    shape: {
+      companies: strings('Company domains or Trustpilot URLs, e.g. "apify.com".'),
+      star_ratings: z.array(z.enum(['1', '2', '3', '4', '5'])).optional().describe('Only these ratings, e.g. ["1","2"] for complaints.'),
+      sort: z.enum(['recency', 'relevance']).default('recency'),
+      search: z.string().optional().describe('Only reviews containing this text.'),
+      date_period: z.enum(['last30days', 'last3months', 'last6months']).optional(),
+      max_reviews: maxItems(50),
+    },
+    map: (a) =>
+      clean({
+        companies: a.companies,
+        starRatings: a.star_ratings,
+        sort: a.sort,
+        search: a.search,
+        datePeriod: a.date_period,
+        maxReviews: a.max_reviews,
+      }),
+    limit: (a) => a.max_reviews + a.companies.length,
+  },
+  {
+    name: 'get_app_reviews',
+    actor: 'tacps126/app-reviews',
+    title: 'Get App Store and Google Play reviews',
+    price: 'about $0.0002 per review',
+    description:
+      'Reviews from the Apple App Store and Google Play in one dataset: rating, text, author, date, app version, developer reply, sentiment. Mix both stores and several countries.',
+    shape: {
+      apps: strings('App Store / Google Play links, App Store ids ("id324684580") or Android package names ("com.spotify.music").'),
+      countries: z.array(z.string().length(2)).default(['us']).describe('Two-letter store countries, e.g. ["us","gb"].'),
+      star_ratings: z.array(z.enum(['1', '2', '3', '4', '5'])).optional().describe('Only these ratings, e.g. ["1","2"].'),
+      max_items: maxItems(100, 2000),
+    },
+    map: (a) =>
+      clean({
+        apps: a.apps,
+        countries: a.countries,
+        starRatings: a.star_ratings,
+        maxItems: a.max_items,
+        maxReviewsPerApp: a.max_items,
+      }),
+    limit: (a) => a.max_items,
+  },
+  {
+    name: 'search_reddit',
+    actor: 'tacps126/reddit-monitor',
+    title: 'Search Reddit posts and comments',
+    price: 'about $0.001 per post or comment',
+    description:
+      'Reddit posts (and optionally comments) by keyword, subreddit or user: title, text, author, subreddit, score, links and dates. Good for brand and topic monitoring.',
+    shape: {
+      keywords: z.array(z.string()).optional().describe('Search all of Reddit; "exact phrase" works.'),
+      subreddits: z.array(z.string()).optional().describe('Subreddit names, e.g. ["webscraping"].'),
+      sort: z.enum(['new', 'hot', 'top', 'relevance']).default('new'),
+      time: z.enum(['hour', 'day', 'week', 'month', 'year', 'all']).default('week'),
+      include_comments: z.boolean().default(false),
+      max_items: maxItems(50),
+    },
+    check: (a) =>
+      (a.keywords?.length || a.subreddits?.length)
+        ? null
+        : 'Provide at least one of: keywords or subreddits.',
+    map: (a) =>
+      clean({
+        keywords: a.keywords,
+        subreddits: a.subreddits,
+        sort: a.sort,
+        time: a.time,
+        includeComments: a.include_comments,
+        maxItems: a.max_items,
+      }),
+    limit: (a) => a.max_items,
+  },
+  {
+    name: 'find_website_contacts',
+    actor: 'tacps126/contact-details',
+    title: 'Find emails, phones and social profiles on websites',
+    price: 'about $0.002 per website with contacts found; nothing found, no charge',
+    description:
+      'Finds business emails, phone numbers, addresses and social profiles (LinkedIn, X, Facebook, Instagram, YouTube) on any list of websites; it visits the contact and about pages itself. Use only for lawful business outreach (GDPR / CAN-SPAM).',
+    shape: {
+      websites: strings('Website addresses or domains, e.g. "apify.com".'),
+      max_pages_per_site: z.number().int().min(1).max(20).default(5),
+      require_email: z.boolean().default(false).describe('Drop sites where no email was found.'),
+      max_items: maxItems(50, 1000),
+    },
+    map: (a) =>
+      clean({
+        startUrls: a.websites,
+        maxPagesPerSite: a.max_pages_per_site,
+        requireEmail: a.require_email,
+        maxItems: a.max_items,
+      }),
+    limit: (a) => a.max_items,
+  },
+  {
+    name: 'search_german_property_listings',
+    actor: 'tacps126/immobilienscout24-scraper',
+    title: 'Search German property listings (ImmoScout24)',
+    price: 'about $0.001 per listing',
+    description:
+      'Apartments and houses for rent or sale in Germany: price, rent, area, rooms, address with coordinates, energy class, features, agent, photos and dates. Germany only.',
+    shape: {
+      locations: strings('Cities, districts or regions in plain words, e.g. ["Berlin","München Schwabing"].'),
+      offer_type: z.enum(['rent', 'buy']).default('rent'),
+      property_type: z.enum(['apartment', 'house']).default('apartment'),
+      min_price: z.number().optional(),
+      max_price: z.number().optional(),
+      min_area: z.number().optional().describe('Minimum area in m2.'),
+      min_rooms: z.number().optional(),
+      max_items: maxItems(50),
+    },
+    map: (a) =>
+      clean({
+        locations: a.locations,
+        offerType: a.offer_type,
+        propertyType: a.property_type,
+        minPrice: a.min_price,
+        maxPrice: a.max_price,
+        minArea: a.min_area,
+        minRooms: a.min_rooms,
+        maxItems: a.max_items,
+      }),
+    limit: (a) => a.max_items,
+  },
+  {
+    name: 'get_shopify_products',
+    actor: 'tacps126/shopify-products',
+    title: 'Get products from Shopify stores',
+    price: 'about $0.001 per product',
+    description:
+      'Products from any Shopify store: prices, sale prices, discounts, stock, variants, SKUs, images and descriptions. Whole stores, collections or single products. Useful for price and stock monitoring.',
+    shape: {
+      stores: strings('Store domains, collection links or product links, e.g. "allbirds.com".'),
+      keywords: z.array(z.string()).optional().describe('Only products matching any of these words.'),
+      only_on_sale: z.boolean().default(false),
+      only_available: z.boolean().default(false),
+      max_items: maxItems(100, 1000),
+    },
+    map: (a) =>
+      clean({
+        startUrls: a.stores,
+        keywords: a.keywords,
+        onlyOnSale: a.only_on_sale || undefined,
+        onlyAvailable: a.only_available || undefined,
+        maxItems: a.max_items,
+      }),
+    limit: (a) => a.max_items,
+  },
+];
+
+export const ACTORS = [...new Set(TOOLS.map((t) => t.actor))];