# DeepSift Search: Tavily-compatible web search for AI agents (`aadstra/deepsift-search`) Actor

Search Google and get back only the passages that answer your question, in the same format as the Tavily API. Works as a drop-in Tavily replacement, an MCP server for Claude and Cursor, or a batch search tool.

- **URL**: https://apify.com/aadstra/deepsift-search.md
- **Developed by:** [Aadstra Labs](https://apify.com/aadstra) (community)
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 searches

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/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

### What does DeepSift Search do?

DeepSift Search gives your AI agent live web search. You send one question; it searches Google, opens the
best pages, and returns **only the passages that answer the question**, ready to drop into an LLM prompt.

It speaks the **same request and response format as the Tavily API**. If your code already uses Tavily,
you can switch by changing one line: the base URL.

Use it three ways:

- 🔁 **As a Tavily drop-in**: point the Tavily SDK (or any HTTP client) at DeepSift's address
- 🤖 **As an MCP server**: add it to Claude, Cursor, Windsurf or any MCP client, and get `web_search`, `web_read`, `web_map` and `web_crawl` tools
- 📋 **As a normal Apify run**: paste a list of search queries, get a table of results

### Why use DeepSift Search?

- **Fewer tokens for your LLM.** You get the best few passages from each page, not whole pages of menus and cookie banners.
- **Switch in a minute.** Same paths (`/search`, `/extract`, `/crawl`, `/map`), same fields, same response shape as Tavily.
- **Pay per use, no subscription.** You pay per search on your Apify account. Failed searches are free.
- **Real Google results.** Up-to-date pages, with country, language, date-range and website filters.
- **No extra API keys.** Your Apify token is the only key you need.

### How to use it as a Tavily drop-in

Your address is `https://aadstra--deepsift-search.apify.actor`. Use your [Apify API token](https://console.apify.com/settings/integrations) as the API key.

**Python (Tavily SDK)**

```python
from tavily import TavilyClient

client = TavilyClient(
    api_key="<YOUR_APIFY_TOKEN>",
    api_base_url="https://aadstra--deepsift-search.apify.actor",
)
result = client.search("who acquired Tavily in 2026", max_results=5)
for row in result["results"]:
    print(row["url"], row["content"])
```

**Any language (HTTP)**

```bash
curl -X POST https://aadstra--deepsift-search.apify.actor/search \
  -H "Authorization: Bearer <YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"query": "best open source vector database 2026", "max_results": 5}'
```

Supported endpoints:

| Endpoint | What it does |
|---|---|
| `POST /search` | Search Google; returns the best passages from each result page |
| `POST /extract` | Readable text of up to 20 pages or PDFs (optionally only the parts about a `query`) |
| `POST /crawl` | Reads many pages of one website; `instructions` keeps the relevant ones |
| `POST /map` | Lists a website's page addresses |

### How to use it as an MCP server

Add this to your MCP client's settings (Claude Code, Claude Desktop, Cursor and others):

```json
{
  "mcpServers": {
    "deepsift-search": {
      "url": "https://aadstra--deepsift-search.apify.actor/mcp",
      "headers": { "Authorization": "Bearer <YOUR_APIFY_TOKEN>" }
    }
  }
}
```

Your agent then has four tools: `web_search`, `web_read`, `web_map` and `web_crawl`.

### How to use it as a normal run

1. Click **Try for free**.
2. Type one search per line in **Search queries**.
3. Pick how many results you want and, if you like, a time range, country or website filter.
4. Click **Start**. Results appear in the **Output** tab and can be downloaded as JSON, CSV or Excel.

### Input

| Field | Meaning |
|---|---|
| `queries` | List of searches (required) |
| `searchDepth` | `basic` (best passage per page), `advanced` (up to three passages, longer page reads) or `fast` (Google snippets only) |
| `maxResults` | Results per search, 1 to 20 (default 5) |
| `topic` | `general`, `news` or `finance` |
| `timeRange` | `day`, `week`, `month` or `year` |
| `includeDomains` / `excludeDomains` | Only search, or never return, these websites |
| `country` / `language` | Two-letter codes, e.g. `us`, `in`, `de` / `en`, `hi` |
| `includeFullPages` | Also return each page's full readable text |

### Output

One row per result:

```json
{
  "query": "best open source vector database 2026",
  "rank": 1,
  "title": "The top open source vector databases & comparison",
  "url": "https://redis.io/blog/best-open-source-vector-databases-comparison/",
  "content": "The top open source vector databases & comparison · Redis · Milvus · Weaviate · Qdrant ...",
  "score": 0.93,
  "publishedDate": null
}
```

### How much does it cost?

You only pay for what you use. Prices per event:

| Event | Price |
|---|---|
| Search (basic or fast) | $0.004 ($4 per 1,000) |
| Advanced search | $0.008 ($8 per 1,000) |
| Page read (each page returned by `/extract` or `/crawl`) | $0.001 ($1 per 1,000) |
| Site map (each `/map` request) | $0.002 ($2 per 1,000) |

Platform usage is included: you pay only the prices above. Failed requests are not charged. You can set a maximum cost for each run, and DeepSift stops (and stops
charging) when it is reached.

For comparison, Tavily's published pay-as-you-go price is $0.008 per credit, and an advanced search uses two credits.

### Limits and good to know

- **No written answers or research reports.** `include_answer` returns `null` and `/research` is not available. DeepSift returns the sources; your own LLM writes the answer.
- **Speed.** The first request after a quiet period takes about 5 to 10 seconds while the server starts. After that, a search takes a few seconds (it opens and reads every result page). Repeating the same search within 24 hours is answered from a cache.
- **Pages that only show text after JavaScript runs** may come back thin.
- **Up to 20 results per search.** More than 10 reads a second Google results page.

### FAQ

**Is it legal to use?** DeepSift reads public web pages and Google results pages. You are responsible for how you use the
data. Don't use it to collect personal data without a legal basis (for example under GDPR).

**Is DeepSift open source?** Yes. The self-hosted version for your own computer is free on
[GitHub](https://github.com/pavanmulka/deepsift). This Apify version saves you from running and maintaining it yourself.

**I found a bug or need a feature.** Open an issue in the **Issues** tab. We usually reply within a few days.

# Actor input Schema

## `queries` (type: `array`):

One search per line. Each search is charged once.

## `searchDepth` (type: `string`):

basic: the best passage from each page. advanced: up to three passages per page, reads pages longer (charged as an advanced search). fast: Google snippets only, no page reading.

## `maxResults` (type: `integer`):

How many websites to return for each search (1-20). More than 10 reads a second Google page.

## `topic` (type: `string`):

news favours recent news articles; finance favours financial sources.

## `timeRange` (type: `string`):

Leave empty for any date.

## `includeDomains` (type: `array`):

For example example.com. Leave empty for the whole web.

## `excludeDomains` (type: `array`):

Results from these websites are dropped.

## `country` (type: `string`):

Two-letter country code (us, gb, in, de...) to get that country's Google results.

## `language` (type: `string`):

Two-letter language code (en, de, hi...).

## `includeFullPages` (type: `boolean`):

Also return the full readable text of each page (long).

## Actor input object example

```json
{
  "queries": [
    "best open source vector databases 2026"
  ],
  "searchDepth": "basic",
  "maxResults": 5,
  "topic": "general",
  "includeFullPages": false
}
```

# Actor output Schema

## `results` (type: `string`):

One row per search result: query, rank, title, URL, best passages, score and published date.

# 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 = {
    "queries": [
        "best open source vector databases 2026"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("aadstra/deepsift-search").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 = { "queries": ["best open source vector databases 2026"] }

# Run the Actor and wait for it to finish
run = client.actor("aadstra/deepsift-search").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 '{
  "queries": [
    "best open source vector databases 2026"
  ]
}' |
apify call aadstra/deepsift-search --silent --output-dataset

```

## MCP server setup

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

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/trHRjOSrGgBz8xt8x/builds/qd10MbceUXRV2Vz6v/openapi.json