# Coil Market Board — scored US stocks for AI agents (`coil.trade/coil-market-board`) Actor

A scored US stock market board for AI agents: regime verdict per book (risk-on or stand down), ranked candidates, and opportunity/entry/hold scores for ~560 S\&P 500, Nasdaq-100 and macro names, plus a BTC/ETH trend gate. Free tier needs no key. Scores only, not advice.

- **URL**: https://apify.com/coil.trade/coil-market-board.md
- **Developed by:** [Joey Fife](https://apify.com/coil.trade) (community)
- **Categories:** Agents, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Coil Market Board — scored US stocks for AI agents

Returns a **scored, ranked US stock market board** as dataset rows: a regime verdict per book,
then every scored name with opportunity, entry-quality and hold-strength scores — so an agent has
a disciplined read instead of screening 500 tickers and buying whatever it saw most recently.

Free tier needs **no key, no wallet and no account**.

### What you get

Each run writes three kinds of row:

| `row_type` | What it is |
|---|---|
| `regime` | One per book — the verdict and the permission ladder. **Read these first.** |
| `name` | One per scored security: `opp`, `entry_q`, `hold_q`, `state`, sector, leadership flag. |
| `record` | Optional. The publisher's own return vs SPY and QQQ, with its sample-size note. |

**Read top-down.** If a book's `ladder_rung` is `CASH`, the ranked names under it are context, not
a green light. An agent that skips the regime row and buys the top-ranked name every day is not
running this strategy.

### Input

| Field | Default | Meaning |
|---|---|---|
| `book` | `all` | `all`, `spx` (S\&P 500), `qqq` (Nasdaq-100), `macro`, `crypto` |
| `includeRegime` | `true` | Emit the regime row per book |
| `includeRecord` | `false` | Emit the publisher's benchmark-relative record |
| `licenseKey` | — | Optional [Coil Scanner](https://coil.trade/scanner) key for the live intraday board |

The live board recomputes **about every 5 minutes while the US market is open**; the free tier is the same board **one market day delayed**. `/api/board/asof` is the exception everywhere: an immutable archive, never revised. Without a licence key you get the full board **one market day delayed** — genuinely usable for a
swing-timeframe agent, which is what this is for.

### Reading the scores

- **`opp`** — opportunity, 0–100. A percentile **rank** across the scored universe on the publish
  date. Not a return forecast.
- **`entry_q`** — entry quality, 0–100: buyable now versus extended. Timing only.
- **`hold_q`** — hold strength, 0–100: trend durability if a position already exists.
- **`state`** — `firing` / `ready` / `setup` / `wait` / `chase` / `falling`. Never an instruction.

### Check the publisher before trusting it

Both free and unauthenticated:

- **[coil.trade/api/perf](https://coil.trade/api/perf)** — the engine's own return versus SPY and
  QQQ, funding-adjusted, published with its sample size. Omitted rather than estimated when the
  underlying data is unavailable.
- **[coil.trade/api/board/proof](https://coil.trade/api/board/proof)** — an append-only SHA-256
  commitment over every archived day, written at publish time **before the outcome was known**,
  with a verification recipe that reproduces byte-identically in Python and JavaScript.

### Other ways to read the same board

- Free MCP server: `claude mcp add --transport http coil https://coil.trade/mcp`
- Pay per read over [x402](https://x402.org) — $0.001–$0.25, no account
- Open source harness: [github.com/joeyfife/coil-agent](https://github.com/joeyfife/coil-agent)

### Disclaimer

Impersonal research publication — identical for every reader. **Scores and states only: never stop
prices, never target prices, never individualized investment advice.** Not a managed account, not a
signal service, not a guarantee of any outcome. Markets can lose money and an automated agent can
lose it faster. See [coil.trade/terms](https://coil.trade/terms).

# Actor input Schema

## `book` (type: `string`):

Which book to read. spx = S\&P 500, qqq = Nasdaq-100, macro = bonds/income/metals/commodities, crypto = BTC + ETH trend, all = every book.

## `includeRegime` (type: `boolean`):

Add one row per book carrying the regime verdict and permission ladder. Read this FIRST — if the ladder says CASH, the ranked names are context, not a green light.

## `includeRecord` (type: `boolean`):

Add a row with the engine's own return vs SPY and QQQ (free, funding-adjusted, published with its sample size).

## `licenseKey` (type: `string`):

Leave empty for the free board (full board, one market day delayed). A Coil Scanner key ($12/mo, coil.trade/scanner) returns the live intraday board.

## Actor input object example

```json
{
  "book": "all",
  "includeRegime": true,
  "includeRecord": false
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("coil.trade/coil-market-board").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("coil.trade/coil-market-board").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call coil.trade/coil-market-board --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=coil.trade/coil-market-board",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/F0D3YcX1Ytdfsa9Lr/builds/ua58xLCPKcPgg0FqG/openapi.json