# Apollo News Signal Monitor (`solutionssmart/apollo-news-signal-monitor`) Actor

Monitors RSS feeds, blogs, and newsroom pages for company signals, generates outreach context, and pushes review-ready actions into Apollo.

- **URL**: https://apify.com/solutionssmart/apollo-news-signal-monitor.md
- **Developed by:** [Solutions Smart](https://apify.com/solutionssmart) (community)
- **Categories:** Lead generation, AI, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/platform/actors/running/actors-in-store#pay-per-event

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

## Apollo News Signal Monitor

Apollo News Signal Monitor is an Apify Actor that watches company RSS feeds, blogs, and newsroom pages for fresh signals, scores each item for sales relevance, generates outreach-ready context, and routes the result into Apollo as a task, sequence action, contact update, or review artifact.

### Why this Actor exists

Apollo is strong at workflows, tasks, custom fields, and sequence enrollment, but it is not a dedicated external signal monitor for content sources like RSS feeds and newsrooms. This Actor fills that gap by becoming the ingestion layer between public company signals and Apollo execution.

### What it does

- Monitors RSS, Atom, blog, and newsroom pages for target companies
- Auto-discovers feed URLs when possible and falls back to HTML extraction when no feed exists
- Stores dedupe state in the default key-value store so the same signal is not processed twice
- Scores items using include and exclude keyword logic plus optional company-specific rules
- Extracts normalized content fields such as title, URL, published date, summary, and a cleaned snippet
- Generates AI-assisted or deterministic icebreakers and outreach framing
- Updates Apollo custom fields, creates review tasks, or enrolls contacts into a sequence
- Emits a dataset of processed signals and a `SUMMARY` record for downstream automation

### Input

Use `.actor/input_schema.json` or the Apify Console form. The most important fields are:

- `sources`: array of monitored companies and source URLs
- `includeKeywords` and `excludeKeywords`: global relevance controls
- `minRelevanceScore`: threshold for filtering low-signal items
- `mode`: `detect_only`, `create_task`, `enroll_sequence`, or `human_review`
- `apolloApiKey`: required for Apollo write actions
- `apolloSequenceId`: required for sequence enrollment
- `useAI`, `llmProvider`, and `llmApiKey`: optional AI personalization settings
- `webhookUrl` and `slackWebhookUrl`: optional review notifications
- `dedupeWindowDays`: how long processed signal fingerprints stay in state

#### Example input

This configuration matches a typical human-review run against OpenAI, Anthropic, and Stripe news sources:

```json
{
  "dedupeWindowDays": 30,
  "excludeKeywords": [
    "privacy policy",
    "terms",
    "careers",
    "policy",
    "trust center"
  ],
  "fetchFullArticle": true,
  "includeKeywords": [
    "launch",
    "model",
    "API",
    "enterprise",
    "agent",
    "assistant",
    "platform",
    "product",
    "automation",
    "developers"
  ],
  "maxItemsPerRun": 20,
  "minRelevanceScore": 0.45,
  "mode": "human_review",
  "sources": [
    {
      "companyName": "OpenAI",
      "domain": "openai.com",
      "pageUrl": "https://openai.com/news"
    },
    {
      "companyName": "Anthropic",
      "domain": "anthropic.com",
      "pageUrl": "https://www.anthropic.com/news"
    },
    {
      "companyName": "Stripe",
      "domain": "stripe.com",
      "pageUrl": "https://stripe.com/newsroom/news"
    }
  ],
  "useAI": false
}
````

#### Source object

Each source supports:

- `companyName`
- `domain`
- `rssUrl`
- `pageUrl`
- `companyIdOptional`
- `apolloContactIdOptional`
- `contactEmailOptional`
- `contactFirstNameOptional`
- `contactLastNameOptional`
- `topicRules.includeKeywords`
- `topicRules.excludeKeywords`

### Output

#### Dataset

Each dataset item represents one signal candidate or processed signal. Key fields include:

- `signalDetected`
- `matchedCompany`
- `matchedContact`
- `apolloAction`
- `taskCreated`
- `sequenceEnrolled`
- `customFieldsUpdated`
- `confidence`
- `generatedIcebreakers`
- `reviewBrief`
- `suggestedFirstLine`
- `outreachAngle`
- `reviewRequired`
- `metadata`
- `errors`

#### Key-value store records

- `SUMMARY`: run-level metrics and action summary
- `STATE`: dedupe fingerprints and per-source cursors

### Apollo integration notes

The Apollo client implementation is intentionally isolated in [`src/apollo.ts`](./src/apollo.ts). Apollo API surface details can vary by workspace and endpoint availability, so the Actor:

- favors direct IDs when supplied
- attempts contact lookup with conservative REST calls
- keeps uncertain payload details behind typed helpers and TODO markers
- fails per item instead of failing the whole run

For v1, write actions are best when at least one of these is available:

- `apolloContactIdOptional`
- `contactEmailOptional`
- `companyIdOptional`
- `domain` or `companyName` for lookup

### Personalization behavior

If `useAI` is enabled and the configured provider call succeeds, the Actor returns short personalized icebreakers, a signal summary, an outreach angle, and a suggested first line.

If AI is disabled or the provider call fails, the Actor falls back to deterministic templates so runs stay retry-safe and predictable.

### Production behavior

- Dedupe is based on a canonical signal hash derived from URL or feed GUID
- Missing publish dates are allowed
- Each item is processed independently with retries around network calls
- Logs stay concise and avoid leaking secrets
- Review mode never auto-enrolls contacts into sequences

### Example output

```json
{
  "companyName": "OpenAI",
  "signalType": "rss_post",
  "title": "The next phase of enterprise AI",
  "url": "https://openai.com/index/next-phase-of-enterprise-ai",
  "publishedAt": "2026-04-08T14:00:00.000Z",
  "sourceName": "OpenAI News",
  "summary": "OpenAI outlines the next phase of enterprise AI, as adoption accelerates across industries with Frontier, ChatGPT Enterprise, Codex, and company-wide AI agents.",
  "snippet": "OpenAI outlines the next phase of enterprise AI, as adoption accelerates across industries with Frontier, ChatGPT Enterprise, Codex, and company-wide AI agents.",
  "relevanceScore": 0.65,
  "confidence": 0.7,
  "signalSummary": "OpenAI published a fresh signal around AI product momentum.",
  "reviewBrief": "OpenAI: The next phase of enterprise AI\nScore: 0.65\nSummary: OpenAI published a fresh signal around AI product momentum.\nSuggested opener: Noticed OpenAI's recent update on AI product momentum and thought it was a strong signal for current priorities.",
  "outreachAngle": "Use the update as a timely hook to connect your solution to AI product momentum outcomes and near-term execution priorities.",
  "suggestedFirstLine": "Noticed OpenAI's recent update on AI product momentum and thought it was a strong signal for current priorities.",
  "icebreakers": [
    "Saw OpenAI's latest post on AI product momentum and the timing feels especially relevant.",
    "Your recent update about AI product momentum stood out, particularly the practical execution angle."
  ],
  "generatedIcebreakers": [
    "Saw OpenAI's latest post on AI product momentum and the timing feels especially relevant.",
    "Your recent update about AI product momentum stood out, particularly the practical execution angle."
  ],
  "signalDetected": true,
  "matchedCompany": false,
  "matchedContact": false,
  "apolloAction": "human_review",
  "taskCreated": false,
  "sequenceEnrolled": false,
  "customFieldsUpdated": false,
  "reviewRequired": true,
  "errors": [],
  "metadata": {
    "sourceFeedUrl": "https://openai.com/blog/rss.xml",
    "personalizationProvider": "template",
    "fallbackUsed": true
  },
  "status": "processed"
}
```

### Future extensions

- Competitor monitoring across peer company feeds and launch pages
- Hiring and organizational-news signals for trigger-based prospecting
- Negative signal and churn monitoring based on incidents, layoffs, and pricing changes
- Social listening extensions for supported third-party sources

# Actor input Schema

## `sources` (type: `array`):

Each source can point directly to an RSS feed or to a blog/newsroom page. If only a page URL or domain is supplied, the Actor will try to discover a feed and then fall back to HTML extraction.

## `includeKeywords` (type: `array`):

Keywords that increase relevance across all monitored sources.

## `excludeKeywords` (type: `array`):

Keywords that suppress low-signal, compliance, or irrelevant posts.

## `minRelevanceScore` (type: `number`):

Signals scoring below this threshold are written as low-signal skips and not actioned.

## `mode` (type: `string`):

Choose whether to detect only, create review tasks, enroll contacts, or keep a human review gate.

## `apolloApiKey` (type: `string`):

Secret Apollo API key used for contact updates, task creation, and sequence enrollment.

## `apolloSequenceId` (type: `string`):

Required when mode is set to enroll\_sequence.

## `apolloCustomFieldMapping` (type: `object`):

Map logical field names to Apollo custom field identifiers or keys.

## `useAI` (type: `boolean`):

Enable LLM-based personalization instead of deterministic templates.

## `llmProvider` (type: `string`):

Only used when AI personalization is enabled.

## `llmApiKey` (type: `string`):

Secret provider API key for optional AI-generated personalization.

## `maxItemsPerRun` (type: `integer`):

Global cap on how many candidate signals the Actor will process in a single run.

## `webhookUrl` (type: `string`):

Optional generic webhook that receives a JSON review payload in human\_review mode.

## `slackWebhookUrl` (type: `string`):

Optional Slack webhook used to send a concise review brief.

## `dedupeWindowDays` (type: `integer`):

Number of days processed signal fingerprints stay in state before they are pruned.

## `fetchFullArticle` (type: `boolean`):

When enabled, fetch each detected article URL to improve summary quality and scoring context.

## Actor input object example

```json
{
  "sources": [
    {
      "companyName": "Example Inc",
      "domain": "example.com",
      "pageUrl": "https://example.com/blog",
      "companyIdOptional": "apollo-company-id",
      "apolloContactIdOptional": "apollo-contact-id"
    }
  ],
  "includeKeywords": [
    "launch",
    "product",
    "platform",
    "AI",
    "automation",
    "funding"
  ],
  "excludeKeywords": [
    "privacy policy",
    "terms of service",
    "cookie policy",
    "job board"
  ],
  "minRelevanceScore": 0.45,
  "mode": "detect_only",
  "apolloCustomFieldMapping": {
    "latest_signal_title": "latest_signal_title",
    "latest_signal_url": "latest_signal_url",
    "latest_signal_date": "latest_signal_date",
    "latest_signal_summary": "latest_signal_summary",
    "latest_signal_icebreaker": "latest_signal_icebreaker"
  },
  "useAI": false,
  "maxItemsPerRun": 25,
  "dedupeWindowDays": 30,
  "fetchFullArticle": true
}
```

# Actor output Schema

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

No description

## `summary` (type: `string`):

No description

## `state` (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 = {
    "sources": [
        {
            "companyName": "Example Inc",
            "domain": "example.com",
            "pageUrl": "https://example.com/blog",
            "companyIdOptional": "apollo-company-id",
            "apolloContactIdOptional": "apollo-contact-id"
        }
    ],
    "apolloCustomFieldMapping": {
        "latest_signal_title": "latest_signal_title",
        "latest_signal_url": "latest_signal_url",
        "latest_signal_date": "latest_signal_date",
        "latest_signal_summary": "latest_signal_summary",
        "latest_signal_icebreaker": "latest_signal_icebreaker"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("solutionssmart/apollo-news-signal-monitor").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 = {
    "sources": [{
            "companyName": "Example Inc",
            "domain": "example.com",
            "pageUrl": "https://example.com/blog",
            "companyIdOptional": "apollo-company-id",
            "apolloContactIdOptional": "apollo-contact-id",
        }],
    "apolloCustomFieldMapping": {
        "latest_signal_title": "latest_signal_title",
        "latest_signal_url": "latest_signal_url",
        "latest_signal_date": "latest_signal_date",
        "latest_signal_summary": "latest_signal_summary",
        "latest_signal_icebreaker": "latest_signal_icebreaker",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("solutionssmart/apollo-news-signal-monitor").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 '{
  "sources": [
    {
      "companyName": "Example Inc",
      "domain": "example.com",
      "pageUrl": "https://example.com/blog",
      "companyIdOptional": "apollo-company-id",
      "apolloContactIdOptional": "apollo-contact-id"
    }
  ],
  "apolloCustomFieldMapping": {
    "latest_signal_title": "latest_signal_title",
    "latest_signal_url": "latest_signal_url",
    "latest_signal_date": "latest_signal_date",
    "latest_signal_summary": "latest_signal_summary",
    "latest_signal_icebreaker": "latest_signal_icebreaker"
  }
}' |
apify call solutionssmart/apollo-news-signal-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=solutionssmart/apollo-news-signal-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Apollo News Signal Monitor",
        "description": "Monitors RSS feeds, blogs, and newsroom pages for company signals, generates outreach context, and pushes review-ready actions into Apollo.",
        "version": "0.1",
        "x-build-id": "txELJoISPEDgBQspJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solutionssmart~apollo-news-signal-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solutionssmart-apollo-news-signal-monitor",
                "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/solutionssmart~apollo-news-signal-monitor/runs": {
            "post": {
                "operationId": "runs-sync-solutionssmart-apollo-news-signal-monitor",
                "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/solutionssmart~apollo-news-signal-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-solutionssmart-apollo-news-signal-monitor",
                "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": [
                    "sources"
                ],
                "properties": {
                    "sources": {
                        "title": "Target companies and sources",
                        "minItems": 1,
                        "type": "array",
                        "description": "Each source can point directly to an RSS feed or to a blog/newsroom page. If only a page URL or domain is supplied, the Actor will try to discover a feed and then fall back to HTML extraction.",
                        "items": {
                            "type": "object",
                            "additionalProperties": false,
                            "required": [
                                "companyName"
                            ],
                            "properties": {
                                "companyName": {
                                    "title": "Company name",
                                    "type": "string",
                                    "editor": "textfield",
                                    "minLength": 1,
                                    "description": "Display name used throughout output records and notifications."
                                },
                                "domain": {
                                    "title": "Company domain",
                                    "type": "string",
                                    "editor": "textfield",
                                    "description": "Used for feed discovery, article filtering, and Apollo matching."
                                },
                                "rssUrl": {
                                    "title": "RSS or Atom URL",
                                    "type": "string",
                                    "editor": "textfield",
                                    "description": "Direct RSS or Atom feed URL when already known."
                                },
                                "pageUrl": {
                                    "title": "Blog or newsroom URL",
                                    "type": "string",
                                    "editor": "textfield",
                                    "description": "Landing page for feed discovery or HTML article extraction fallback."
                                },
                                "companyIdOptional": {
                                    "title": "Apollo company ID",
                                    "type": "string",
                                    "editor": "textfield",
                                    "description": "Optional direct Apollo company identifier for downstream matching."
                                },
                                "apolloContactIdOptional": {
                                    "title": "Apollo contact ID",
                                    "type": "string",
                                    "editor": "textfield",
                                    "description": "Optional direct Apollo contact identifier for downstream writes."
                                },
                                "contactEmailOptional": {
                                    "title": "Apollo contact email",
                                    "type": "string",
                                    "editor": "textfield",
                                    "description": "Optional contact email used for Apollo lookup or contact creation."
                                },
                                "contactFirstNameOptional": {
                                    "title": "Contact first name",
                                    "type": "string",
                                    "editor": "textfield",
                                    "description": "Optional first name used when creating a contact in Apollo."
                                },
                                "contactLastNameOptional": {
                                    "title": "Contact last name",
                                    "type": "string",
                                    "editor": "textfield",
                                    "description": "Optional last name used when creating a contact in Apollo."
                                },
                                "topicRules": {
                                    "title": "Company-specific topic rules",
                                    "type": "object",
                                    "description": "Optional per-company keyword overrides layered on top of the global scoring rules.",
                                    "additionalProperties": false,
                                    "properties": {
                                        "includeKeywords": {
                                            "title": "Company include keywords",
                                            "type": "array",
                                            "editor": "stringList",
                                            "description": "Keywords that should boost relevance for this company only.",
                                            "items": {
                                                "type": "string"
                                            }
                                        },
                                        "excludeKeywords": {
                                            "title": "Company exclude keywords",
                                            "type": "array",
                                            "editor": "stringList",
                                            "description": "Keywords that should suppress relevance for this company only.",
                                            "items": {
                                                "type": "string"
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    },
                    "includeKeywords": {
                        "title": "Global include keywords",
                        "type": "array",
                        "description": "Keywords that increase relevance across all monitored sources.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "launch",
                            "product",
                            "platform",
                            "AI",
                            "automation",
                            "funding"
                        ]
                    },
                    "excludeKeywords": {
                        "title": "Global exclude keywords",
                        "type": "array",
                        "description": "Keywords that suppress low-signal, compliance, or irrelevant posts.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "privacy policy",
                            "terms of service",
                            "cookie policy",
                            "job board"
                        ]
                    },
                    "minRelevanceScore": {
                        "title": "Minimum relevance score",
                        "minimum": 0,
                        "maximum": 1,
                        "type": "number",
                        "description": "Signals scoring below this threshold are written as low-signal skips and not actioned.",
                        "default": 0.45
                    },
                    "mode": {
                        "title": "Apollo action mode",
                        "enum": [
                            "detect_only",
                            "create_task",
                            "enroll_sequence",
                            "human_review"
                        ],
                        "type": "string",
                        "description": "Choose whether to detect only, create review tasks, enroll contacts, or keep a human review gate.",
                        "default": "detect_only"
                    },
                    "apolloApiKey": {
                        "title": "Apollo API key",
                        "type": "string",
                        "description": "Secret Apollo API key used for contact updates, task creation, and sequence enrollment."
                    },
                    "apolloSequenceId": {
                        "title": "Apollo sequence ID",
                        "type": "string",
                        "description": "Required when mode is set to enroll_sequence."
                    },
                    "apolloCustomFieldMapping": {
                        "title": "Apollo custom field mapping",
                        "type": "object",
                        "description": "Map logical field names to Apollo custom field identifiers or keys.",
                        "properties": {
                            "latest_signal_title": {
                                "title": "Latest signal title field",
                                "type": "string",
                                "editor": "textfield",
                                "description": "Apollo custom field key or identifier that should receive the latest signal title."
                            },
                            "latest_signal_url": {
                                "title": "Latest signal URL field",
                                "type": "string",
                                "editor": "textfield",
                                "description": "Apollo custom field key or identifier that should receive the latest signal URL."
                            },
                            "latest_signal_date": {
                                "title": "Latest signal date field",
                                "type": "string",
                                "editor": "textfield",
                                "description": "Apollo custom field key or identifier that should receive the latest signal publish date."
                            },
                            "latest_signal_summary": {
                                "title": "Latest signal summary field",
                                "type": "string",
                                "editor": "textfield",
                                "description": "Apollo custom field key or identifier that should receive the generated signal summary."
                            },
                            "latest_signal_icebreaker": {
                                "title": "Latest signal icebreaker field",
                                "type": "string",
                                "editor": "textfield",
                                "description": "Apollo custom field key or identifier that should receive the primary icebreaker."
                            }
                        },
                        "additionalProperties": false
                    },
                    "useAI": {
                        "title": "Use AI personalization",
                        "type": "boolean",
                        "description": "Enable LLM-based personalization instead of deterministic templates.",
                        "default": false
                    },
                    "llmProvider": {
                        "title": "LLM provider",
                        "type": "string",
                        "description": "Only used when AI personalization is enabled."
                    },
                    "llmApiKey": {
                        "title": "LLM API key",
                        "type": "string",
                        "description": "Secret provider API key for optional AI-generated personalization."
                    },
                    "maxItemsPerRun": {
                        "title": "Maximum items per run",
                        "minimum": 1,
                        "maximum": 250,
                        "type": "integer",
                        "description": "Global cap on how many candidate signals the Actor will process in a single run.",
                        "default": 25
                    },
                    "webhookUrl": {
                        "title": "Generic webhook URL",
                        "type": "string",
                        "description": "Optional generic webhook that receives a JSON review payload in human_review mode."
                    },
                    "slackWebhookUrl": {
                        "title": "Slack webhook URL",
                        "type": "string",
                        "description": "Optional Slack webhook used to send a concise review brief."
                    },
                    "dedupeWindowDays": {
                        "title": "Dedupe window in days",
                        "minimum": 1,
                        "maximum": 365,
                        "type": "integer",
                        "description": "Number of days processed signal fingerprints stay in state before they are pruned.",
                        "default": 30
                    },
                    "fetchFullArticle": {
                        "title": "Fetch full article content",
                        "type": "boolean",
                        "description": "When enabled, fetch each detected article URL to improve summary quality and scoring context.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
