SYNORB CREDENTIALS

Active

Tap to expand

Learn

Tutorials and video guides

All videos from our YouTube channel • Subscribe →

AI Assistants

Connect Synorb to your favorite AI assistants via MCP

Getting Started

Documentation Coming Soon

Learn how to connect Synorb to Claude, Cline, and other AI assistants

Supported Assistants

Documentation Coming Soon

Configuration guides for different AI platforms

MCP Documentation

Model Context Protocol server integration with personalized credentials

API Documentation

REST API integration with your credentials pre-filled

Settings

Manage your account and subscription

Profile

Account information

Account Information

Current Plan & Usage

Plan Loading...

Story Quota Loading...

Next Reset Loading...

Story Usage 0 / 0

0% used

Available Plans

Upgrade or change your plan

Billing

Manage your paid plan subscription

Stripe Billing Portal

Access your complete billing history and manage your subscription through Stripe's secure portal.

✓ View Invoices

✓ Download PDFs

✓ Update Payment

✓ Cancel Subscription

Learn

AI AI Assistants

MCP

API

Settings

Logout

MCP Server URL

https://mcp.synorb.com/

Your MCP Credentials

MCP Token

{{MCP_TOKEN}}

MCP Tools Reference

Complete tool specifications for Claude Desktop integration with production MCP endpoint

synorb-profile

Retrieve authenticated account metadata and access configuration

Description

Retrieve authenticated account metadata and access configuration. Use this to verify token validity, check quota status, and understand your access level.

Parameters

No parameters required

Returns

Field	Type	Description
user_id	integer	Account identifier
access_token	string	Your MCP authentication token
usage	object	Quota and usage statistics

When to Use

• User asks about account or access level
• Debugging authentication
• Verifying token validity
• Checking quota and usage statistics

synorb-stream-catalog

Retrieve the complete catalog of Synorb data streams available to your API token

Description

Retrieve the complete catalog of Synorb data streams available to your API token. Returns metadata about stream types (Discovery, Narrative, Research), domains, and available filters for surgical query construction. Synorb provides machine-readable intelligence through three stream types:

1. Discovery Streams: Summaries and structured extracts from human web content
2. Narrative Streams: Textual narratives generated from numerical/statistical data
3. Research Streams: Research reports written specifically for machine consumption

Parameters

No parameters required

Returns

Field	Type	Description
stream_id	integer	Unique identifier (required for all other operations)
title	string	Human-readable stream name
description	string	Stream content and purpose
filters	array	Available query dimensions (varies by stream)

When to Use

• Beginning any research task - discover relevant intelligence sources
• User asks about available data or capabilities
• Exploring new topic areas
• Planning multi-stream queries

Best Practice

Start here when uncertain which streams are relevant. Examine 'filters' to understand each stream's query dimensions. Match user intent to stream descriptions and domains.

synorb-stream-details

Fetch deep metadata and configuration for a specific stream

Description

Fetch deep metadata and configuration for a specific stream. Reveals internal structure, available filters with exact enumerated values, content schema (15+ body sections), and usage patterns. Essential for understanding query dimensions before calling synorb-stream-stories.

Parameters

Parameter	Type	Required	Description
stream_id	string	Required	Stream identifier from catalog

Returns

Field	Type	Description
body_sections	array	Content structure and available fields (15+ sections)
filters.allowed	array	Exact enumerated values for each filter dimension
nlq	array	Natural language query examples

When to Use

• After identifying a target stream from catalog
• Need exact filter values before querying
• Planning complex filtered queries
• Understanding content structure for parsing

Filter Discovery Pattern

Always call this tool before synorb-stream-stories to discover available filters and body sections for that stream. Each stream has unique filter dimensions and section structures.

synorb-stream-stories

Retrieve actual stream content with multi-dimensional filtering and pagination

Description

Retrieve actual stream content (stories) with multi-dimensional filtering, date ranges, section extraction, and pagination. This is the primary data retrieval tool - all intelligence flows through this endpoint.

Required Parameters

Parameter	Type	Description
stream_id	number/string	Target stream identifier
Date Range	strings	published_date_from + published_date_to OR created_on_from + created_on_to (YYYY-MM-DD)

Optional Parameters

Parameter	Type	Description
entity_details	array	[{entity_type, entity_value}] - Use synorb-stream-details to discover valid values
body_sections	array	Request specific content sections only (surgical extraction)
page_size	integer	Results per page (max 200)
page_num	integer	Page index for pagination (0-based)

Returns

Field	Type	Description
stories	array	Array of content objects with story_id, published_date, entity_details, and body
pagination	object	Navigation metadata (total_count, next, prev)

Critical Requirements

⚠️ MUST provide date ranges - no default behavior

Date ranges required even if searching by other filters

Best Practices

• Start with recent dates (last 30 days) unless specified
• Use page_size=50-100 initially
• Get filter values from synorb-stream-details first
• ALWAYS cite source_urls in outputs
• Parse story.body - format varies (JSON, markdown, structured text)

Query Workflow

1. synorb-stream-catalog → Find relevant streams
2. synorb-stream-details → Understand available filters
3. synorb-stream-stories → Execute filtered query
4. Iterate based on results

Real-World Implementation

Production-ready examples with your MCP token pre-filled and ready to use

Investment Due Diligence Pipeline

Multi-source company intelligence combining regulatory filings, earnings calls, and VC perspective

SEC 8-K Earnings Calls a16z

// Multi-source company research async function researchCompany(companyName) { const [secRisks, earnings, vcView] = await Promise.all([ // 1. SEC regulatory risks synorb.get_stories({ stream_id: 786, entity_details: [{ entity_type: "organization", entity_value: companyName }], body_sections: [ "Risks & Watchpoints", "Key Details" ], published_date_from: "2025-01-01", published_date_to: "2025-10-10" }), // 2. Earnings call sentiment synorb.get_stories({ stream_id: 1015, entity_details: [{ entity_type: "organization", entity_value: companyName }], body_sections: [ "Key Insights", "Signals" ], published_date_from: "2025-01-01", published_date_to: "2025-10-10" }), // 3. VC perspective synorb.get_stories({ stream_id: 889, entity_details: [{ entity_type: "organization", entity_value: companyName }], body_sections: [ "Portfolio Mentions", "Big Picture" ], published_date_from: "2025-01-01", published_date_to: "2025-10-10" }) ]); return { regulatory_risks: secRisks.stories, financial_health: earnings.stories, vc_sentiment: vcView.stories }; }

Real Estate Market Intelligence

Price trend analysis with loss pattern detection for market stress signals

Price Drops Loss Sales

// Track market softness in Boston const bostonAnalysis = async () => { const [priceDrops, lossSales] = await Promise.all([ // Recent price reductions synorb.get_stories({ stream_id: 1011, entity_details: [{ entity_type: "place", entity_value: "Boston" }], body_sections: [ "Overview", "Key Details" ], published_date_from: "2025-09-01", published_date_to: "2025-10-10" }), // Properties sold at loss synorb.get_stories({ stream_id: 1012, entity_details: [{ entity_type: "place", entity_value: "Boston" }], body_sections: [ "Key Insights", "Signals" ], published_date_from: "2025-01-01", published_date_to: "2025-10-10" }) ]); const avgDrop = calculateAverage( priceDrops.stories.map(s => extractDropPercentage(s) ) ); return { market_stress_score: avgDrop * lossSales.stories.length, price_drops: priceDrops.stories, loss_sales: lossSales.stories }; };

Geopolitical Risk Monitor

Policy analysis correlated with investor response for sector impact assessment

Atlantic Council Sequoia

// Track policy shifts and sector impact const policyImpact = async (region, sector) => { const [policy, vcReaction] = await Promise.all([ // Policy analysis synorb.get_stories({ stream_id: 521, entity_details: [ { entity_type: "place", entity_value: region }, { entity_type: "topic", entity_value: sector } ], body_sections: [ "Big Picture", "Risks & Watchpoints" ], published_date_from: "2025-01-01", published_date_to: "2025-10-10" }), // VC response synorb.get_stories({ stream_id: 989, entity_details: [{ entity_type: "place", entity_value: region }], body_sections: [ "Signals", "Portfolio Mentions" ], published_date_from: "2025-01-01", published_date_to: "2025-10-10" }) ]); return { policy_analysis: policy.stories, investor_response: vcReaction.stories, correlation: analyzeCorrelation( policy, vcReaction ) }; };

Crowdfunding Deal Flow

Early-stage funding landscape via SEC Reg CF and Reg A filings

SEC Reg CF SEC Reg A

// Track early-stage tech funding const crowdfundingPipeline = async () => { const [regCF, regA] = await Promise.all([ // Regulation Crowdfunding synorb.get_stories({ stream_id: 566, entity_details: [{ entity_type: "topic", entity_value: "Technology" }], body_sections: [ "Announcement", "Key Details" ], published_date_from: "2025-09-01", published_date_to: "2025-10-10" }), // Regulation A offerings synorb.get_stories({ stream_id: 567, entity_details: [{ entity_type: "topic", entity_value: "Technology" }], body_sections: [ "Key Details", "Signals" ], published_date_from: "2025-09-01", published_date_to: "2025-10-10" }) ]); const deals = [...regCF.stories, ...regA.stories]; return { deals, sectors: analyzeSectorDistribution(deals), avgRaise: calculateAverageRaise(deals) }; };

Cross-Sector Correlation Engine

Four-source convergence analysis across VCs, policy, public markets, and regulatory filings

General Catalyst Atlantic Council Earnings SEC 8-K

// Multi-source sector intelligence const crossSector = async (sector) => { const [vc, policy, earnings, sec] = await Promise.all([ // VC activity synorb.get_stories({ stream_id: 947, entity_details: [{ entity_type: "Topics", entity_value: sector }], body_sections: [ "Portfolio Mentions", "Signals" ], published_date_from: "2025-01-01", published_date_to: "2025-10-10" }), // Policy landscape synorb.get_stories({ stream_id: 521, entity_details: [{ entity_type: "topic", entity_value: sector }], body_sections: [ "Big Picture", "Risks & Watchpoints" ], published_date_from: "2025-01-01", published_date_to: "2025-10-10" }), // Public sentiment synorb.get_stories({ stream_id: 1015, entity_details: [{ entity_type: "topic", entity_value: sector }], body_sections: [ "Key Insights", "Signals" ], published_date_from: "2025-01-01", published_date_to: "2025-10-10" }), // Regulatory activity synorb.get_stories({ stream_id: 786, entity_details: [{ entity_type: "topic", entity_value: sector }], body_sections: [ "Announcement", "Key Details" ], published_date_from: "2025-01-01", published_date_to: "2025-10-10" }) ]); return { vc_positioning: vc.stories, policy_headwinds: policy.stories, public_sentiment: earnings.stories, regulatory_activity: sec.stories, convergence_score: calculateConvergence([ vc, policy, earnings, sec ]) }; };

Podcast Intelligence + SEC Validation

Verify VC podcast claims against regulatory filings for investment validation

20VC Podcast SEC 10-K

// Fact-check VC claims with SEC data const verifyVCClaims = async (company) => { const [podcast, sec10K] = await Promise.all([ // VC podcast mentions synorb.get_stories({ stream_id: 1014, entity_details: [{ entity_type: "organization", entity_value: company }], body_sections: [ "Notable Quotes", "Key Arguments" ], published_date_from: "2025-09-01", published_date_to: "2025-10-10" }), // SEC 10-K verification synorb.get_stories({ stream_id: 564, entity_details: [{ entity_type: "organization", entity_value: company }], body_sections: [ "Key Details", "Risks & Watchpoints" ], published_date_from: "2025-01-01", published_date_to: "2025-10-10" }) ]); const claims = extractClaims(podcast.stories); const facts = extractFacts(sec10K.stories); return { podcast_narrative: claims, sec_reality: facts, alignment_score: compareNarratives( claims, facts ) }; };

Robust Error Handling

Production-ready validation patterns with section detection, retry logic, and graceful degradation

Best Practices Production

// Production-ready error handling async function robustQuery(streamId, filters) { try { // STEP 1: Always validate sections first const details = await synorb.get_stream_details({ stream_id: streamId }); // STEP 2: Only request valid sections const validSections = filters.body_sections.filter( s => details.body_sections.includes(s) ); if (validSections.length === 0) { console.warn('No valid sections. Using defaults.'); validSections = details.body_sections.slice(0, 3); } // STEP 3: Query with validated params const result = await synorb.get_stories({ stream_id: streamId, body_sections: validSections, entity_details: filters.entity_details, published_date_from: filters.date_from, published_date_to: filters.date_to }); // STEP 4: Check relay metadata if (result._relay_metadata) { console.log(`Returned ${result._relay_metadata.stories_returned} stories`); if (result._relay_metadata.validation_warnings) { console.warn('Validation warnings:', result._relay_metadata.validation_warnings); } } return result.stories; } catch (error) { if (error.details?.invalid_sections) { // Section validation error console.error('Invalid sections requested:', error.details.invalid_sections); console.log('Available:', error.details.available_sections); // Retry with valid sections return robustQuery(streamId, { ...filters, body_sections: error.details.available_sections.slice(0, 3) }); } if (error.details?.invalid_filters) { // Filter validation error console.error('Invalid filter combination:', error.details); throw new Error('Check filter types and values'); } // Generic error console.error('Query failed:', error); throw error; } }

Advanced Filtering Patterns

Surgical precision techniques for multi-dimensional filtering, temporal control, and section-level extraction

0

Section Discovery First (ALWAYS)

NEVER request body_sections without checking synorb-stream-details first—avoid validation errors and ensure you're requesting sections that actually exist

❌ Wrong - Guessing Sections

// Requesting unknown sections = ERROR
synorb.get_stories({
stream_id: 889,
body_sections: [
"Summary",      // Doesn't exist!
"Main Points"   // Doesn't exist!
],
published_date_from: "2025-09-01",
published_date_to: "2025-09-30"
})
// Result: Validation error

✅ Correct - Discover Then Request

// STEP 1: Check available sections
const details = await synorb.get_stream_details({
stream_id: 889,
mcp_token: "{{MCP_TOKEN}}"
});
console.log(details.body_sections);

// STEP 2: Request ONLY what exists
synorb.get_stories({
stream_id: 889,
mcp_token: "{{MCP_TOKEN}}",
body_sections: [
"Key Insights",
"Big Picture"
],
published_date_from: "2025-09-01",
published_date_to: "2025-09-30"
})

Critical Rule

ALWAYS call synorb-stream-details BEFORE requesting body_sections. Each stream has different available sections—never assume.

1

Multi-Entity Boolean Filtering

Combine multiple filters with AND logic for precise targeting across Topics, People, Content Type, and Organizations

❌ Basic

// Single dimension - too broad
synorb.get_stories({
stream_id: 889,
mcp_token: "{{MCP_TOKEN}}",
entity_details: [{
entity_type: "Topics",
entity_value: "AI"
}],
published_date_from: "2025-09-01",
published_date_to: "2025-09-30"
})
// Returns ALL AI content - unfocused

✅ Advanced

// Multi-dimensional precision
synorb.get_stories({
stream_id: 889,
mcp_token: "{{MCP_TOKEN}}",
entity_details: [
{
entity_type: "Topics",
entity_value: "AI"
},
{
entity_type: "people",
entity_value: "Ben Horowitz"
},
{
entity_type: "content_type",
entity_value: "Podcast"
}
],
published_date_from: "2025-09-01",
published_date_to: "2025-09-30"
})
// Only Ben's AI podcasts - precise

Key Insight

Boolean AND across filters reduces noise by 95%. Use 2-3 filters for surgical precision.

2

Surgical Section Extraction

Extract only specific reasoning sections from stories—eliminate fluff, get exactly what you need

❌ Basic

// Full story - 15+ sections
synorb.get_stories({
stream_id: 889,
mcp_token: "{{MCP_TOKEN}}",
published_date_from: "2025-09-01",
published_date_to: "2025-09-30"
})
// ~3000 tokens per story

✅ Advanced

// Only reasoning sections
synorb.get_stories({
stream_id: 889,
mcp_token: "{{MCP_TOKEN}}",
body_sections: [
"Key Insights",
"Big Picture",
"Signals"
],
published_date_from: "2025-09-01",
published_date_to: "2025-09-30"
})
// ~800 tokens - 73% reduction

RAG Optimization

Section filtering reduces LLM context by 60-80% while preserving signal. Perfect for RAG pipelines with token constraints.

3

Temporal Precision Control

Query by exact date ranges or use activity metrics to detect and query hot streams dynamically

// Activity-based intelligence
const details = await synorb.get_stream_details({
stream_id: 889,
mcp_token: "{{MCP_TOKEN}}"
});

if (details.stories_over_last_7_days > 10) {
// Hot stream - query recent only
const trending = await synorb.get_stories({
stream_id: 889,
mcp_token: "{{MCP_TOKEN}}",
published_date_from: getLastWeek(),
published_date_to: getToday()
});
} else {
// Quiet stream - expand window
const recent = await synorb.get_stories({
stream_id: 889,
mcp_token: "{{MCP_TOKEN}}",
published_date_from: getLastMonth(),
published_date_to: getToday()
});
}

Dynamic Querying

Use 7/30/90-day metrics to adapt query windows. Both published_date_from AND published_date_to are required.

4

Cross-Domain Intelligence Discovery

Find content that spans multiple domains for unique cross-sector insights

// Find AI content across domains
const catalog = await synorb.get_catalog({
mcp_token: "{{MCP_TOKEN}}"
});

const crossDomainAI = catalog.streams.filter(stream =>
stream.cross_domains?.includes("engineering-technology") &&
stream.home_domain === "economics-business-work"
);

const insights = await Promise.all(
crossDomainAI.map(async stream => {
const stories = await synorb.get_stories({
stream_id: stream.id,
mcp_token: "{{MCP_TOKEN}}",
entity_details: [{
entity_type: "Topics",
entity_value: "AI"
}],
published_date_from: getLastMonth(),
published_date_to: getToday()
});
return { source: stream.title, insights: stories };
})
);

Cross-Domain Pattern

Cross-referenced streams reveal unique angles unavailable from single-domain sources.

5

Provenance-Aware Filtering

Build trust by tracking source URLs and classification confidence

const result = await synorb.get_stories({
stream_id: 889,
mcp_token: "{{MCP_TOKEN}}",
body_sections: ["Key Insights"],
published_date_from: "2025-09-01",
published_date_to: "2025-09-30"
});

// Filter by confidence
const highConfidence = result.stories.filter(story =>
story.classification_confidence > 0.9 &&
story.evidence_ref?.source_urls?.length > 0
);

// Build citation-ready output
const citableInsights = highConfidence.map(story => ({
insight: story.story.body,
source: story.evidence_ref.source_urls[0],
confidence: story.classification_confidence,
pipeline: story.provenance?.pipeline_version
}));

Trust & Attribution

Filter by classification_confidence > 0.9 for high-quality results. Always include source URLs for transparency.

Production Architecture

Performance optimization and integration strategies for production deployments

Common Integration Mistakes

Avoid these pitfalls

❌ Mistake 1: String Parameters

Wrong: get_stories("889", "2025-01-01")
Correct: All MCP tools require object parameters.

// ✅ Correct format
synorb.get_stories({
stream_id: 889,
mcp_token: "{{MCP_TOKEN}}",
published_date_from: "2025-01-01",
published_date_to: "2025-01-31"
})

❌ Mistake 2: Missing Date Range

Both published_date_from AND published_date_to are required. No defaults.

❌ Mistake 3: Guessing Body Sections

Never request body_sections without checking synorb-stream-details first.

❌ Mistake 4: Invalid Filter Structure

Wrong: entity_details: "AI"
Correct: Must be array of objects with entity_type and entity_value.

Pro Tip: Always check synorb-stream-details first to see available sections and valid filter values.

Performance Optimization

Maximize throughput

Parallel Queries

Query multiple streams concurrently using Promise.all for 3-5x speedup.

Section Filtering

Request only needed body_sections to reduce payload size by 60-80%.

Activity-Based Selection

Use 7/30/90-day activity metrics to prioritize high-velocity streams.

// Parallel stream queries
const streamIds = [889, 947, 989];
const results = await Promise.all(
streamIds.map(async id => {
return synorb.get_stories({
stream_id: id,
mcp_token: "{{MCP_TOKEN}}",
body_sections: ["Key Insights"],
published_date_from: "2025-09-01",
published_date_to: "2025-09-30"
});
})
);

Integration Patterns

Common architectures

Discovery → Validation → Query

Use catalog to find streams, stream-details to validate, then stories to retrieve. Never skip validation.

Activity-Based Selection

Check 7/30/90-day metrics to identify trending streams worth deeper investigation.

Multi-Source Validation

Cross-reference stories from different streams (e.g., VC + SEC) for fact-checking pipelines.

// Complete integration pattern
async function intelligentQuery(streamId, topic) {
// Step 1: Get stream details
const details = await synorb.get_stream_details({
stream_id: streamId,
mcp_token: "{{MCP_TOKEN}}"
});

// Step 2: Query with validated sections
const result = await synorb.get_stories({
stream_id: streamId,
mcp_token: "{{MCP_TOKEN}}",
body_sections: details.body_sections.slice(0, 3),
entity_details: [{
entity_type: "Topics",
entity_value: topic
}],
published_date_from: getLastWeek(),
published_date_to: getToday()
});

return result.stories;
}

Intelligence Workflows

Production-ready patterns for market research, competitive intelligence, investment validation, RAG pipelines, and error handling

Market Research Pipeline

Discover streams → Analyze activity → Extract insights → Generate synthesis report

1 Catalog Discovery →

// Find relevant streams for your sector const catalog = await synorb.get_catalog({ mcp_token: "{{MCP_TOKEN}}" }); const aiStreams = catalog.streams.filter(s => s.subject_domains.includes("engineering-technology") && s.stream_class === "discovery" );

Filter catalog by domain and stream class to find relevant intelligence sources

2 Activity Analysis →

// Check which streams are hot const streamActivity = await Promise.all( aiStreams.map(async stream => { const details = await synorb.get_stream_details({ stream_id: stream.id, mcp_token: "{{MCP_TOKEN}}" }); return { ...stream, activity_7d: details.stories_over_last_7_days, activity_30d: details.stories_over_last_30_days }; }) ); // Prioritize high-activity streams const hotStreams = streamActivity .filter(s => s.activity_7d > 5) .sort((a,b) => b.activity_7d - a.activity_7d);

Use activity metrics to identify trending sources worth deeper investigation

3 Insight Extraction →

// Extract insights from hot streams const insights = await Promise.all( hotStreams.slice(0, 5).map(async stream => { const stories = await synorb.get_stories({ stream_id: stream.id, mcp_token: "{{MCP_TOKEN}}", entity_details: [{ entity_type: "Topics", entity_value: "AI" }], body_sections: [ "Key Insights", "Big Picture", "Signals" ], published_date_from: "2025-10-08", published_date_to: "2025-10-15" }); return { source: stream.title, insights: stories.stories }; }) );

Query top streams with surgical section filtering for high-signal content

4 Synthesis Report

// Generate market intelligence report const report = { sector: "AI", timeframe: "Last 7 days", sources_analyzed: hotStreams.length, total_stories: insights.reduce( (sum, i) => sum + i.insights.length, 0 ), key_insights: insights.map(i => ({ source: i.source, summary: extractKeyPoints(i.insights), evidence: i.insights.map(s => s.evidence_ref.source_urls[0] ) })), signals: identifyTrends(insights) };

Output

Structured market intelligence report with sourced insights, trend signals, and full provenance for investment decisions

Competitive Intelligence Monitor

Multi-source tracking → Cross-reference validation → Alert generation

1 Multi-Source Monitoring →

// Track competitor across multiple sources const competitor = "CompanyX"; const [vcMentions, secFilings, earnings, media] = await Promise.all([ // VC perspective synorb.get_stories({ stream_id: 889, mcp_token: "{{MCP_TOKEN}}", entity_details: [{ entity_type: "organization", entity_value: competitor }], published_date_from: "2025-09-15", published_date_to: "2025-10-15" }), // SEC activity synorb.get_stories({ stream_id: 786, mcp_token: "{{MCP_TOKEN}}", entity_details: [{ entity_type: "organization", entity_value: competitor }], published_date_from: "2025-09-15", published_date_to: "2025-10-15" }), // Earnings calls synorb.get_stories({ stream_id: 1015, mcp_token: "{{MCP_TOKEN}}", entity_details: [{ entity_type: "organization", entity_value: competitor }], published_date_from: "2025-09-15", published_date_to: "2025-10-15" }), // Industry podcasts synorb.get_stories({ stream_id: 1014, mcp_token: "{{MCP_TOKEN}}", entity_details: [{ entity_type: "organization", entity_value: competitor }], published_date_from: "2025-09-15", published_date_to: "2025-10-15" }) ]);

2 Cross-Reference Validation →

// Identify mentions across sources const signals = detectSignals({ funding: extractFundingNews(vcMentions, secFilings), product: extractProductNews(media, earnings), leadership: extractPeopleChanges(secFilings, media), financial: extractFinancials(earnings, secFilings) }); // Flag corroborated signals const validated = signals.filter(s => s.source_count >= 2 && s.confidence > 0.8 );

Cross-validate signals across sources to reduce false positives

3 Alert Generation

// Generate alerts for validated signals const alerts = validated.map(signal => ({ priority: signal.confidence > 0.9 ? "HIGH" : "MEDIUM", type: signal.category, summary: signal.text, sources: signal.sources, timestamp: new Date(), action_items: generateActionItems(signal) })); // Deliver via preferred channel if (alerts.some(a => a.priority === "HIGH")) { await sendSlackAlert(alerts); }

Output

Real-time competitive alerts with confidence scoring, multi-source validation, and actionable recommendations

Investment Thesis Validation

VC narrative → Regulatory reality check → Public sentiment → Convergence score

1 VC Narrative Analysis →

// Extract VC investment thesis const vcThesis = await synorb.get_stories({ stream_id: 889, mcp_token: "{{MCP_TOKEN}}", entity_details: [{ entity_type: "Topics", entity_value: "Enterprise AI" }], body_sections: [ "Key Arguments", "Big Picture", "Portfolio Mentions" ], published_date_from: "2025-09-15", published_date_to: "2025-10-15" }); const claims = extractInvestmentClaims(vcThesis.stories);

2 Regulatory Reality Check →

// Check SEC filings for validation const secData = await synorb.get_stories({ stream_id: 564, // 10-K filings mcp_token: "{{MCP_TOKEN}}", entity_details: [{ entity_type: "topic", entity_value: "Enterprise AI" }], body_sections: [ "Key Details", "Risks & Watchpoints" ], published_date_from: "2025-07-01", published_date_to: "2025-10-15" }); const facts = extractFinancialReality(secData.stories);

3 Public Market Sentiment →

// Get earnings call sentiment const publicSentiment = await synorb.get_stories({ stream_id: 1015, mcp_token: "{{MCP_TOKEN}}", entity_details: [{ entity_type: "topic", entity_value: "Enterprise AI" }], body_sections: ["Key Insights", "Signals"], published_date_from: "2025-09-15", published_date_to: "2025-10-15" }); const market = extractMarketView(publicSentiment.stories);

4 Convergence Analysis

// Calculate thesis validation score const validation = { vc_claims: claims, regulatory_facts: facts, market_sentiment: market, alignment_score: calculateAlignment( claims, facts, market ), divergence_points: identifyDivergence( claims, facts ), recommendation: generateRecommendation({ alignment: validation.alignment_score, divergence: validation.divergence_points }) };

Output

Investment validation report with convergence scoring, divergence analysis, and data-driven recommendation

RAG Context Extraction Pipeline

Query with sections → Filter by confidence → Build citations → Feed to LLM

1 Surgical Query →

// Request only reasoning sections const context = await synorb.get_stories({ stream_id: 889, mcp_token: "{{MCP_TOKEN}}", entity_details: [{ entity_type: "Topics", entity_value: "AI Safety" }], body_sections: [ "Key Insights", "Key Arguments", "Big Picture" ], published_date_from: "2025-09-15", published_date_to: "2025-10-15" });

Section filtering reduces tokens by 70% while preserving signal quality

2 Quality Filtering →

// Filter by confidence and validate sources const highQuality = context.stories.filter(story => story.classification_confidence > 0.9 && story.evidence_ref?.source_urls?.length > 0 );

Confidence threshold ensures only high-quality context enters your RAG pipeline

3 Citation Building →

// Build citation-ready chunks const chunks = highQuality.map(story => ({ content: story.story.body, metadata: { source_url: story.evidence_ref.source_urls[0], confidence: story.classification_confidence, published_date: story.published_date, domains: { primary: story.home_domain, cross: story.cross_domains }, provenance: story.provenance } }));

4 LLM Prompt Construction

// Build fully-attributed prompt const prompt = ` Context from ${chunks.length} authoritative sources: ${chunks.map((c, i) => ` [Source ${i+1}] ${c.metadata.source_url} Confidence: ${(c.metadata.confidence * 100).toFixed(0)}% Published: ${c.metadata.published_date} ${c.content} `).join('\n---\n')} Question: What is the current thinking on AI safety at leading VC firms? Instructions: Synthesize the above context and cite sources by number. `; const response = await llm.generate(prompt);

Output

Citation-ready LLM prompts with provenance tracking, confidence scoring, and full source attribution for trustworthy AI responses

Error Handling & Validation Pipeline

Section validation → Query with error handling → Retry logic → Graceful degradation

1 Validate Sections First →

// ALWAYS validate before querying async function validateSections(streamId, requestedSections) { try { // Get available sections from stream details const details = await synorb.get_stream_details({ stream_id: streamId, mcp_token: "{{MCP_TOKEN}}" }); // Filter requested sections to only valid ones const validSections = requestedSections.filter( s => details.body_sections.includes(s) ); if (validSections.length === 0) { console.warn('No valid sections. Using defaults.'); // Fallback to first 3 available sections return details.body_sections.slice(0, 3); } return validSections; } catch (error) { console.error('Section validation failed:', error); throw error; } }

Never skip validation—prevents 90% of integration errors by checking sections before requesting

2 Query with Error Handling →

// Query with comprehensive error handling async function robustQuery(streamId, filters) { try { // Step 1: Validate sections if provided let validSections = filters.body_sections; if (validSections && validSections.length > 0) { validSections = await validateSections( streamId, filters.body_sections ); } // Step 2: Execute query with validated parameters const result = await synorb.get_stories({ stream_id: streamId, mcp_token: "{{MCP_TOKEN}}", body_sections: validSections, entity_details: filters.entity_details, published_date_from: filters.date_from, published_date_to: filters.date_to }); // Step 3: Validate response if (!result.stories || result.stories.length === 0) { console.warn('No stories returned. Try expanding date range.'); } // Step 4: Check relay metadata if (result._relay_metadata) { console.log(`Stories returned: ${result._relay_metadata.stories_returned}`); } return result; } catch (error) { return handleQueryError(error, streamId, filters); } }

Always validate parameters, execute query, check response, and handle errors gracefully

3 Error Classification & Retry →

// Handle different error types intelligently function handleQueryError(error, streamId, filters) { // Section validation error (relay v2.4.0) if (error.details?.invalid_sections) { console.error('Invalid sections requested:', error.details.invalid_sections); console.log('Available sections:', error.details.available_sections); // Retry with valid sections return robustQuery(streamId, { ...filters, body_sections: error.details.available_sections.slice(0, 3) }); } // Filter validation error if (error.details?.invalid_filters) { console.error('Invalid filter combination:', error.details); throw new Error('Check entity_details structure'); } // Date range error if (error.message?.includes('date')) { throw new Error( 'Both published_date_from and published_date_to required' ); } // Generic error with context console.error('Query failed:', error); throw error; }

Classify errors by type, provide actionable messages, and retry with corrected parameters when possible

4 Production Usage Example

// Complete production-ready implementation async function getInsights(topic) { try { const result = await robustQuery(889, { body_sections: [ "Key Insights", "Signals", "Big Picture" ], entity_details: [{ entity_type: "Topics", entity_value: topic }], date_from: "2025-09-01", date_to: "2025-10-10" }); return result.stories; } catch (error) { // Log error and return graceful fallback console.error('Failed to get insights:', error.message); return []; } } // Usage const insights = await getInsights("AI");

Output

Production-ready query function with section validation, comprehensive error handling, automatic retry logic, and graceful degradation for maximum reliability

Base URL

https://api.synorb.com

Your API Credentials

API Key

{{API_KEY}}

API Secret

{{API_SECRET}}

Endpoint Reference

Complete API specifications with your credentials pre-filled in all examples

GET

/profile

Authentication verification and quota tracking

Request Example

curl -X GET https://api.synorb.com/profile \
  -H "api-key: {{API_KEY}}" \
  -H "secret: {{API_SECRET}}"

Authentication Headers

Header	Type	Description
api-key	string	Your API key: {{API_KEY}}
secret	string	Your API secret for authentication

Response Schema

{
  "user_id": 429,
  "usage": {
    "quota": 1000,           // Monthly allocation
    "usage": 3252,           // Stories consumed
    "overage": 2252,         // Beyond quota
    "quota_reset_date": "2025-10-15"
  }
}

GET

/catalog

Discover all available streams with metadata

Request Example

curl -X GET https://api.synorb.com/catalog \
  -H "api-key: {{API_KEY}}" \
  -H "secret: {{API_SECRET}}"

Response Schema

{
  "streams": [
    {
      "id": 889,
      "title": "Andreessen Horowitz Insights",
      "description": "VC insights, portfolio updates...",
      "purpose": "Track venture perspectives...",
      "home_domain": "economics-business-work",
      "cross_domains": ["engineering-technology"],
      "primary_entity": {
        "name": "Andreessen Horowitz",
        "type": "org",
        "role": "publisher"
      }
    }
  ]
}

Key Fields

Field	Type	Description
id	integer	Stream identifier for detail queries
home_domain	string	Primary domain classification
cross_domains	array	Secondary domains this stream appears in

GET

/stream?streamid={id}

Filter discovery and stream structure inspection

Request Example

curl -X GET https://api.synorb.com/stream?streamid=889 \
  -H "api-key: {{API_KEY}}" \
  -H "secret: {{API_SECRET}}"

Parameters

Parameter	Type	Required	Description
streamid	integer	Required	Stream ID from catalog

Response: Filter Discovery

{
  "stream_id": 889,
  "title": "Andreessen Horowitz Insights",
  // 15+ structured body sections (stream-specific)
  "body_sections": [
    "Overview", "Key Insights", "Notable Quotes",
    "Actionable Takeaways", "Announcement",
    "Key Details", "Big Picture", "Key Arguments",
    "Signals", "Entities Mentioned", "Links",
    "Portfolio Mentions", "Risks & Watchpoints",
    "Resources Mentioned", "Timestamps"
  ],
  // Multi-dimensional filters (stream-specific)
  "filters": [
    {
      "key": "Topics",
      "allowed": ["AI", "Crypto", "Biotech", "Enterprise"]
    },
    {
      "key": "people",
      "allowed": ["Marc Andreessen", "Ben Horowitz"]
    },
    {
      "key": "content_type",
      "allowed": ["Blog Post", "Podcast", "Tweet Thread"]
    }
  ],
  // Activity metrics
  "activity": {
    "7d_count": 12,
    "30d_count": 48,
    "90d_count": 156
  }
}

Filter Discovery Pattern

Always call /stream first to discover available filters and body sections for that stream. Each stream has unique filter dimensions and section structures. Use this metadata to construct precise /stories queries.

POST

/stories

Surgical extraction with multi-dimensional filtering

Request Example

curl -X POST https://api.synorb.com/stories \
  -H "api-key: {{API_KEY}}" \
  -H "secret: {{API_SECRET}}" \
  -H "Content-Type: application/json" \
  -d '{
    "stream_id": 889,
    "published_date_from": "2025-08-01",
    "published_date_to": "2025-10-03",
    "page_num": 0,
    "page_size": 100,
    "body_sections": [
      "Key Insights",
      "Signals",
      "Portfolio Mentions"
    ],
    "filters": [
      {"key": "Topics", "value": "AI"},
      {"key": "people", "value": "Marc Andreessen"}
    ]
  }'

Request Body

{
  "stream_id": 889,                    // Required
  "published_date_from": "2025-08-01", // Optional
  "published_date_to": "2025-10-03",   // Optional
  "page_num": 0,                      // Default: 0
  "page_size": 100,                   // Max: 200
  // Section extraction (empty = all)
  "body_sections": [
    "Key Insights",
    "Signals",
    "Portfolio Mentions"
  ],
  // Multi-dimensional filtering
  "filters": [
    {"key": "Topics", "value": "AI"},
    {"key": "people", "value": "Marc Andreessen"}
  ]
}

Request Parameters

Parameter	Type	Required	Description
stream_id	integer	Required	Target stream identifier
body_sections	array	Optional	Sections to extract (empty = all 15 sections). Use /stream to discover available sections.
filters	array	Optional	Multi-dimensional filters [{key, value}]. Use /stream to discover filter dimensions.
published_date_from	string	Optional	Start date (YYYY-MM-DD format)
page_size	integer	Optional	Results per page (max: 200)

Response Schema

{
  "stories": [
    {
      "story_id": 1126730,
      "published_date": "2025-09-23",
      "filters": [
        {"key": "Topics", "allowed": ["AI", "Crypto"]},
        {"key": "people", "allowed": ["Ben Horowitz"]}
      ],
      "story": {
        "body": "# Title\n\n## Key Insights\n..."
      }
    }
  ],
  "pagination": {
    "total_count": 28,
    "next": null,
    "prev": null
  }
}

Critical Requirements

⚠️ MUST provide date ranges - no default behavior

Date ranges required even if searching by other filters

Best Practices

• Start with recent dates (last 30 days) unless specified
• Use page_size=50-100 initially
• Get filter values from /stream first
• ALWAYS cite source_urls in outputs
• Parse story.body - format varies (JSON, markdown, structured text)

Surgical Extraction

Combine body_sections + filters for precision targeting. Example: Extract only "Portfolio Mentions" section from AI-related stories by Marc Andreessen. Filters are stream-specific - always check /stream first.

Native SDKs

Production-ready libraries with built-in surgical extraction and multi-dimensional filtering

PY

Python

Coming Q1 2026

pip install synorb

from synorb import Client
client = Client("{{API_KEY}}", "{{API_SECRET}}")

# Discover stream filters
stream = client.get_stream(889)
print(stream["body_sections"])  # 15+ sections

# Surgical extraction
stories = client.get_stories(
  stream_id=889,
  filters=[
    {"key": "Topics", "value": "AI"},
    {"key": "people", "value": "Marc Andreessen"}
  ],
  body_sections=["Key Insights", "Signals"]
)

# Process extracted intelligence
for story in stories["stories"]:
  insights = story["story"]["body"]
  print(insights)

JS

JavaScript/TypeScript

Coming Q1 2026

npm install synorb

import { Synorb } from 'synorb'
const client = new Synorb("{{API_KEY}}", "{{API_SECRET}}")

// Discover stream structure
const stream = await client.getStream(889)
console.log(stream.bodySections)

// Multi-dimensional filtering
const response = await client.getStories({
  streamId: 889,
  filters: [
    { key: "Topics", value: "AI" },
    { key: "people", value: "Ben Horowitz" }
  ],
  bodySections: ["Portfolio Mentions"]
})

// Extract portfolio intelligence
response.stories.forEach(s => {
  console.log(s.story.body)
})

JAVA

Java

Coming Q1 2026

com.synorb:synorb-java:1.0.0

import com.synorb.Client;
import com.synorb.models.*;

Client client = new Client("{{API_KEY}}", "{{API_SECRET}}");

// Surgical query builder
Stories response = client.stories()
  .streamId(889)
  .filter("Topics", "AI")
  .sections("Key Insights", "Signals")
  .execute();

GO

Go

Coming Q1 2026

go get github.com/synorb/synorb-go

import "github.com/synorb/synorb-go"

client := synorb.NewClient("{{API_KEY}}", "{{API_SECRET}}")

// Multi-filter query
response, err := client.GetStories(synorb.Query{
  StreamID: 889,
  Filters: []synorb.Filter{
    {Key: "Topics", Value: "AI"},
  },
  Sections: []string{"Key Insights"},
})

Enterprise Use Cases

Real patterns for production AI applications

Competitive Intelligence

Track Competitor Portfolio Activity

Extract portfolio mentions from VC content, filtered by specific topics and investors

filters=[{"key": "people", "value": "Marc Andreessen"}]
body_sections=["Portfolio Mentions", "Signals"]

Risk Monitoring

Extract Risk Signals from Filings

Pull only risk sections from regulatory filings, filtered by entity type

filters=[{"key": "entity_type", "value": "Public Company"}]
body_sections=["Risks & Watchpoints"]

Market Research

AI Trend Analysis from VC Insights

Aggregate key insights about AI from multiple venture sources

filters=[{"key": "Topics", "value": "AI"}]
body_sections=["Key Insights", "Big Picture"]

Deal Sourcing

Monitor Funding Announcements

Extract only announcement sections from specific industry streams

filters=[{"key": "content_type", "value": "Funding"}]
body_sections=["Announcement", "Key Details"]

Production-Ready in 3 Steps

From setup to surgical extraction

1

Your Credentials

You're already authenticated with your API key and secret

2

Discover Filters

Call /stream to see available filters and sections

3

Extract Intelligence

Combine filters + sections for surgical precision

# Complete enterprise workflow - 8 lines
from synorb import Client
client = Client("{{API_KEY}}", "{{API_SECRET}}")

# Discover stream structure
stream = client.get_stream(889)

# Surgical extraction
ai_insights = client.get_stories(
  stream_id=889,
  filters=[{"key": "Topics", "value": "AI"}],
  body_sections=["Key Insights", "Signals"]
)

print(f"Extracted {len(ai_insights['stories'])} precision insights")
    

Advanced Patterns

Production-ready techniques for multi-dimensional filtering, pagination strategies, and surgical extraction at scale

Multi-Dimensional Filtering

Combine filters across dimensions for precision targeting (AND logic)

SDK Required

# Python: Combine multiple filter dimensions
stories = client.get_stories(
  stream_id=889,
  api_key="{{API_KEY}}",
  api_secret="{{API_SECRET}}",
  filters=[
    {
      "key": "Topics",
      "value": "AI"
    },
    {
      "key": "people",
      "value": "Marc Andreessen"
    },
    {
      "key": "content_type",
      "value": "Blog Post"
    }
  ],
  published_date_from="2025-09-01"
)

How It Works

Filters use AND logic across dimensions:

Topics = "AI" AND
people = "Marc Andreessen" AND
content_type = "Blog Post"

Result: Only AI blog posts by Marc Andreessen

Surgical Section Extraction

Extract only specific sections to reduce payload and focus intelligence

SDK Required

# JavaScript: Extract specific sections only
const response = await client.getStories({
  streamId: 889,
  apiKey: "{{API_KEY}}",
  apiSecret: "{{API_SECRET}}",
  filters: [
    { key: "Topics", value: "AI" }
  ],
  bodySections: [
    "Key Insights",
    "Signals",
    "Portfolio Mentions"
  ]
})

// Story body contains ONLY requested sections

Why Use This

Reduce payload: Get 3 sections instead of 15
Focus intelligence: Extract only what matters
Faster processing: Less data to parse
Cost savings: Smaller responses = lower bandwidth

Efficient Pagination

Handle large result sets with cursor-based pagination

SDK Required

# Python: Paginate through large result sets
all_stories = []
page_num = 0
has_more = True

while has_more:
  response = client.get_stories(
    stream_id=889,
    api_key="{{API_KEY}}",
    api_secret="{{API_SECRET}}",
    filters=[{"key": "Topics", "value": "AI"}],
    page_num=page_num,
    page_size=200  # Max per request
  )
  
  all_stories.extend(response["stories"])
  
  # Check if there are more pages
  has_more = response["pagination"]["next"] is not None
  page_num += 1
  
  print(f"Fetched {len(all_stories)} stories so far...")

print(f"Total: {len(all_stories)} stories")

Production Recipes

Copy-paste patterns for common enterprise use cases

Competitive Intel SDK Required

Monitor Competitor Portfolio Activity

Track what your competitors are investing in by extracting portfolio mentions from VC streams

# Get competitor portfolio signals client.get_stories( stream_id=889, api_key="{{API_KEY}}", api_secret="{{API_SECRET}}", filters=[ {"key": "people", "value": "Competitor VC"} ], body_sections=[ "Portfolio Mentions", "Signals" ] )

Risk Monitoring SDK Required

Extract Risk Signals from Filings

Pull only risk-related sections from regulatory streams for compliance monitoring

# Monitor regulatory risks client.get_stories( stream_id=308, api_key="{{API_KEY}}", api_secret="{{API_SECRET}}", filters=[ {"key": "entity_type", "value": "Public Company"} ], body_sections=[ "Risks & Watchpoints", "Key Details" ] )

Trend Analysis SDK Required

Aggregate AI Market Insights

Collect key insights about AI trends from multiple VC and research sources

# Aggregate AI trend signals client.get_stories( stream_id=889, api_key="{{API_KEY}}", api_secret="{{API_SECRET}}", filters=[ {"key": "Topics", "value": "AI"} ], body_sections=[ "Key Insights", "Big Picture" ], published_date_from="2025-09-01" )

Deal Sourcing SDK Required

Track Funding Announcements

Monitor new funding rounds by filtering for announcement-type content

# Find funding announcements client.get_stories( stream_id=889, api_key="{{API_KEY}}", api_secret="{{API_SECRET}}", filters=[ {"key": "content_type", "value": "Funding"} ], body_sections=[ "Announcement", "Key Details", "Entities Mentioned" ] )

Market Research SDK Required

Extract Actionable Takeaways

Get only actionable insights from industry reports for strategic planning

# Get strategic actions client.get_stories( stream_id=889, api_key="{{API_KEY}}", api_secret="{{API_SECRET}}", filters=[ {"key": "Topics", "value": "Enterprise"} ], body_sections=[ "Actionable Takeaways", "Big Picture" ] )

Content Aggregation SDK Required

Build Custom News Feeds

Create personalized intelligence feeds by combining multiple filters and date ranges

# Custom intelligence feed client.get_stories( stream_id=889, api_key="{{API_KEY}}", api_secret="{{API_SECRET}}", filters=[ {"key": "Topics", "value": "AI"}, {"key": "content_type", "value": "Blog Post"} ], body_sections=["Overview", "Links"], published_date_from="2025-10-01" )