# Data Source Finder — Find Where Any Data Lives (Dork-Powered) (`apricot_blackberry/data-source-finder`) Actor

Stop guessing where to scrape. Describe the data you want — it finds the richest directories, registries, datasets and listings that hold it, ranked by how extractable and fresh each is, with the exact way to pull each one. The scout for your scrapers. MCP-ready.

- **URL**: https://apify.com/apricot\_blackberry/data-source-finder.md
- **Developed by:** [Creator Fusion](https://apify.com/apricot_blackberry) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $30.00 / 1,000 source founds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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

## Data Source Finder — stop guessing where to scrape

**The hardest part of scraping isn't the scrape. It's knowing where the data actually lives.** You waste hours Googling, wading past blogs and Pinterest, hunting for the one directory or registry that actually has what you need at scale.

**Tell Data Source Finder what you want — it hands you the sources, ranked.** Describe the data in plain English and it returns the richest directories, government registries, downloadable datasets, and listing sites that hold it, each scored by how extractable and how fresh it is, **with the exact way to pull it.**

> "med spa businesses in Texas with emails" → `americanmedspa.org` (association directory), `tdlr.texas.gov` (state license registry), `texmed.org`… ranked, typed, and ready to scrape.

### Why it finds what plain search can't: clever dorking

Anyone can search. This runs a **library of advanced queries** against every need — `inurl:directory`, `inurl:members`, `filetype:csv`, `site:.gov`, `registry`/`license`, `"list of…"`, owner/contact patterns with the junk sites subtracted — then **ranks the domains that recur across all of them.** Recurrence is authority: the source that shows up for eight different expert queries is the one that actually holds the data. It surfaces the structured, bulk-extractable sources that keyword search buries under content farms.

### What you get, per source

- **`type`** — `registry` (official, authoritative, bulk records) · `dataset` (a file/API — already structured) · `directory` (a member/listing page — many entities at once) · `listing` (single-entity page or seed).
- **`score` (0–100)** — structure × authority (recurrence) × freshness.
- **`freshness` + `live`** — is it up, and when was it last updated (so you don't scrape a graveyard).
- **`suggestedApproach`** — how to actually extract it (bulk export, crawl the directory, hit the API…).

Plus a **SUMMARY**: the top sources, a breakdown by type, and how many queries ran.

### The scout for your whole pipeline

Data Source Finder is the top of the funnel:
**describe the need → find the sources → point a scraper at them → score the result with Trust Score → act.**

- **Chain it (MCP / Zapier / Make / n8n):** feed the top `domain`/`url` straight into a scraper like [Contact Email Finder](https://apify.com/apricot_blackberry/contact-email-finder) or [YouTube Email Finder](https://apify.com/apricot_blackberry/youtube-email-finder), then run the result through [Scrape Trust Score](https://apify.com/apricot_blackberry/scrape-trust-score) before you act.
- **For AI agents:** an agent that needs data first asks *where* to get it — exposed via the Apify MCP server.

### Integrations

```bash
curl -X POST "https://api.apify.com/v2/acts/apricot_blackberry~data-source-finder/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"need":"solar installers in California"}'
```

Also `apify-client` (JS/Python), the Apify MCP server, and the official Apify app in n8n / Make / Zapier.

### Honest about the method

It searches public results with advanced operators and ranks by recurrence, source structure, and freshness — it points you at the best places to get data and how to pull them. It does not itself bypass logins or extract records (that's your scraper's job); it makes sure you aim it at the right target.

# Actor input Schema

## `need` (type: `string`):

Describe it in plain language, e.g. "med spa businesses in Texas with emails" or "solar installers in California". The finder expands this into advanced search queries and returns the sources that hold it.

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

Optional explicit location if it isn't in the need text (e.g. "Texas", "UK").

## `dorks` (type: `array`):

Optional advanced queries to add to the auto-generated set (Bing operators: site:, inurl:, intitle:, filetype:).

## `maxSources` (type: `integer`):

Cap the ranked sources returned.

## `maxDorks` (type: `integer`):

How many advanced queries to run (more = broader coverage, higher cost).

## `deepScore` (type: `boolean`):

Check each source is live and read its freshness (sitemap/Last-Modified) to rank by how current it is.

## `proxyConfiguration` (type: `object`):

Optional. Used only if direct search requests get rate-limited.

## Actor input object example

```json
{
  "need": "med spa businesses in Texas with emails",
  "maxSources": 25,
  "maxDorks": 10,
  "deepScore": true
}
```

# Actor output Schema

## `sources` (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 = {
    "need": "med spa businesses in Texas with emails"
};

// Run the Actor and wait for it to finish
const run = await client.actor("apricot_blackberry/data-source-finder").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 = { "need": "med spa businesses in Texas with emails" }

# Run the Actor and wait for it to finish
run = client.actor("apricot_blackberry/data-source-finder").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 '{
  "need": "med spa businesses in Texas with emails"
}' |
apify call apricot_blackberry/data-source-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,apricot_blackberry/data-source-finder"
        }
    }
}

```

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/uILPq5wGFtfv4fSiN/builds/2GR59opDEIFPvYQMJ/openapi.json