FinSignals v2.0

Financial social signals,
decoded.

A purpose-built NLP API that classifies Reddit posts, news, and social financial content across 7 dimensions in a single call. 6–30× cheaper than LLMs. 20× faster.

Get API Key (Free) See Demo

✓ No credit card required ✓ 1,000 free credits / month ✓ Key in 60 seconds

classify.py

import finsignals

client = finsignals.Client("fs_your_key_here")

result = client.classify(
    ticker="NVDA",
    body="NVDA to $200 EOY 🚀🚀 DD inside"
)

# Real response envelope — all 7 heads in outputs[0]:
{
  "model_version":   "2.0.0",
  "credits_charged": 1.0,
  "outputs": [{
    "sentiment":         { "label": "positive", "positive": 0.89 },
    "directionality":    { "label": "bullish",   "bullish":   0.84 },
    "quality":           { "label": "relevant",  "relevant":  0.76 },
    "relevance_score":   0.9137,
    "author_confidence": 0.5802,
    "sarcasm":           false
  }]
}

Try it now — no account required

See all 7 heads in one call

POST /v1/classify ● cached

NVDA to $200 EOY 🚀🚀 DD inside. Blackwell demand is insane, hyperscalers not slowing capex, and the short interest is evaporating. Diamond hands 💎🙌 this thing prints.

Response v2.0.0

// Select a sample post above to see the full 7-head output

6–30×

cheaper than mid-tier LLMs

$0.000396/call on Pro vs $0.0024 for Claude Sonnet 4. At 500K posts/month that's $1,400 saved — every month.

20×

faster than any LLM API

5–15ms per classification. Single forward pass. No token generation. Built for real-time trading pipelines.

signals per API call

Sentiment, direction, quality, post type, relevance, author confidence, and sarcasm — all in one response.

Seven classification heads

Everything you need to filter signal from noise

Every API call returns all seven heads simultaneously. No extra prompts, no retries, no JSON parsing failures.

📊

sentiment

Overall tone of the post toward the asset

positive negative neutral

📈

directionality

Stated or implied market intent

bullish bearish neutral

🎯

quality

Signal quality filter — is this post worth reading?

relevant noise spam

📝

post_type

Content category for routing and scoring

dd news_reaction technical_analysis +3

⚡

relevance_score

Continuous 0–1 score: how on-topic is this post for the queried ticker?

💡

author_confidence

Continuous 0–1 score: how confident does the author appear?

😏

sarcasm

Boolean flag trained to detect Reddit irony and sarcastic sentiment inversion

true false

⇉

batch endpoint

Up to 256 posts per call—1.00 credit for the first item, 0.70 per additional item vs 1.00 each as singles

Who it's for

Built for people who build things with financial data.

Quant traders → Filter social noise from real signal before it moves your model.

Fintech developers → Add sentiment to any financial app without training your own model.

Data engineers → Replace ad-hoc LLM calls with a deterministic, structured endpoint.

Market researchers → Classify thousands of posts without manual review.

What developers build with FinSignals

→ Bullish/bearish scanners that surface high-signal posts before price moves
→ Noise filters that strip low-quality posts from any data pipeline
→ Sentiment dashboards showing ticker mood across Reddit in real time
→ Alert systems triggered by unusual spikes in directional sentiment
→ Backtesting datasets with labeled sentiment for quant model training
→ Content quality filters for financial news aggregators

Cost comparison

Why not just use GPT-4o?

At 500,000 posts / month, the difference is ~$1,400. That's $16,800 / year. And you'd still need to write the prompt, handle malformed JSON, and tolerate 200ms+ latency on every call.

Dimension	FinSignals Pro	Claude Sonnet 4	GPT-4o	GPT-4o-mini	Self-hosted LLM
Cost · 500K posts/mo	~$224	~$1,200	~$1,750	~$210	$1,500–$5,700
Total response time · single call	~1,500 ms	2,000–4,000 ms	2,000–4,500 ms	1,500–3,000 ms	2,000–8,000 ms
Real-time batch throughput synchronous · results in one response	~8 ms / item 256 items in <2,000 ms total	not availableasync batch only · minutes–hours	not availableasync batch only · up to 24 hrs	not availableasync batch only · up to 24 hrs	possibledepends on serving setup
Reddit social content	Finance-tuned	General model	General model	General model	General model
Structured output	Guaranteed always	Sometimes fails	Sometimes fails	Sometimes fails	Often fails
7 heads · one call	✓ native	Extra tokens	Extra tokens	Extra tokens	Extra prompting
Prompt engineering	None required	Required	Required	Required	Extensive
Understands "diamond hands", "DD", "🚀🚀"	✓ Trained on it	Partial	Partial	Partial	Unlikely

Pricing

Start free. Scale when you're ready.

Credit-based pricing. Single call = 1.00 credit. Batch = 1.00 for the first item + 0.70 for each additional item in the same request. No hidden fees.

Free

$0/mo

1,000 credits / month

Single + batch endpoints
1 API key
All 7 classification heads
Community support
No credit card ever

Get started free

Starter

$29/mo

100,000 credits / month

Everything in Free
2 active API keys
PAYG overage available
Auto-refill credits
Email support

Start Starter

Up and running in 5 minutes

1

Create a free account

Email only. No credit card. Your 1,000 free credits activate immediately and your key appears on the next screen.
2

Copy your API key

Find it in the dashboard under API Keys. Set it as FINSIGNALS_API_KEY in your environment.
3

Install the SDK or call REST directly

pip install finsignals — or send a plain HTTP POST with your key in the header. No SDK required.
4

Send your first post

All 7 heads come back in under 15ms. Batch up to 256 posts in one call for the 30% credit discount.

import finsignals

client = finsignals.Client(api_key="fs_your_key_here")

# Single classification
result = client.classify(
    ticker="AAPL",
    body="Apple crushes Q3 earnings, up 12% AH"
)
print(result.sentiment.label)       # "positive"
print(result.relevance_score)       # 0.9412
print(result.credits_charged)       # 1.0

# Batch: 1.0 + 0.7*(n-1) credits (e.g. 2 items = 1.7)
results = client.classify_batch([
    {"ticker": "TSLA", "body": "Tesla misses deliveries..."},
    {"ticker": "NVDA", "body": "Blackwell demand insane 🚀"},
])

curl -X POST https://api.finsignals.ai/v1/classify \
  -H "X-API-Key: fs_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "ticker": "AAPL",
    "body":   "Apple crushes Q3 earnings, up 12% AH"
  }'

# Response:
{
  "sentiment":      {"label": "positive", "positive": 0.92},
  "relevance_score": 0.9412,
  "credits_charged": 1.0
}

import FinSignals from 'finsignals';

const client = new FinSignals({ apiKey: 'fs_your_key_here' });

const result = await client.classify({
  ticker: 'AAPL',
  body:   'Apple crushes Q3 earnings, up 12% AH'
});
console.log(result.sentiment.label);  // "positive"
console.log(result.relevanceScore);   // 0.9412

Read the documentation →

Full pipeline

Don't have Reddit posts yet? Here's the full pipeline.

FinSignals classifies text. You need a source of text first. Two clean options:

Option 1 Reddit API (free)

Use PRAW, the official Python wrapper for the Reddit API. Pull posts from any subreddit in a few lines of code. Free, no scraping required, works well for most use cases. Rate-limited at 60 requests/minute — unless you're processing over 100,000 posts a day, you'll never notice.

Option 2 Third-party scraper (high-volume)

If you need tens of thousands of posts per day across many subreddits, a dedicated data provider like Bright Data handles the collection layer. Pair it with FinSignals batch classification and your per-post cost stays well below any LLM alternative.

You handle the data collection. FinSignals does the classification.

Full pipeline in under 20 lines

pipeline.py

import praw
import finsignals

reddit = praw.Reddit(client_id="...", client_secret="...", user_agent="...")
client = finsignals.Client("fs_your_key_here")

# Fetch top posts from r/wallstreetbets
posts = list(reddit.subreddit("wallstreetbets").hot(limit=100))
items = [{"ticker": "GME", "title": p.title, "body": p.selftext} for p in posts]

# Classify the whole batch in one call
results = client.classify_batch(items)

# Filter for high-confidence bullish signals
signals = [
    (post, out) for post, out in zip(posts, results)
    if out.directionality.label == "bullish"
    and out.quality.label == "relevant"
    and out.relevance_score > 0.7
    and not out.sarcasm
]
print(f"{len(signals)} signals from {len(posts)} posts")

💡 Most users combine automated data collection with FinSignals to build a fully hands-off classification pipeline. The data source is interchangeable. The classification layer is not.

Full pipeline tutorial →

Financial social signals,decoded.