# Alternative Data Signal Aggregator (`automation-lab/alternative-data-signal-aggregator`) Actor

Turn public news, hiring, and SEC filing data into one auditable company research indicator with evidence and cross-run hiring deltas.

- **URL**: https://apify.com/automation-lab/alternative-data-signal-aggregator.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Alternative Data Signal Aggregator

Turn public news, hiring, and SEC filing data into one auditable research indicator per US-listed company.

The actor joins three anonymous HTTP sources:

- 📰 Google News RSS for headline sentiment and velocity
- 🧑‍💻 Public Greenhouse boards for opening counts and cross-run changes
- 🏛️ SEC Company Facts for filing-backed revenue and gross-margin changes

Instead of exporting thousands of unrelated raw records, it saves one normalized company row with a `-100..100` score, confidence, rationale, timestamps, and evidence URLs.

> The score is a transparent research indicator. It is not investment advice, a price forecast, or a buy/sell instruction.

### What does Alternative Data Signal Aggregator do?

For every supplied ticker and Greenhouse board mapping, the actor:

1. resolves the ticker to an SEC CIK;
2. searches recent Google News RSS headlines;
3. scores headline words with a deterministic local lexicon;
4. loads the company's current public Greenhouse openings;
5. compares job IDs with the prior named-store snapshot;
6. extracts comparable annual SEC revenue and gross profit facts;
7. calculates three component scores;
8. combines them using your normalized weights;
9. saves one evidence-linked dataset row.

The first run is clearly marked as a baseline. Later runs with the same snapshot settings can report new, removed, and net job openings.

### Who is it for?

#### Quant researchers

Schedule a small ticker watchlist and receive consistent rows that can enter a feature store or review queue.

#### Equity analysts

Use evidence URLs and plain-language rationale to identify companies that need deeper primary research.

#### Small funds and family offices

Monitor workforce, narrative, and filing changes without maintaining three collectors and a join pipeline.

#### Fintech and data-product builders

Call one Actor API and deliver normalized JSON to a dashboard, alerting system, notebook, or warehouse.

#### Corporate strategy teams

Compare hiring direction and public narrative across peers that use Greenhouse.

### Why use this actor?

- ✅ **Joined output:** one company row, not separate feeds
- ✅ **Auditable:** source links, filing accession, and collection time are retained
- ✅ **Repeatable:** named KVS snapshots support scheduled hiring deltas
- ✅ **Transparent:** component scores, weights, confidence, and rationale are exposed
- ✅ **Deterministic:** no paid AI key or opaque LLM is required
- ✅ **HTTP-only:** no browser, login, proxy, or user credential is required
- ✅ **Bounded:** watchlist and embedded evidence limits keep runs predictable
- ✅ **Resilient:** one source failure is reported without hiding other components

### Supported companies and important limitation

V1 supports US-listed companies that:

- appear in the SEC public ticker mapping;
- have filing facts in SEC Company Facts; and
- expose a public Greenhouse job board.

You must provide the Greenhouse board token explicitly.

For example, the token for `https://boards.greenhouse.io/cloudflare` is `cloudflare`.

The actor does not guess the board from the company name. This avoids silently attaching the wrong employer's hiring data.

### What data can I extract?

| Group | Fields |
|---|---|
| Identity | `ticker`, `companyName`, `cik`, `asOf`, `windowDays` |
| Baseline | `baseline`, hiring `deltaAvailable` |
| News | article count, publishers, articles/day, count change, sentiment, component score |
| Hiring | total, new, removed, net change, department mix, location mix, sample job URLs |
| Fundamentals | fiscal year, filing date, accession, revenue, revenue YoY, gross margin, margin delta |
| Composite | score, label, confidence, normalized weights, component scores, rationale |
| Evidence | Google News RSS, Greenhouse board, SEC Company Facts, timestamps |
| Diagnostics | `sourceErrors` and component-level errors |

Nested component objects remain together so each dataset item is a complete research record.

### How is the signal calculated?

#### News component

Headline titles use a deterministic positive/negative finance-oriented word list.

Average sentiment contributes most of the news score. When a previous snapshot exists, article-count velocity also contributes.

No article body is fetched and no claim of human-level sentiment understanding is made.

#### Hiring component

Current Greenhouse job IDs are compared with the previous snapshot:

- new IDs become `newOpenings`;
- missing old IDs become `removedOpenings`;
- new minus removed becomes `netChange`.

On the first run, the hiring component is a baseline with score zero.

#### Fundamentals component

The actor selects annual `10-K` / `FY` facts for common US-GAAP revenue concepts and `GrossProfit`.

It calculates revenue year-over-year change and gross-margin percentage-point change when comparable facts exist.

#### Composite

Component scores are clamped to `-100..100` and combined with normalized weights.

Confidence falls when headline coverage is thin, hiring has no prior snapshot, or filing metrics are unavailable.

### Input

A minimal input is:

```json
{
  "companies": [
    {
      "ticker": "NET",
      "companyName": "Cloudflare",
      "greenhouseBoardToken": "cloudflare"
    }
  ],
  "lookbackDays": 7,
  "maxNewsArticles": 25,
  "maxEvidenceItems": 5,
  "snapshotNamespace": "my-watchlist"
}
````

Available settings:

| Input | Default | Purpose |
|---|---:|---|
| `companies` | required | 1–25 explicit company mappings |
| `lookbackDays` | `7` | recent Google News window, 1–30 days |
| `maxNewsArticles` | `50` | headlines scored per company, maximum 100 |
| `maxEvidenceItems` | `8` | embedded headline/job evidence per source |
| `weights.news` | `0.4` | relative news weight |
| `weights.hiring` | `0.35` | relative hiring weight |
| `weights.fundamentals` | `0.25` | relative filing-fundamentals weight |
| `snapshotStoreName` | `alternative-data-signal-snapshots` | named KVS for comparisons |
| `snapshotNamespace` | `default` | stable watchlist/client separation key |
| `secUserAgent` | actor contact | descriptive SEC request identity |

Weights can use any non-negative scale. They are normalized automatically.

### Output example

```json
{
  "ticker": "NET",
  "companyName": "Cloudflare",
  "cik": "0001477333",
  "asOf": "2026-07-14T15:00:00.000Z",
  "windowDays": 7,
  "baseline": true,
  "news": {
    "articleCount": 25,
    "uniquePublishers": 18,
    "articlesPerDay": 3.57,
    "articleCountChange": null,
    "sentimentScore": 4.2,
    "sentimentLabel": "neutral",
    "componentScore": 2.94,
    "evidence": []
  },
  "hiring": {
    "totalOpenings": 259,
    "newOpenings": null,
    "removedOpenings": null,
    "netChange": null,
    "deltaAvailable": false,
    "departmentMix": {},
    "locationMix": {},
    "componentScore": 0,
    "sampleJobUrls": []
  },
  "fundamentals": {
    "latestFilingDate": "2026-02-20",
    "latestAccessionNumber": "...",
    "latestFiscalYear": 2025,
    "revenue": 2168000000,
    "revenueYoYPct": 27.8,
    "grossMarginPct": 75.1,
    "grossMarginDeltaPp": -1.2,
    "componentScore": 24.8
  },
  "composite": {
    "score": 7.38,
    "label": "neutral",
    "confidence": 0.83,
    "weights": { "news": 0.4, "hiring": 0.35, "fundamentals": 0.25 },
    "componentScores": { "news": 2.94, "hiring": 0, "fundamentals": 24.8 },
    "rationale": []
  },
  "sourceErrors": []
}
```

Values above illustrate the shape; live source data changes.

### First run and scheduled monitoring

A first run stores:

- current headline count;
- current Greenhouse job IDs; and
- collection time.

It returns `baseline: true` and `hiring.deltaAvailable: false`.

For comparisons:

1. keep `snapshotStoreName` unchanged;
2. keep `snapshotNamespace` unchanged;
3. keep ticker and Greenhouse token unchanged;
4. schedule the same Actor input daily or weekly.

Use a unique namespace per watchlist or client. Named stores belong to the Actor account, so careless namespace reuse can merge histories for identical mappings.

### How much does it cost to monitor alternative data signals?

The actor uses pay-per-event pricing:

- a small one-time run-start charge;
- one `company-signal` event for each dataset row produced.

The formula-derived BRONZE price is `$0.0024617` per company signal, with automatic lower prices on higher Apify tiers.

You are not charged per raw headline or job. The buyer output is the normalized company signal.

Before a production watchlist, run one company to verify mapping and source coverage.

### How to run the actor

1. Open the Actor input page.
2. Add one to 25 company mappings.
3. Choose a stable snapshot namespace.
4. Keep the default seven-day news window or adjust it.
5. Run the Actor.
6. Review `sourceErrors`, confidence, and evidence.
7. Export JSON, CSV, Excel, or connect an integration.
8. Schedule later runs if hiring deltas are required.

### Practical analysis tips

- Start with one company and confirm its Greenhouse token.
- Compare confidence before ranking companies by score.
- Treat small headline samples as weak evidence.
- Inspect rationale and source URLs before acting on an outlier.
- Use the same lookback window across peers.
- Avoid interpreting a first-run hiring score as direction.
- Store raw exported rows if you need your own long history.
- Keep component weights stable when comparing time periods.

### Integrations and workflow patterns

#### Google Sheets

Send each scheduled dataset to a sheet for an analyst review queue.

#### Slack or email alerts

Trigger an alert only when confidence is above your threshold and score moves materially.

#### Webhooks

Use the run-finished webhook to pass the dataset URL to an internal pipeline.

#### Snowflake, BigQuery, or PostgreSQL

Load one row per ticker/run into a research feature table.

#### Python notebooks

Pull the dataset through the Apify API and compare component scores against your own models.

#### Zapier and Make

Build no-code workflows around new rows, score bands, or source errors.

### API usage with Node.js

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/alternative-data-signal-aggregator').call({
  companies: [
    { ticker: 'NET', companyName: 'Cloudflare', greenhouseBoardToken: 'cloudflare' }
  ],
  snapshotNamespace: 'node-watchlist'
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0].composite);
```

### API usage with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/alternative-data-signal-aggregator').call(run_input={
    'companies': [
        {'ticker': 'NET', 'companyName': 'Cloudflare', 'greenhouseBoardToken': 'cloudflare'}
    ],
    'snapshotNamespace': 'python-watchlist',
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items[0]['composite'])
```

### API usage with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~alternative-data-signal-aggregator/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "companies":[{"ticker":"NET","companyName":"Cloudflare","greenhouseBoardToken":"cloudflare"}],
    "snapshotNamespace":"curl-watchlist"
  }'
```

Fetch results from the run's `defaultDatasetId` after it succeeds.

### Use with Apify MCP

Connect the Actor to AI clients through [Apify MCP](https://mcp.apify.com/?tools=automation-lab/alternative-data-signal-aggregator).

#### Claude Code

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com/?tools=automation-lab/alternative-data-signal-aggregator"
```

Example prompt:

> Run the Alternative Data Signal Aggregator for Cloudflare using its `cloudflare` Greenhouse token. Explain each component and cite the evidence URLs. Do not give investment advice.

#### Claude Desktop

Add this `mcpServers` JSON to Claude Desktop's configuration:

```json
{
  "mcpServers": {
    "apify": {
      "type": "http",
      "url": "https://mcp.apify.com/?tools=automation-lab/alternative-data-signal-aggregator"
    }
  }
}
```

#### Cursor

Open **Settings → Tools & Integrations → MCP**, add a remote HTTP server, and use the same `mcpServers` JSON and URL shown above.

#### VS Code

Open the MCP server configuration in VS Code, choose an HTTP server, and set its URL to:

```text
https://mcp.apify.com/?tools=automation-lab/alternative-data-signal-aggregator
```

Example prompt:

> Compare the news, hiring, and SEC components from my latest cybersecurity watchlist dataset. Flag low-confidence rows.

### Error handling

The actor retries transient `429` and `5xx` responses up to three times.

If one company source fails:

- the failure appears in `sourceErrors`;
- the relevant component contains an `error` message;
- other available components still contribute a row;
- confidence is reduced.

Input errors, such as a missing required mapping or duplicate ticker, stop the run early with a clear message.

### Data quality and interpretation

Public data has limitations:

- a headline lexicon cannot understand every irony or context;
- Google News coverage varies by company and day;
- Greenhouse shows only roles published on that board;
- a company may use several applicant-tracking systems;
- SEC taxonomies and fiscal calendars vary;
- amended filings can restate facts;
- short windows can exaggerate change.

Use confidence, component values, and evidence—not the composite alone.

### Legality and responsible use

The actor accesses public Google News RSS, public Greenhouse board APIs, and official SEC data.

Users are responsible for:

- complying with applicable laws and source terms;
- respecting SEC fair-access guidance;
- using a descriptive SEC User-Agent;
- avoiding misleading financial claims;
- protecting exported datasets and client-specific watchlist names;
- obtaining professional advice where required.

This Actor does not execute trades and does not provide financial advice.

### FAQ

#### Does it predict stock prices?

No. It creates a transparent research indicator from three public data components.

#### Does it use ChatGPT or another paid model?

No. Headline scoring is deterministic and local.

#### Can it monitor companies that do not use Greenhouse?

Not in v1. A public Greenhouse token is required to preserve a consistent three-source product.

#### Why is hiring delta unavailable?

The first run is a baseline. Rerun with the same store name, namespace, ticker, and board token.

#### Why did my company return a Greenhouse 404?

Check the exact token after `boards.greenhouse.io/`. Do not use a company website slug unless it matches the board URL.

#### Why are revenue or margin fields null?

The company's SEC taxonomy may not expose comparable annual USD facts under the supported concepts. Inspect the SEC evidence URL.

#### Can I change the score weights?

Yes. Provide any non-negative values; the actor normalizes them.

#### Can I backtest years of signals?

No. Historical backtesting is intentionally outside v1. Export scheduled rows to build your own history.

#### How many companies should I run first?

One. Confirm mappings and evidence, then expand up to 25 companies.

### Troubleshooting checklist

If output looks wrong:

1. verify the ticker is US-listed and present in SEC mappings;
2. open the Greenhouse board URL from `evidence`;
3. inspect `sourceErrors`;
4. compare headline evidence with the selected lookback;
5. confirm snapshot namespace consistency;
6. check whether this is the baseline run;
7. review confidence before interpreting the score.

### Related scrapers

Use raw component actors when you need source records instead of one normalized company signal:

- [Google News Scraper](https://apify.com/automation-lab/google-news-scraper) for individual news articles
- [Greenhouse Jobs Scraper](https://apify.com/automation-lab/greenhouse-jobs-scraper) for full job listings
- [SEC Company Facts API Scraper](https://apify.com/automation-lab/sec-company-facts-api-scraper) for flattened XBRL facts
- [Financial Statements Scraper](https://apify.com/automation-lab/financial-statements-scraper) for statement-oriented SEC output

### Changelog

See the Actor changelog for user-facing releases and behavior changes.

### Support

When reporting a problem, include:

- the run URL;
- a redacted input;
- affected ticker;
- Greenhouse board token;
- expected versus actual component;
- any `sourceErrors` value.

That evidence makes source-specific diagnosis much faster.

# Actor input Schema

## `companies` (type: `array`):

US-listed companies to analyze. Each company needs its ticker, display name, and public Greenhouse board token (the segment after boards.greenhouse.io/).

## `lookbackDays` (type: `integer`):

Count and score headlines published in this recent window.

## `maxNewsArticles` (type: `integer`):

Bound the headlines used for each company score.

## `maxEvidenceItems` (type: `integer`):

Maximum sample headline and job URLs retained inside each company signal.

## `weights` (type: `object`):

Relative non-negative weights. Values are normalized automatically.

## `snapshotStoreName` (type: `string`):

Named key-value store used to compare hiring and news counts across scheduled runs.

## `snapshotNamespace` (type: `string`):

Use a stable unique namespace for each watchlist or client to prevent histories from overlapping.

## `secUserAgent` (type: `string`):

Descriptive SEC request User-Agent. Include an application name and contact email for production use.

## Actor input object example

```json
{
  "companies": [
    {
      "ticker": "NET",
      "companyName": "Cloudflare",
      "greenhouseBoardToken": "cloudflare"
    }
  ],
  "lookbackDays": 7,
  "maxNewsArticles": 20,
  "maxEvidenceItems": 5,
  "weights": {
    "news": 0.4,
    "hiring": 0.35,
    "fundamentals": 0.25
  },
  "snapshotStoreName": "alternative-data-signal-snapshots",
  "snapshotNamespace": "my-watchlist",
  "secUserAgent": "MyResearchPipeline/1.0 research@example.com"
}
```

# Actor output Schema

## `companySignals` (type: `string`):

No description

## `dataset` (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 = {
    "companies": [
        {
            "ticker": "NET",
            "companyName": "Cloudflare",
            "greenhouseBoardToken": "cloudflare"
        }
    ],
    "lookbackDays": 7,
    "maxNewsArticles": 20,
    "maxEvidenceItems": 5,
    "weights": {
        "news": 0.4,
        "hiring": 0.35,
        "fundamentals": 0.25
    },
    "snapshotStoreName": "alternative-data-signal-snapshots",
    "snapshotNamespace": "my-watchlist",
    "secUserAgent": "MyResearchPipeline/1.0 research@example.com"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/alternative-data-signal-aggregator").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 = {
    "companies": [{
            "ticker": "NET",
            "companyName": "Cloudflare",
            "greenhouseBoardToken": "cloudflare",
        }],
    "lookbackDays": 7,
    "maxNewsArticles": 20,
    "maxEvidenceItems": 5,
    "weights": {
        "news": 0.4,
        "hiring": 0.35,
        "fundamentals": 0.25,
    },
    "snapshotStoreName": "alternative-data-signal-snapshots",
    "snapshotNamespace": "my-watchlist",
    "secUserAgent": "MyResearchPipeline/1.0 research@example.com",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/alternative-data-signal-aggregator").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 '{
  "companies": [
    {
      "ticker": "NET",
      "companyName": "Cloudflare",
      "greenhouseBoardToken": "cloudflare"
    }
  ],
  "lookbackDays": 7,
  "maxNewsArticles": 20,
  "maxEvidenceItems": 5,
  "weights": {
    "news": 0.4,
    "hiring": 0.35,
    "fundamentals": 0.25
  },
  "snapshotStoreName": "alternative-data-signal-snapshots",
  "snapshotNamespace": "my-watchlist",
  "secUserAgent": "MyResearchPipeline/1.0 research@example.com"
}' |
apify call automation-lab/alternative-data-signal-aggregator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/alternative-data-signal-aggregator",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Alternative Data Signal Aggregator",
        "description": "Turn public news, hiring, and SEC filing data into one auditable company research indicator with evidence and cross-run hiring deltas.",
        "version": "0.1",
        "x-build-id": "jvUY32h6LFsrB2xGK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~alternative-data-signal-aggregator/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-alternative-data-signal-aggregator",
                "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/automation-lab~alternative-data-signal-aggregator/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-alternative-data-signal-aggregator",
                "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/automation-lab~alternative-data-signal-aggregator/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-alternative-data-signal-aggregator",
                "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": [
                    "companies"
                ],
                "properties": {
                    "companies": {
                        "title": "🏢 Company watchlist",
                        "minItems": 1,
                        "maxItems": 25,
                        "type": "array",
                        "description": "US-listed companies to analyze. Each company needs its ticker, display name, and public Greenhouse board token (the segment after boards.greenhouse.io/).",
                        "items": {
                            "type": "object",
                            "required": [
                                "ticker",
                                "companyName",
                                "greenhouseBoardToken"
                            ],
                            "properties": {
                                "ticker": {
                                    "title": "Ticker",
                                    "type": "string",
                                    "description": "US stock ticker resolved through the SEC company ticker file."
                                },
                                "companyName": {
                                    "title": "Company name",
                                    "type": "string",
                                    "description": "Name used in the Google News query."
                                },
                                "greenhouseBoardToken": {
                                    "title": "Greenhouse board token",
                                    "type": "string",
                                    "description": "Public board token, for example cloudflare from boards.greenhouse.io/cloudflare."
                                }
                            }
                        }
                    },
                    "lookbackDays": {
                        "title": "News lookback (days)",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Count and score headlines published in this recent window.",
                        "default": 7
                    },
                    "maxNewsArticles": {
                        "title": "Maximum headlines per company",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Bound the headlines used for each company score.",
                        "default": 50
                    },
                    "maxEvidenceItems": {
                        "title": "Evidence rows per source",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum sample headline and job URLs retained inside each company signal.",
                        "default": 8
                    },
                    "weights": {
                        "title": "Component weights",
                        "type": "object",
                        "description": "Relative non-negative weights. Values are normalized automatically.",
                        "properties": {
                            "news": {
                                "title": "News",
                                "description": "Relative weight for headline sentiment and velocity.",
                                "type": "number",
                                "minimum": 0,
                                "default": 0.4
                            },
                            "hiring": {
                                "title": "Hiring",
                                "description": "Relative weight for cross-run job-opening changes.",
                                "type": "number",
                                "minimum": 0,
                                "default": 0.35
                            },
                            "fundamentals": {
                                "title": "Fundamentals",
                                "description": "Relative weight for filing-backed annual changes.",
                                "type": "number",
                                "minimum": 0,
                                "default": 0.25
                            }
                        }
                    },
                    "snapshotStoreName": {
                        "title": "Snapshot store name",
                        "type": "string",
                        "description": "Named key-value store used to compare hiring and news counts across scheduled runs.",
                        "default": "alternative-data-signal-snapshots"
                    },
                    "snapshotNamespace": {
                        "title": "Snapshot namespace",
                        "type": "string",
                        "description": "Use a stable unique namespace for each watchlist or client to prevent histories from overlapping.",
                        "default": "default"
                    },
                    "secUserAgent": {
                        "title": "SEC User-Agent",
                        "type": "string",
                        "description": "Descriptive SEC request User-Agent. Include an application name and contact email for production use.",
                        "default": "AlternativeDataSignalAggregator/0.1 contact@automation-lab.com"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
