# Actor Run Search (`true.false.maybe/actor-run-search`) Actor

Find historical Apify Actor runs by searching run inputs for exact or partial text matches. Quickly locate run IDs without manually browsing run history.

- **URL**: https://apify.com/true.false.maybe/actor-run-search.md
- **Developed by:** [TrueFalseMaybe](https://apify.com/true.false.maybe) (community)
- **Categories:** Automation, Integrations, Developer tools
- **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

## 🔎 Apify Run Input Search (Apify Actor)

This Apify Actor searches through an Actor’s historical run inputs and finds runs containing a specific keyword, phrase, URL, or partial text match.

The Actor scans all available runs, loads each run’s `INPUT` record from its Key-Value Store, and performs a case-insensitive text search against the full JSON input.

Results are exported into an Apify Dataset for easy filtering, analysis, or debugging.

---

### 🚀 How It Works

The Actor:

1. Fetches all runs from a target Actor
2. Extracts each run’s Key-Value Store ID
3. Loads the `INPUT` record from every run
4. Converts the input JSON into searchable text
5. Searches for a user-provided term
6. Stores matching runs in the Dataset

---

### 🧠 Use Cases

- Find runs containing a specific URL
- Locate runs by keyword or product name
- Search historical automation inputs
- Recover lost run configurations
- Audit old Actor runs
- Investigate customer executions
- Debug large-scale automation workflows

---

## 📥 Input Options

### 🔑 `actorId`

The Actor ID whose runs should be searched.

- **Type:** `string`
- **Required:** yes

```json
"actorId": "nwua9Gu5YrADL7ZDj"
````

***

### 🔍 `searchTerm`

Text to search for inside run inputs.

Supports:

- URLs
- partial strings
- keywords
- JSON fragments
- usernames
- arbitrary text

Search is:

- case-insensitive

- partial-match based

- **Type:** `string`

- **Required:** yes

```json
"searchTerm": "kitchenaid"
```

```json
"searchTerm": "https://www.ebay.com/usr/kitchenaid"
```

***

### 🔐 `apiToken`

Optional custom Apify API token.

If omitted, the Actor automatically uses its own execution token.

Useful when:

- searching another account’s runs

- accessing private Actors

- cross-account debugging

- **Type:** `string`

- **Optional**

- Hidden securely in Actor input UI

```json
"apiToken": "apify_api_xxxxxxxxx"
```

***

### 🛑 `stopIfMatchFound`

Controls whether the Actor stops after finding the first match.

#### `true`

- Stops early
- Faster execution
- Lower API usage

#### `false`

- Processes all runs

- Finds every possible match

- Pushes all matches to dataset

- **Type:** `boolean`

- **Default:** `true`

```json
"stopIfMatchFound": false
```

***

### ⚡ `concurrency`

Number of runs processed simultaneously.

Higher values:

- increase speed
- increase API request volume

Recommended:

- `10-100` for most cases

- `100-500+` for aggressive searching

- **Type:** `integer`

- **Default:** `50`

```json
"concurrency": 100
```

***

## 📥 Full Input Example

```json
{
  "actorId": "nwua9Gu5YrADL7ZDj",
  "searchTerm": "kitchenaid",
  "apiToken": "",
  "stopIfMatchFound": false,
  "concurrency": 100
}
```

***

## 📤 Output

Each dataset item represents one matching run input.

***

### Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `runId` | `string` | Apify Run ID |
| `storeId` | `string` | Key-Value Store ID associated with the run |
| `matchedTerm` | `string` | Search term used |
| `matched` | `boolean` | Indicates successful match |
| `inputPreview` | `string` | Truncated preview of input JSON |
| `input` | `object` | Full original INPUT payload |

***

## 📤 Output Example

```json
{
  "runId": "3KH8s2a9LmP4xQvWc",
  "storeId": "Jt9mKz1vQaY2LpNs",
  "matchedTerm": "kitchenaid",
  "matched": true,
  "inputPreview": "{\"startUrls\":[{\"url\":\"https://www.ebay.com/usr/kitchenaid\"}]}",
  "input": {
    "startUrls": [
      {
        "url": "https://www.ebay.com/usr/kitchenaid"
      }
    ]
  }
}
```

***

## 📊 Dataset Views

The Actor includes multiple Dataset views:

| View | Description |
| --- | --- |
| `Overview 🔎` | General match overview |
| `Matches 🎯` | Match-focused output |
| `Input Data 📦` | Full input payloads |
| `Store IDs 🆔` | IDs only |

***

## ⚠️ Notes

- The Actor searches only the `INPUT` record of each run
- Search uses `JSON.stringify(input).includes(...)`
- Matching is case-insensitive
- Extremely large Actors may take significant time to process
- Private Actors require a valid API token with access

***

## ⚠️ Legal Disclaimer

This Actor is not affiliated with or endorsed by Apify.

Users are responsible for:

- complying with Apify Terms of Service
- respecting account permissions
- ensuring authorized access to searched Actors

# Actor input Schema

## `actorId` (type: `string`):

ID of the Actor whose runs should be searched.

## `searchTerm` (type: `string`):

Keyword, URL, phrase, or partial text to search for inside run inputs.

## `stopIfMatchFound` (type: `boolean`):

If enabled, the Actor stops after finding the first batch containing matches.

## `concurrency` (type: `integer`):

Number of runs processed simultaneously.

## `apiToken` (type: `string`):

Optional Apify API token used instead of the Actor's default token.

## Actor input object example

```json
{
  "stopIfMatchFound": false,
  "concurrency": 50
}
```

# Actor output Schema

## `overview` (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("true.false.maybe/actor-run-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("true.false.maybe/actor-run-search").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 true.false.maybe/actor-run-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=true.false.maybe/actor-run-search",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Actor Run Search",
        "description": "Find historical Apify Actor runs by searching run inputs for exact or partial text matches. Quickly locate run IDs without manually browsing run history.",
        "version": "0.0",
        "x-build-id": "TPatu6aDYiFLnOtuw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/true.false.maybe~actor-run-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-true.false.maybe-actor-run-search",
                "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/true.false.maybe~actor-run-search/runs": {
            "post": {
                "operationId": "runs-sync-true.false.maybe-actor-run-search",
                "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/true.false.maybe~actor-run-search/run-sync": {
            "post": {
                "operationId": "run-sync-true.false.maybe-actor-run-search",
                "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",
                "required": [
                    "actorId",
                    "searchTerm"
                ],
                "properties": {
                    "actorId": {
                        "title": "Actor ID",
                        "type": "string",
                        "description": "ID of the Actor whose runs should be searched."
                    },
                    "searchTerm": {
                        "title": "Search Term",
                        "type": "string",
                        "description": "Keyword, URL, phrase, or partial text to search for inside run inputs."
                    },
                    "stopIfMatchFound": {
                        "title": "Stop After Match Found",
                        "type": "boolean",
                        "description": "If enabled, the Actor stops after finding the first batch containing matches.",
                        "default": false
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Number of runs processed simultaneously.",
                        "default": 50
                    },
                    "apiToken": {
                        "title": "Custom API Token",
                        "type": "string",
                        "description": "Optional Apify API token used instead of the Actor's default token."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```