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 assistant in under 30 seconds

Connector URL

Loading...

Claude

by Anthropic

Supported

Eligible Plans

Pro Max Team Enterprise

Setup

1

Copy your Connector URL

Open the Credentials Bar at the top of this page and copy your Connector URL.

2

Add it as a Connector in Claude

In Claude, go to Settings → Connectors → Add and paste your Connector URL.

3

Test the connection

Ask Claude:

"What Synorb streams do I have access to?"

ChatGPT

by OpenAI

Supported

Eligible Plans

Plus Developer Pro

Currently via Developer Mode — standard ChatGPT support coming soon

Setup

1

Copy your Connector URL

Open the Credentials Bar at the top of this page and copy your Connector URL.

2

Add it as a Connector in ChatGPT

In ChatGPT, go to Settings → Connectors → Add and paste your Connector URL.

3

Test the connection

Ask ChatGPT:

"What Synorb streams do I have access to?"

Troubleshooting

Connection not working? Make sure you copied the full Connector URL from your credentials. It should start with https:// and contain your unique token.

Tools not appearing? After adding the connector, start a new conversation. Some platforms require a fresh chat for MCP tools to load.

Need to reset? Use the Regenerate button in the Credentials Bar to get fresh credentials, then update your connector.

MCP Documentation

Model Context Protocol server integration with personalized credentials

Base URL

Loading...

MCP Token

Loading...

API Documentation

REST API integration with your credentials pre-filled

Base URL

Loading...

API Key

Loading...

API Secret

Loading...

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

synorb-stream-stories-advanced

Fetch stories across multiple streams in a single request with AND filters and pagination

Description

Search and retrieve stories across one or more streams simultaneously. Supports multi-stream querying with AND filter logic, date ranges, pagination, and body section selection. Use this when aggregating intelligence from different sources, domains, or entity types in a single request.

Required Parameters

Parameter	Type	Description
stream_ids	array[number]	One or more numeric stream identifiers
Date Range	strings	published_date_from + published_date_to OR created_on_from + created_on_to (YYYY-MM-DD)

Optional Parameters

Parameter	Type	Description
filters	array	[{key, operator, allowed}] — stream-specific filters with AND/OR operators (two-group logic)
body_sections	array	Restrict output to specific content sections
page_size	integer	Results per page (default 50, max 200)
page_num	integer	Page index for pagination (0-based)

Returns

Field	Type	Description
stories	array	Array of content objects with story_id, stream_id, dates, filters, evidence_ref, and body
pagination	object	Navigation metadata (total_count, page_num, page_size, next, prev)

When to Use

• Querying multiple streams in a single request
• Building cross-domain dashboards or reports
• Aggregating intelligence from different source types
• When pagination.next is non-null, iterate until null for complete results

Key Difference from synorb-stream-stories

This tool accepts multiple stream_ids (numeric array) and returns results across all specified streams. Use synorb-stream-stories for single-stream queries with simple filters.

synorb-stream-stories-advanced-logic

Multi-stream queries with explicit AND/OR boolean filter logic

Description

The most powerful query tool — search across multiple streams with explicit boolean filter logic. Build complex queries like (Tesla OR SpaceX) AND AI for precise cross-stream intelligence retrieval. Supports two-group filter logic with AND/OR operators.

Required Parameters

Parameter	Type	Description
stream_id	array[number]	One or more numeric stream identifiers
Date Range	strings	published_date_from + published_date_to OR created_on_from + created_on_to (YYYY-MM-DD)

Optional Parameters

Parameter	Type	Description
filters	array	[{key, value}] — stream-specific filters with boolean logic (two-group)
body_sections	array	Restrict output to specific content sections
page_size	integer	Results per page (default 50, max 200)
page_num	integer	Page index for pagination (0-based)

Returns

Field	Type	Description
stories	array	Array of content objects with story_id, stream_id, dates, filters, evidence_ref, and body
pagination	object	Navigation metadata (total_count, page_num, page_size, next, prev)

When to Use

• Complex cross-stream queries requiring boolean logic
• Combining inclusion and exclusion filters
• Precise intelligence retrieval across multiple domains
• When synorb-stream-stories-advanced doesn't offer enough filter control

Boolean Logic Pattern

This tool adds explicit AND/OR boolean operators to filter groups. Use it for queries like "stories about (AI OR ML) AND (healthcare)" that require combining filter dimensions with precise logic.

Real-World Implementation

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

Investment Due Diligence Pipeline

Multi-source company intelligence in a single query — regulatory filings, earnings calls, and VC perspective

SEC 8-K Earnings Calls a16z stories-advanced

// Multi-source company research — single query async function researchCompany(companyName) { // One call across 3 streams instead of 3 separate calls const result = await synorb.get_stories_advanced({ stream_ids: [786, 1015, 889], filters: [{ key: "organization", operator: "AND", allowed: [companyName] }], body_sections: [ "Risks & Watchpoints", "Key Details", "Key Insights", "Signals", "Big Picture" ], published_date_from: "2025-01-01", published_date_to: "2025-10-10", page_size: 100 }); // Group results by source stream const grouped = result.stories.reduce((acc, s) => { acc[s.stream_id] = acc[s.stream_id] || []; acc[s.stream_id].push(s); return acc; }, {}); return { regulatory_risks: grouped[786] || [], financial_health: grouped[1015] || [], vc_sentiment: grouped[889] || [], total: result.pagination.total_count }; }

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 in one query

General Catalyst Atlantic Council Earnings SEC 8-K stories-advanced

// Multi-source sector intelligence — single query const crossSector = async (sector) => { // One call across 4 streams instead of 4 separate calls const result = await synorb.get_stories_advanced({ stream_ids: [947, 521, 1015, 786], filters: [{ key: "topic", operator: "AND", allowed: [sector] }], body_sections: [ "Signals", "Big Picture", "Key Insights", "Risks & Watchpoints" ], published_date_from: "2025-01-01", published_date_to: "2025-10-10", page_size: 200 }); // Group by source stream const grouped = result.stories.reduce((acc, s) => { acc[s.stream_id] = acc[s.stream_id] || []; acc[s.stream_id].push(s); return acc; }, {}); return { vc_positioning: grouped[947] || [], policy_headwinds: grouped[521] || [], public_sentiment: grouped[1015] || [], regulatory_activity: grouped[786] || [], convergence_score: calculateConvergence(grouped) }; };

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; } }

Boolean Logic Cross-Stream Query

Precise intelligence retrieval with AND/OR filter logic across multiple streams and domains

SEC 8-K Earnings Calls a16z stories-advanced-logic

// Boolean logic: (Tesla OR SpaceX) across streams const booleanQuery = async () => { const result = await synorb.get_stories_advanced_logic({ stream_id: [786, 1015, 889], filters: [ { key: "organization", value: "Tesla" }, { key: "organization", value: "SpaceX" } ], body_sections: [ "Key Details", "Signals", "Risks & Watchpoints" ], published_date_from: "2025-01-01", published_date_to: "2025-10-10", page_size: 100 }); // Paginate if more results exist let allStories = [...result.stories]; let page = 1; while (result.pagination.next) { const next = await synorb.get_stories_advanced_logic({ stream_id: [786, 1015, 889], filters: [ { key: "organization", value: "Tesla" }, { key: "organization", value: "SpaceX" } ], published_date_from: "2025-01-01", published_date_to: "2025-10-10", page_num: page++, page_size: 100 }); allStories = allStories.concat(next.stories); if (!next.pagination.next) break; } return { stories: allStories, total: allStories.length, sources: [...new Set(allStories.map(s => s.stream_id))] }; };

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
});
console.log(details.body_sections);

// STEP 2: Request ONLY what exists
synorb.get_stories({
  stream_id: 889,
  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,
  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,
  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,
  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,
  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 });

if (details.stories_over_last_7_days > 10) {
  // Hot stream - query recent only
  const trending = await synorb.get_stories({
    stream_id: 889,
    published_date_from: getLastWeek(),
    published_date_to: getToday()
  });
} else {
  // Quiet stream - expand window
  const recent = await synorb.get_stories({
    stream_id: 889,
    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 stories-advanced

Find content that spans multiple domains in a single query — no loops or Promise.all needed

❌ Inefficient - Looping Streams

// Multiple calls in a loop
const catalog = await synorb.get_catalog();
const aiStreams = catalog.streams.filter(s =>
  s.cross_domains?.includes("engineering-technology")
);

// N separate calls — slow
const results = await Promise.all(
  aiStreams.map(s => synorb.get_stories({
    stream_id: s.id,
    published_date_from: "2025-09-01",
    published_date_to: "2025-09-30"
  }))
);

✅ Optimal - Single Advanced Call

// Discover stream IDs from catalog
const catalog = await synorb.get_catalog();
const aiStreamIds = catalog.streams
  .filter(s => s.cross_domains?.includes("engineering-technology"))
  .map(s => s.id);

// ONE call across all streams
const result = await synorb.get_stories_advanced({
  stream_ids: aiStreamIds,
  filters: [{ key: "topic", operator: "AND", allowed: ["AI"] }],
  published_date_from: "2025-09-01",
  published_date_to: "2025-09-30",
  page_size: 200
});

stories-advanced

Pass multiple stream_ids to query across domains in one call. Eliminates Promise.all loops and reduces latency proportional to stream count.

5

Provenance-Aware Filtering

Build trust by tracking source URLs and classification confidence

const result = await synorb.get_stories({
  stream_id: 889,
  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
}));

Trust & Attribution

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

6

Multi-Stream Boolean Logic stories-advanced-logic

Query across multiple streams with explicit AND/OR boolean filter logic — combine inclusion criteria in a single call

❌ Without Boolean Logic

// Separate queries, manual merging
const [tesla, spacex] = await Promise.all([
  synorb.get_stories_advanced({
    stream_ids: [786, 1015],
    filters: [{ key: "organization", operator: "AND", allowed: ["Tesla"] }],
    published_date_from: "2025-01-01",
    published_date_to: "2025-10-10"
  }),
  synorb.get_stories_advanced({
    stream_ids: [786, 1015],
    filters: [{ key: "organization", operator: "AND", allowed: ["SpaceX"] }],
    published_date_from: "2025-01-01",
    published_date_to: "2025-10-10"
  })
]);
// Manual deduplication needed

✅ With Boolean Logic

// (Tesla OR SpaceX) in one call
const result = await synorb.get_stories_advanced_logic({
  stream_id: [786, 1015],
  filters: [
    { key: "organization", value: "Tesla" },
    { key: "organization", value: "SpaceX" }
  ],
  body_sections: ["Key Details", "Signals"],
  published_date_from: "2025-01-01",
  published_date_to: "2025-10-10",
  page_size: 200
});
// No dedup — handled server-side

stories-advanced-logic

Use key/value filter pairs for boolean inclusion. Note: param is stream_id (array), not stream_ids. Paginate with page_num until pagination.next is null.

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,
  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.

❌ Mistake 5: Wrong Tool for Multi-Stream

Wrong: Promise.all with multiple get_stories calls.
Correct: Use get_stories_advanced (stream_ids) or get_stories_advanced_logic (stream_id + boolean filters).

Pro Tip: Always check synorb-stream-details first. For multi-stream queries, use advanced tools—they're faster and handle deduplication server-side.

Performance Optimization

Maximize throughput

Multi-Stream Aggregation

Use stories-advanced to query multiple streams in a single call — eliminates Promise.all overhead and returns unified, paginated results.

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.

// Multi-stream query — one call replaces N
const streamIds = [889, 947, 989];
const result = await synorb.get_stories_advanced({
  stream_ids: streamIds,
  body_sections: ["Key Insights", "Signals"],
  published_date_from: "2025-09-01",
  published_date_to: "2025-09-30",
  page_size: 200
});

// Group results by stream
const byStream = result.stories.reduce((acc, s) => {
  acc[s.stream_id] = acc[s.stream_id] || [];
  acc[s.stream_id].push(s);
  return acc;
}, {});

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.

Multi-Stream Aggregation

Use stories-advanced or stories-advanced-logic to query across streams in a single call. Group by stream_id for source attribution.

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

  // Step 2: Query with validated sections
  const result = await synorb.get_stories({
    stream_id: streamId,
    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 stories-advanced

Discover streams → Analyze activity → Extract insights in one query → 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 (Single Query) →

// Extract insights from ALL hot streams in one call const hotStreamIds = hotStreams.slice(0, 5).map(s => s.id); const result = await synorb.get_stories_advanced({ stream_ids: hotStreamIds, mcp_token: "{{MCP_TOKEN}}", filters: [{ key: "topic", operator: "AND", allowed: ["AI"] }], body_sections: [ "Key Insights", "Big Picture", "Signals" ], published_date_from: "2025-10-08", published_date_to: "2025-10-15", page_size: 200 }); // Group results by stream for analysis const insights = hotStreams.slice(0, 5).map(stream => ({ source: stream.title, insights: result.stories.filter(s => s.stream_id === stream.id) }));

One stories-advanced call replaces N parallel get_stories calls — same results, single round-trip

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 stories-advanced

Multi-source tracking in one query → Cross-reference validation → Alert generation

1 Multi-Source Monitoring (Single Query) →

// Track competitor across ALL sources in one call const competitor = "CompanyX"; const allMentions = await synorb.get_stories_advanced({ stream_ids: [ 889, // VC perspective 786, // SEC filings 1015, // Earnings calls 1014 // Industry podcasts ], mcp_token: "{{MCP_TOKEN}}", filters: [{ key: "organization", operator: "AND", allowed: [competitor] }], published_date_from: "2025-09-15", published_date_to: "2025-10-15", page_size: 200 }); // Group by source stream const bySource = allMentions.stories.reduce((acc, s) => { acc[s.stream_id] = acc[s.stream_id] || []; acc[s.stream_id].push(s); return acc; }, {}); const vcMentions = bySource[889] || []; const secFilings = bySource[786] || []; const earnings = bySource[1015] || []; const media = bySource[1014] || [];

One stories-advanced call replaces 4 parallel get_stories calls. Group by stream_id for source attribution.

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

Architecture note: Each step intentionally uses separate get_stories calls because each stream requires different body_sections (VC: Key Arguments, SEC: Risks & Watchpoints, Earnings: Key Insights). stories-advanced applies body_sections uniformly—use separate calls when section requirements differ per stream.

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 { const details = await synorb.get_stream_details({ stream_id: streamId, mcp_token: "{{MCP_TOKEN}}" }); const validSections = requestedSections.filter( s => details.body_sections.includes(s) ); if (validSections.length === 0) { console.warn('No valid sections. Using defaults.'); 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 { let validSections = filters.body_sections; if (validSections && validSections.length > 0) { validSections = await validateSections( streamId, filters.body_sections ); } 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 }); if (!result.stories || result.stories.length === 0) { console.warn('No stories returned. Try expanding date range.'); } 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) { if (error.details?.invalid_sections) { console.error('Invalid sections:', error.details.invalid_sections); return robustQuery(streamId, { ...filters, body_sections: error.details.available_sections.slice(0, 3) }); } if (error.details?.invalid_filters) { throw new Error('Check entity_details structure'); } if (error.message?.includes('date')) { throw new Error( 'Both published_date_from and published_date_to required' ); } 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) { 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

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" )

Confirm Action

Regenerate Credentials

Learn

AI Assistants

MCP Documentation

API Documentation

Settings

Profile

Available Plans

Billing

MCP Tools Reference

Description

Parameters

Returns

When to Use

Description

Parameters

Returns

When to Use

Description

Parameters

Returns

When to Use

Description

Required Parameters

Optional Parameters

Returns

Critical Requirements

Best Practices

Description

Required Parameters

Optional Parameters

Returns

When to Use

Description

Required Parameters

Optional Parameters

Returns

When to Use

Real-World Implementation

Investment Due Diligence Pipeline

Real Estate Market Intelligence

Geopolitical Risk Monitor

Crowdfunding Deal Flow

Cross-Sector Correlation Engine

Podcast Intelligence + SEC Validation

Robust Error Handling

Boolean Logic Cross-Stream Query

Advanced Filtering Patterns

Section Discovery First (ALWAYS)

Multi-Entity Boolean Filtering

Surgical Section Extraction

Temporal Precision Control

Cross-Domain Intelligence Discovery stories-advanced

Provenance-Aware Filtering

Multi-Stream Boolean Logic stories-advanced-logic

Production Architecture

Common Integration Mistakes

Performance Optimization

Integration Patterns

Intelligence Workflows

Market Research Pipeline stories-advanced

Competitive Intelligence Monitor stories-advanced

Investment Thesis Validation

RAG Context Extraction Pipeline

Error Handling & Validation Pipeline

Endpoint Reference

Request Example

Authentication Headers

Response Schema

Request Example

Response Schema

Key Fields

Request Example

Parameters

Response: Filter Discovery

Request Example

Request Body

Request Parameters

Response Schema