# AlphaAssay — Trading Signal Validator (`alphaassay/signal-validator`) Actor

Independent statistical validation for a trading signal or backtest — deflated Sharpe, out-of-sample, look-ahead and leakage forensics. Deterministic pass/fail verdict with failure gradients. Methodology audit, not investment advice.

- **URL**: https://apify.com/alphaassay/signal-validator.md
- **Developed by:** [Alpha Assay](https://apify.com/alphaassay) (community)
- **Categories:** AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$50.00 / 1,000 signal validations

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

## AlphaAssay — Trading Signal Validator

**A thousand signals promise an edge. Most are noise. Is yours?**

AlphaAssay is an independent assay office for trading signals. Send a strategy, a backtest or a
returns series, and it goes on a statistical trial — out of sample, against chance, against
overfitting — and comes back with a deterministic **pass or fail verdict, with the reasons
attached**. Every verdict is replayable, bit for bit. Proof, not promises.

This Actor runs that trial from inside Apify: pick one of the built-in test cases or submit your
own signal, and get the full verdict as structured output your agent can branch on.

### Why this exists

The uncomfortable truth of quant research: most profitable-looking strategies are statistical
illusions. When 97 peer-reviewed return anomalies were re-tested, more than half of the
performance evaporated after publication. When 2.1 million strategies were generated
systematically and corrected for multiple testing, almost none survived. Retail backtests get far
less scrutiny than either — and then real money follows them.

A no without a finding is an annoyance. A no with a finding is a shortcut: it saves the most
expensive thing you own — weeks of searching in a dead direction, and the drawdown that ends the
search for you.

### What the trial does

Every signal runs the same four-gate battery, in order:

1. **Net edge** — does anything remain after realistic costs, spread and one bar of execution
   delay? Most edges end here.
2. **Family deflation** — every variant you tried is counted against you. Trying forty
   parameter combinations and keeping the best one manufactures a great backtest from pure
   noise; the deflated Sharpe ratio prices exactly that.
3. **Placebo trial** — your signal races 500 random twins with the same trading profile. If
   random timing does as well, your timing was never the edge.
4. **Robustness** — the survivor is attacked: delayed fills, stressed costs, deleted history,
   regime splits, wiggled parameters. A real edge is inconvenient to kill.

The verdict names the first gate that killed the signal — so you know what to fix, or when to
stop.

### Input

| Field | What it does |
|---|---|
| `specimen` | One of four built-in known-answer test cases (default: `golden_lookahead`, a signal with planted look-ahead bias the battery must catch) |
| `customPayload` | Your own signal instead: a returns series, equity curve or trade list as JSON |

The built-in specimens are the fastest way to audit the validator itself: each has a known
correct verdict. A validator you cannot test is just another promise — so test this one first.

### Output

The complete verdict document, pushed to the dataset:

```json
{
  "schema": "gauntlet.v1",
  "verdict": "fail",
  "died_at": "net_edge",
  "failure_codes": ["no_net_edge"],
  "spec_hash": "sha256:421f1b1f4675…",
  "family_id": "fam_004b8867ffc7a556",
  "stages": [ … ]
}
````

- **`verdict`** — `pass`, `conditional`, `fail`, or an honest `insufficient_evidence` when the
  data cannot support a judgment either way.
- **`died_at`** — the first failed gate: `net_edge`, `family_deflation`, `placebo` or `capacity`.
- **`failure_codes`** — machine-readable causes. An agent that branches on these converges; one
  that retries blindly burns its budget on a dead idea.
- **`stages`** — the full evidence trail, gate by gate.

### Pricing

The four golden specimens are free — they are known-answer tests that prove the validator is
correct before you trust it with your own data. Validating your own signal (the Custom input) is
charged per event at the price shown on this page; pass and fail cost the same, because you are
buying the trial, not a flattering outcome. Platform pricing for direct API access:
[alphaassay.com/pricing](https://alphaassay.com/pricing).

### Don't trust us — check us

- Verdicts on the paid tier are Ed25519-signed; anyone can verify a certificate at
  [alphaassay.com/verify](https://alphaassay.com/verify) or completely offline.
- Our own track record is public and updated daily — we grade ourselves before we grade you:
  `GET https://api.alphaassay.com/v1/public/calibration`.
- Strategies are never stored. Only a one-way fingerprint and the cause of death.

### Links

- Website: [alphaassay.com](https://alphaassay.com)
- Documentation: [alphaassay.com/docs](https://alphaassay.com/docs)
- MCP server and known-answer examples: [github.com/alphaassay](https://github.com/alphaassay)

***

AlphaAssay performs methodology audits. It is not investment advice, has no order path and takes
no custody. A pass means a signal survived a statistical trial that most signals fail — it is
never a promise of returns.

# Actor input Schema

## `specimen` (type: `string`):

Validate a built-in golden specimen (a known-answer test signal) or choose Custom to submit your own returns series, equity curve or trade list. Golden specimens prove the validator is correct — it catches a real flaw, does not cry wolf, and abstains honestly — before you trust it with your own data. The demo tier runs the real engine, free and deterministic.

## `customPayload` (type: `object`):

Only used when What to validate is Custom. Custom validations run the full engine and are charged per event (see the pricing on this page); golden specimens stay free. Submit either a gauntlet request { "spec": {…}, "ohlcv\_by\_symbol": {…} } to test a strategy on price history, or a validator request { "trades": \[ … ] } to check a trade list. The request shape and worked examples are in the docs: https://alphaassay.com/docs/quickstart

## Actor input object example

```json
{
  "specimen": "golden_lookahead"
}
```

# 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("alphaassay/signal-validator").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("alphaassay/signal-validator").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 alphaassay/signal-validator --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AlphaAssay — Trading Signal Validator",
        "description": "Independent statistical validation for a trading signal or backtest — deflated Sharpe, out-of-sample, look-ahead and leakage forensics. Deterministic pass/fail verdict with failure gradients. Methodology audit, not investment advice.",
        "version": "0.3",
        "x-build-id": "QIgdd04eLHbyrY3Yi"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/alphaassay~signal-validator/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-alphaassay-signal-validator",
                "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/alphaassay~signal-validator/runs": {
            "post": {
                "operationId": "runs-sync-alphaassay-signal-validator",
                "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/alphaassay~signal-validator/run-sync": {
            "post": {
                "operationId": "run-sync-alphaassay-signal-validator",
                "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",
                "properties": {
                    "specimen": {
                        "title": "What to validate",
                        "enum": [
                            "golden_lookahead",
                            "golden_clean",
                            "golden_cherry",
                            "golden_thin",
                            "custom"
                        ],
                        "type": "string",
                        "description": "Validate a built-in golden specimen (a known-answer test signal) or choose Custom to submit your own returns series, equity curve or trade list. Golden specimens prove the validator is correct — it catches a real flaw, does not cry wolf, and abstains honestly — before you trust it with your own data. The demo tier runs the real engine, free and deterministic.",
                        "default": "golden_lookahead"
                    },
                    "customPayload": {
                        "title": "Custom payload (JSON)",
                        "type": "object",
                        "description": "Only used when What to validate is Custom. Custom validations run the full engine and are charged per event (see the pricing on this page); golden specimens stay free. Submit either a gauntlet request { \"spec\": {…}, \"ohlcv_by_symbol\": {…} } to test a strategy on price history, or a validator request { \"trades\": [ … ] } to check a trade list. The request shape and worked examples are in the docs: https://alphaassay.com/docs/quickstart"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```