# How to integrate Crustdata MCP with OpenAI Agents SDK ```json { "title": "How to integrate Crustdata MCP with OpenAI Agents SDK", "toolkit": "Crustdata", "toolkit_slug": "crustdata", "framework": "OpenAI Agents SDK", "framework_slug": "open-ai-agents-sdk", "url": "https://composio.dev/toolkits/crustdata/framework/open-ai-agents-sdk", "markdown_url": "https://composio.dev/toolkits/crustdata/framework/open-ai-agents-sdk.md", "updated_at": "2026-05-12T10:07:51.622Z" } ``` ## Introduction This guide walks you through connecting Crustdata to the OpenAI Agents SDK using the Composio tool router. By the end, you'll have a working Crustdata agent that can find tech companies with recent funding milestones, enrich this lead's profile with latest data, list top decision makers in saas startups through natural language commands. This guide will help you understand how to give your OpenAI Agents SDK agent real control over a Crustdata account through Composio's Crustdata MCP server. Before we dive in, let's take a quick look at the key ideas and tools involved. ## Also integrate Crustdata with - [Claude Agent SDK](https://composio.dev/toolkits/crustdata/framework/claude-agents-sdk) - [Claude Code](https://composio.dev/toolkits/crustdata/framework/claude-code) - [Claude Cowork](https://composio.dev/toolkits/crustdata/framework/claude-cowork) - [Codex](https://composio.dev/toolkits/crustdata/framework/codex) - [OpenClaw](https://composio.dev/toolkits/crustdata/framework/openclaw) - [Hermes](https://composio.dev/toolkits/crustdata/framework/hermes-agent) - [CLI](https://composio.dev/toolkits/crustdata/framework/cli) - [Google ADK](https://composio.dev/toolkits/crustdata/framework/google-adk) - [LangChain](https://composio.dev/toolkits/crustdata/framework/langchain) - [Vercel AI SDK](https://composio.dev/toolkits/crustdata/framework/ai-sdk) - [Mastra AI](https://composio.dev/toolkits/crustdata/framework/mastra-ai) - [LlamaIndex](https://composio.dev/toolkits/crustdata/framework/llama-index) - [CrewAI](https://composio.dev/toolkits/crustdata/framework/crew-ai) ## TL;DR Here's what you'll learn: - Get and set up your OpenAI and Composio API keys - Install the necessary dependencies - Initialize Composio and create a Tool Router session for Crustdata - Configure an AI agent that can use Crustdata as a tool - Run a live chat session where you can ask the agent to perform Crustdata operations ## What is OpenAI Agents SDK? The OpenAI Agents SDK is a lightweight framework for building AI agents that can use tools and maintain conversation state. It provides a simple interface for creating agents with hosted MCP tool support. Key features include: - Hosted MCP Tools: Connect to external services through hosted MCP endpoints - SQLite Sessions: Persist conversation history across interactions - Simple API: Clean interface with Agent, Runner, and tool configuration - Streaming Support: Real-time response streaming for interactive applications ## What is the Crustdata MCP server, and what's possible with it? The Crustdata MCP server is an implementation of the Model Context Protocol that connects your AI agent and assistants like Claude, Cursor, etc directly to your Crustdata account. It provides structured and secure access to real-time company and people intelligence, so your agent can perform actions like lead enrichment, market research, investor portfolio analysis, and workforce trend tracking on your behalf. - Comprehensive person and company enrichment: Instantly enrich leads or companies with up-to-date details for customer profiling, data verification, or targeted outreach. - Advanced decision maker filtering: Find and analyze decision makers across organizations using complex filters, titles, and segmentation for your sales or marketing efforts. - Investor portfolio and funding milestone analysis: Retrieve in-depth investor portfolio data, analyze funding milestones, and generate reports for investment research or deal sourcing. - Workforce and job market trend insights: Fetch headcount and job listing timeseries data to track organizational growth, hiring activity, or competitive shifts in specific industries. - Social and web activity monitoring: Collect and analyze LinkedIn posts and web traffic data for any company to assess engagement, sentiment, and digital footprint for market intelligence and outreach strategies. ## Supported Tools | Tool slug | Name | Description | |---|---|---| | `CRUSTDATA_ENRICH_PERSON_SCREENER` | Enrich person screener | The screener_person_enrich endpoint enriches person data by providing additional information based on the given query. It allows users to retrieve detailed information about individuals, which can be useful for various purposes such as customer profiling, lead generation, or data verification. This endpoint should be used when you need to augment existing person data with additional details or verify information about a specific individual. The enrichment process draws from CrustData's extensive database and real-time data sources to provide up-to-date and comprehensive information. Users can customize the response by specifying the exact fields they need, optimizing data transfer and processing. Note that the availability and accuracy of enriched data may vary depending on the input provided and the information available in CrustData's systems. | | `CRUSTDATA_FETCH_HEADCOUNT_BY_FACET_TIMESERIES` | Fetch headcount by facet timeseries | Retrieves headcount data as a timeseries with faceted analysis capabilities. This endpoint allows users to fetch detailed headcount information over time, applying complex filters, pagination, and sorting. It's particularly useful for HR analytics, workforce planning, and organizational growth analysis. The endpoint supports nested logical operations in its filtering mechanism, enabling highly specific queries. Users can paginate through large datasets and sort results based on multiple criteria. While powerful, this endpoint requires careful construction of the filters parameter to ensure accurate data retrieval. It should be used when detailed, time-based headcount analysis is needed, but may not be suitable for simple, non-time-series headcount queries or for real-time data needs due to its complexity. | | `CRUSTDATA_FETCH_INVESTOR_PORTFOLIO_DATA` | Fetch investor portfolio data | Retrieves comprehensive investor portfolio data from the Data Lab section of the CrustData API. This endpoint provides access to detailed information about investor portfolios, including investment holdings, performance metrics, and other relevant data points. It is designed to support investment analysis, portfolio management, and decision-making processes in a B2B context. The endpoint should be used when detailed investor portfolio information is required for tasks such as investment screening, performance tracking, or generating analytical reports. It's important to note that this endpoint may not provide real-time data and the frequency of updates should be verified in the API documentation. Additionally, users should be aware of any data privacy and usage restrictions that may apply to the retrieved investor information. | | `CRUSTDATA_FILTER_DECISION_MAKERS_DATA` | Filter decision makers data | Filters and retrieves decision maker data from the CrustData B2B SaaS integration platform based on complex criteria. This endpoint allows for advanced querying of decision maker information using a combination of filters, pagination, sorting, and title-based filtering. It's designed for scenarios where specific subsets of decision maker data need to be extracted or analyzed. The endpoint supports nested logical conditions in filters, enabling highly targeted data retrieval. Use this when you need to perform detailed analysis or reporting on decision makers across various organizations or industries. Note that the endpoint requires careful structuring of the request body to effectively utilize its advanced filtering capabilities. | | `CRUSTDATA_POST_FUNDING_MILESTONE_TIME_SERIES_DATA` | Post funding milestone timeseries data | The FundingMilestoneTimeseries endpoint retrieves time-series data related to funding milestones for companies. It allows for complex querying of funding events over time, with flexible filtering, pagination, and sorting options. This endpoint is particularly useful for analyzing funding trends, comparing company funding histories, or tracking specific funding events across multiple organizations. The data returned is based on the specified filters and can be tailored to focus on particular time ranges, funding stages, or company characteristics. While it provides comprehensive funding milestone data, it does not include detailed company information beyond what's directly related to funding events. | | `CRUSTDATA_POST_HEADCOUNT_TIMESERIES_DATA` | Post headcount timeseries data | Retrieves filtered and sorted headcount timeseries data from the CrustData Data Lab. This endpoint allows for complex querying of historical headcount information, enabling users to analyze workforce trends over time. It supports advanced filtering with nested conditions, pagination for handling large datasets, and customizable sorting. Ideal for generating reports, conducting workforce analysis, or integrating headcount data into third-party business intelligence tools. Note that the specifics of the returned data structure are not provided in the given schema. | | `CRUSTDATA_POST_JOB_LISTINGS_TABLE_DATA` | Post job listings table data | This endpoint retrieves filtered and sorted job listings data for specified company tickers from a chosen dataset in the CrustData platform. It allows for highly customizable queries with complex filtering conditions, pagination, and sorting options. The endpoint is designed for bulk data retrieval and analysis of job market trends across multiple companies. Use this endpoint when you need to fetch and analyze job listing data for specific companies, apply custom filters to narrow down the results, or when you want to paginate through large sets of job data. It's particularly useful for market research, competitive analysis, or tracking employment trends in specific industries or companies. Note that this endpoint requires careful construction of the request body, especially for the filters parameter, which can support nested logical conditions. The performance and response time may vary depending on the complexity of the filters and the amount of data requested. | | `CRUSTDATA_POST_WEB_TRAFFIC_DATA` | Post web traffic data | Retrieves filtered and sorted web traffic data from the CrustData platform. This endpoint allows for complex querying of web traffic information using nested conditions and logical operators. It supports pagination for handling large datasets and provides sorting capabilities for customized data presentation. Use this endpoint when you need to analyze web traffic patterns, filter data based on specific criteria, or extract insights from your web analytics. The endpoint is particularly useful for generating reports, identifying trends, or monitoring key performance indicators related to web traffic. | | `CRUSTDATA_RETRIEVE_LINKED_IN_POSTS` | Retrieve linkedin posts | Retrieves LinkedIn posts for a specified company using CrustData's screener functionality. This endpoint allows users to gather social media data from LinkedIn, which can be used for analyzing company activity, engagement, and sentiment. It's particularly useful for B2B marketers, sales professionals, and analysts who need insights into a company's social media presence and content strategy. The endpoint supports filtering by date range and customizing the response fields, making it versatile for various use cases such as competitive analysis, lead generation, and market research. Note that the availability and completeness of data may depend on the company's LinkedIn activity and privacy settings. | | `CRUSTDATA_SCREENER_COMPANY_INFORMATION` | Screener company information | The GetCompanyScreener endpoint allows users to search and filter companies based on various criteria such as headcount, growth rate, funding, and more. It provides a powerful way to identify specific companies that meet predefined conditions. This endpoint is particularly useful for tasks like lead generation, market research, and competitive analysis. The endpoint returns a list of companies matching the specified criteria, with each company entry containing key information such as name, industry, headcount, funding details, and growth metrics. Users can customize their search using multiple filters, sort the results, and paginate through large result sets. Note that the accuracy of the data depends on CrustData's real-time data collection and update frequency. | | `CRUSTDATA_SCREEN_METRICS_AND_FILTER_CONDITIONS` | Screen metrics and filter conditions | The ScreenData endpoint enables advanced data screening and filtering on the CrustData platform. It allows users to construct complex queries for retrieving specific datasets based on custom metrics, filtering conditions, and sorting criteria. Use this endpoint for targeted data extraction, custom reporting, or data analysis within the B2B SaaS integration ecosystem. Note that while powerful, complex queries may impact performance with large datasets. | | `CRUSTDATA_SEARCH_COMPANIES_WITH_FILTERS` | Search companies with filters | The CompanySearch endpoint enables users to search and filter companies using the CrustData API. It provides a powerful mechanism for querying company data based on multiple criteria, supporting complex filtering and pagination. This endpoint is ideal for applications that need to retrieve specific sets of company information, such as financial analysis tools, market research platforms, or business intelligence systems. The search functionality allows for precise data retrieval, enhancing the efficiency of data integration and analysis processes in B2B scenarios. Users should be aware that the endpoint requires careful construction of filter objects and proper use of pagination to ensure optimal performance and accurate results. | | `CRUSTDATA_SEARCH_FOR_JOB_ID_IN_SCREENER` | Search for job id in screener | The screener_person_search endpoint allows users to search for persons associated with a specific job ID within the CrustData B2B SaaS integration platform. This POST request accepts a JSON payload containing a job_id and returns relevant person data linked to that job. It's particularly useful for scenarios where you need to quickly retrieve all individuals connected to a particular job or project. The endpoint is part of the platform's screening functionality, enabling efficient filtering of person records based on job-related criteria. While it provides a focused search based on job ID, it may not offer advanced filtering options or return comprehensive job details. | | `CRUSTDATA_SEARCH_LINKED_IN_POSTS_BY_KEYWORD` | Search linkedin posts by keyword | This endpoint enables searching for LinkedIn posts using a specific keyword. It allows users to retrieve relevant content from LinkedIn by specifying a search term, along with options for pagination, sorting, and filtering by post date. The function is particularly useful for conducting market research, competitor analysis, or tracking industry trends on the LinkedIn platform. Users can fine-tune their search results by choosing how to sort the posts (by relevance or date) and selecting a specific time frame for the content. The endpoint returns paginated results, allowing for efficient navigation through large sets of matching posts. | ## Supported Triggers None listed. ## Creating MCP Server - Stand-alone vs Composio SDK The Crustdata MCP server is an implementation of the Model Context Protocol that connects your AI agent to Crustdata. It provides structured and secure access so your agent can perform Crustdata operations on your behalf through a secure, permission-based interface. With Composio's managed implementation, you don't have to create your own developer app. For production, if you're building an end product, we recommend using your own credentials. The managed server helps you prototype fast and go from 0-1 faster. ## Step-by-step Guide ### 1. Prerequisites Before starting, make sure you have: - Composio API Key and OpenAI API Key - Primary know-how of OpenAI Agents SDK - A live Crustdata project - Some knowledge of Python or Typescript ### 1. Getting API Keys for OpenAI and Composio OpenAI API Key - Go to the [OpenAI dashboard](https://platform.openai.com/settings/organization/api-keys) and create an API key. You'll need credits to use the models, or you can connect to another model provider. - Keep the API key safe. Composio API Key - Log in to the [Composio dashboard](https://dashboard.composio.dev?utm_source=toolkits&utm_medium=framework_docs). - Go to Settings and copy your API key. ### 2. Install dependencies Install the Composio SDK and the OpenAI Agents SDK. ```python pip install composio_openai_agents openai-agents python-dotenv ``` ```typescript npm install @composio/openai-agents @openai/agents dotenv ``` ### 3. Set up environment variables Create a .env file and add your OpenAI and Composio API keys. ```bash OPENAI_API_KEY=sk-...your-api-key COMPOSIO_API_KEY=your-api-key USER_ID=composio_user@gmail.com ``` ### 4. Import dependencies What's happening: - You're importing all necessary libraries. - The Composio and OpenAIAgentsProvider classes are imported to connect your OpenAI agent to Composio tools like Crustdata. ```python import asyncio import os from dotenv import load_dotenv from composio import Composio from composio_openai_agents import OpenAIAgentsProvider from agents import Agent, Runner, HostedMCPTool, SQLiteSession ``` ```typescript import 'dotenv/config'; import { Composio } from '@composio/core'; import { OpenAIAgentsProvider } from '@composio/openai-agents'; import { Agent, hostedMcpTool, run, OpenAIConversationsSession } from '@openai/agents'; import * as readline from 'readline'; ``` ### 5. Set up the Composio instance No description provided. ```python load_dotenv() api_key = os.getenv("COMPOSIO_API_KEY") user_id = os.getenv("USER_ID") if not api_key: raise RuntimeError("COMPOSIO_API_KEY is not set. Create a .env file with COMPOSIO_API_KEY=your_key") # Initialize Composio composio = Composio(api_key=api_key, provider=OpenAIAgentsProvider()) ``` ```typescript dotenv.config(); const composioApiKey = process.env.COMPOSIO_API_KEY; const userId = process.env.USER_ID; if (!composioApiKey) { throw new Error('COMPOSIO_API_KEY is not set. Create a .env file with COMPOSIO_API_KEY=your_key'); } if (!userId) { throw new Error('USER_ID is not set'); } // Initialize Composio const composio = new Composio({ apiKey: composioApiKey, provider: new OpenAIAgentsProvider(), }); ``` ### 6. Create a Tool Router session What is happening: - You give the Tool Router the user id and the toolkits you want available. Here, it is only crustdata. - The router checks the user's Crustdata connection and prepares the MCP endpoint. - The returned session.mcp.url is the MCP URL that your agent will use to access Crustdata. - This approach keeps things lightweight and lets the agent request Crustdata tools only when needed during the conversation. ```python # Create a Crustdata Tool Router session session = composio.create( user_id=user_id, toolkits=["crustdata"] ) mcp_url = session.mcp.url ``` ```typescript // Create Tool Router session for Crustdata const session = await composio.create(userId as string, { toolkits: ['crustdata'], }); const mcpUrl = session.mcp.url; ``` ### 7. Configure the agent No description provided. ```python # Configure agent with MCP tool agent = Agent( name="Assistant", model="gpt-5", instructions=( "You are a helpful assistant that can access Crustdata. " "Help users perform Crustdata operations through natural language." ), tools=[ HostedMCPTool( tool_config={ "type": "mcp", "server_label": "tool_router", "server_url": mcp_url, "headers": {"x-api-key": api_key}, "require_approval": "never", } ) ], ) ``` ```typescript // Configure agent with MCP tool const agent = new Agent({ name: 'Assistant', model: 'gpt-5', instructions: 'You are a helpful assistant that can access Crustdata. Help users perform Crustdata operations through natural language.', tools: [ hostedMcpTool({ serverLabel: 'tool_router', serverUrl: mcpUrl, headers: { 'x-api-key': composioApiKey }, requireApproval: 'never', }), ], }); ``` ### 8. Start chat loop and handle conversation No description provided. ```python print("\nComposio Tool Router session created.") chat_session = SQLiteSession("conversation_openai_toolrouter") print("\nChat started. Type your requests below.") print("Commands: 'exit', 'quit', or 'q' to end\n") async def main(): try: result = await Runner.run( agent, "What can you help me with?", session=chat_session ) print(f"Assistant: {result.final_output}\n") except Exception as e: print(f"Error: {e}\n") while True: user_input = input("You: ").strip() if user_input.lower() in {"exit", "quit", "q"}: print("Goodbye!") break result = await Runner.run( agent, user_input, session=chat_session ) print(f"Assistant: {result.final_output}\n") asyncio.run(main()) ``` ```typescript // Keep conversation state across turns const conversationSession = new OpenAIConversationsSession(); // Simple CLI const rl = readline.createInterface({ input: process.stdin, output: process.stdout, prompt: 'You: ', }); console.log('\nComposio Tool Router session created.'); console.log('\nChat started. Type your requests below.'); console.log("Commands: 'exit', 'quit', or 'q' to end\n"); try { const first = await run(agent, 'What can you help me with?', { session: conversationSession }); console.log(`Assistant: ${first.finalOutput}\n`); } catch (e) { console.error('Error:', e instanceof Error ? e.message : e, '\n'); } rl.prompt(); rl.on('line', async (userInput) => { const text = userInput.trim(); if (['exit', 'quit', 'q'].includes(text.toLowerCase())) { console.log('Goodbye!'); rl.close(); process.exit(0); } if (!text) { rl.prompt(); return; } try { const result = await run(agent, text, { session: conversationSession }); console.log(`\nAssistant: ${result.finalOutput}\n`); } catch (e) { console.error('Error:', e instanceof Error ? e.message : e, '\n'); } rl.prompt(); }); rl.on('close', () => { console.log('\n👋 Session ended.'); process.exit(0); }); ``` ## Complete Code ```python import asyncio import os from dotenv import load_dotenv from composio import Composio from composio_openai_agents import OpenAIAgentsProvider from agents import Agent, Runner, HostedMCPTool, SQLiteSession load_dotenv() api_key = os.getenv("COMPOSIO_API_KEY") user_id = os.getenv("USER_ID") if not api_key: raise RuntimeError("COMPOSIO_API_KEY is not set. Create a .env file with COMPOSIO_API_KEY=your_key") # Initialize Composio composio = Composio(api_key=api_key, provider=OpenAIAgentsProvider()) # Create Tool Router session session = composio.create( user_id=user_id, toolkits=["crustdata"] ) mcp_url = session.mcp.url # Configure agent with MCP tool agent = Agent( name="Assistant", model="gpt-5", instructions=( "You are a helpful assistant that can access Crustdata. " "Help users perform Crustdata operations through natural language." ), tools=[ HostedMCPTool( tool_config={ "type": "mcp", "server_label": "tool_router", "server_url": mcp_url, "headers": {"x-api-key": api_key}, "require_approval": "never", } ) ], ) print("\nComposio Tool Router session created.") chat_session = SQLiteSession("conversation_openai_toolrouter") print("\nChat started. Type your requests below.") print("Commands: 'exit', 'quit', or 'q' to end\n") async def main(): try: result = await Runner.run( agent, "What can you help me with?", session=chat_session ) print(f"Assistant: {result.final_output}\n") except Exception as e: print(f"Error: {e}\n") while True: user_input = input("You: ").strip() if user_input.lower() in {"exit", "quit", "q"}: print("Goodbye!") break result = await Runner.run( agent, user_input, session=chat_session ) print(f"Assistant: {result.final_output}\n") asyncio.run(main()) ``` ```typescript import 'dotenv/config'; import { Composio } from '@composio/core'; import { OpenAIAgentsProvider } from '@composio/openai-agents'; import { Agent, hostedMcpTool, run, OpenAIConversationsSession } from '@openai/agents'; import * as readline from 'readline'; const composioApiKey = process.env.COMPOSIO_API_KEY; const userId = process.env.USER_ID; if (!composioApiKey) { throw new Error('COMPOSIO_API_KEY is not set. Create a .env file with COMPOSIO_API_KEY=your_key'); } if (!userId) { throw new Error('USER_ID is not set'); } // Initialize Composio const composio = new Composio({ apiKey: composioApiKey, provider: new OpenAIAgentsProvider(), }); async function main() { // Create Tool Router session const session = await composio.create(userId as string, { toolkits: ['crustdata'], }); const mcpUrl = session.mcp.url; // Configure agent with MCP tool const agent = new Agent({ name: 'Assistant', model: 'gpt-5', instructions: 'You are a helpful assistant that can access Crustdata. Help users perform Crustdata operations through natural language.', tools: [ hostedMcpTool({ serverLabel: 'tool_router', serverUrl: mcpUrl, headers: { 'x-api-key': composioApiKey }, requireApproval: 'never', }), ], }); // Keep conversation state across turns const conversationSession = new OpenAIConversationsSession(); // Simple CLI const rl = readline.createInterface({ input: process.stdin, output: process.stdout, prompt: 'You: ', }); console.log('\nComposio Tool Router session created.'); console.log('\nChat started. Type your requests below.'); console.log("Commands: 'exit', 'quit', or 'q' to end\n"); try { const first = await run(agent, 'What can you help me with?', { session: conversationSession }); console.log(`Assistant: ${first.finalOutput}\n`); } catch (e) { console.error('Error:', e instanceof Error ? e.message : e, '\n'); } rl.prompt(); rl.on('line', async (userInput) => { const text = userInput.trim(); if (['exit', 'quit', 'q'].includes(text.toLowerCase())) { console.log('Goodbye!'); rl.close(); process.exit(0); } if (!text) { rl.prompt(); return; } try { const result = await run(agent, text, { session: conversationSession }); console.log(`\nAssistant: ${result.finalOutput}\n`); } catch (e) { console.error('Error:', e instanceof Error ? e.message : e, '\n'); } rl.prompt(); }); rl.on('close', () => { console.log('\nSession ended.'); process.exit(0); }); } main().catch((err) => { console.error('Fatal error:', err); process.exit(1); }); ``` ## Conclusion This was a starter code for integrating Crustdata MCP with OpenAI Agents SDK to build a functional AI agent that can interact with Crustdata. Key features: - Hosted MCP tool integration through Composio's Tool Router - SQLite session persistence for conversation history - Simple async chat loop for interactive testing You can extend this by adding more toolkits, implementing custom business logic, or building a web interface around the agent. ## How to build Crustdata MCP Agent with another framework - [Claude Agent SDK](https://composio.dev/toolkits/crustdata/framework/claude-agents-sdk) - [Claude Code](https://composio.dev/toolkits/crustdata/framework/claude-code) - [Claude Cowork](https://composio.dev/toolkits/crustdata/framework/claude-cowork) - [Codex](https://composio.dev/toolkits/crustdata/framework/codex) - [OpenClaw](https://composio.dev/toolkits/crustdata/framework/openclaw) - [Hermes](https://composio.dev/toolkits/crustdata/framework/hermes-agent) - [CLI](https://composio.dev/toolkits/crustdata/framework/cli) - [Google ADK](https://composio.dev/toolkits/crustdata/framework/google-adk) - [LangChain](https://composio.dev/toolkits/crustdata/framework/langchain) - [Vercel AI SDK](https://composio.dev/toolkits/crustdata/framework/ai-sdk) - [Mastra AI](https://composio.dev/toolkits/crustdata/framework/mastra-ai) - [LlamaIndex](https://composio.dev/toolkits/crustdata/framework/llama-index) - [CrewAI](https://composio.dev/toolkits/crustdata/framework/crew-ai) ## Related Toolkits - [Reddit](https://composio.dev/toolkits/reddit) - Reddit is a social news platform with thriving user-driven communities (subreddits). It's the go-to place for discussion, content sharing, and viral marketing. - [Facebook](https://composio.dev/toolkits/facebook) - Facebook is a social media and advertising platform for businesses and creators. It helps you connect, share, and manage content across your public Facebook Pages. - [Linkedin](https://composio.dev/toolkits/linkedin) - LinkedIn is a professional networking platform for connecting, sharing content, and engaging with business opportunities. It's the go-to place for building your professional brand and unlocking new career connections. - [Active campaign](https://composio.dev/toolkits/active_campaign) - ActiveCampaign is a marketing automation and CRM platform for managing email campaigns, sales pipelines, and customer segmentation. It helps businesses engage customers and drive growth through smart automation and targeted outreach. - [ActiveTrail](https://composio.dev/toolkits/active_trail) - ActiveTrail is a user-friendly email marketing and automation platform. It helps you reach subscribers and automate campaigns with ease. - [Ahrefs](https://composio.dev/toolkits/ahrefs) - Ahrefs is an SEO and marketing platform for site audits, keyword research, and competitor insights. It helps you improve search rankings and drive organic traffic. - [Amcards](https://composio.dev/toolkits/amcards) - AMCards lets you create and mail personalized greeting cards online. Build stronger customer relationships with easy, automated card campaigns. - [Beamer](https://composio.dev/toolkits/beamer) - Beamer is a news and changelog platform for in-app announcements and feature updates. It helps companies boost user engagement by sharing news where users are most active. - [Benchmark email](https://composio.dev/toolkits/benchmark_email) - Benchmark Email is a platform for creating, sending, and tracking email campaigns. It's built to help you engage audiences and analyze results—all in one place. - [Bigmailer](https://composio.dev/toolkits/bigmailer) - BigMailer is an email marketing platform for managing multiple brands with white-labeling and automation. It helps teams streamline campaigns and simplify integration with Amazon SES. - [Brandfetch](https://composio.dev/toolkits/brandfetch) - Brandfetch is an API that delivers company logos, colors, and visual branding assets. It helps marketers and developers keep brand visuals consistent everywhere. - [Brevo](https://composio.dev/toolkits/brevo) - Brevo is an all-in-one email and SMS marketing platform for transactional messaging, automation, and CRM. It helps businesses engage customers and streamline communications through powerful campaign tools. - [Campayn](https://composio.dev/toolkits/campayn) - Campayn is an email marketing platform for creating, sending, and managing campaigns. It helps businesses engage contacts and grow audiences with easy-to-use tools. - [Cardly](https://composio.dev/toolkits/cardly) - Cardly is a platform for creating and sending personalized direct mail to customers. It helps businesses break through the digital clutter by getting real engagement via physical mailboxes. - [ClickSend](https://composio.dev/toolkits/clicksend) - ClickSend is a cloud-based SMS and email marketing platform for businesses. It streamlines communication by enabling quick message delivery and contact management. - [Curated](https://composio.dev/toolkits/curated) - Curated is a platform for collecting, curating, and publishing newsletters. It streamlines content aggregation and distribution for creators and teams. - [Customerio](https://composio.dev/toolkits/customerio) - Customer.io is a customer engagement platform for targeted messaging across email, SMS, and push. Easily automate, segment, and track communications with your audience. - [Cutt ly](https://composio.dev/toolkits/cutt_ly) - Cutt.ly is a URL shortening service for managing and analyzing links. Streamline your workflows with quick, trackable, and branded short URLs. - [Demio](https://composio.dev/toolkits/demio) - Demio is webinar software built for marketers, offering both live and automated sessions with interactive features. It helps teams engage audiences and optimize lead generation through detailed analytics. - [Doppler marketing automation](https://composio.dev/toolkits/doppler_marketing_automation) - Doppler marketing automation is a platform for creating, sending, and tracking email campaigns. It helps you automate marketing workflows and manage subscriber lists for better engagement. ## Frequently Asked Questions ### What are the differences in Tool Router MCP and Crustdata MCP? With a standalone Crustdata MCP server, the agents and LLMs can only access a fixed set of Crustdata tools tied to that server. However, with the Composio Tool Router, agents can dynamically load tools from Crustdata and many other apps based on the task at hand, all through a single MCP endpoint. ### Can I use Tool Router MCP with OpenAI Agents SDK? Yes, you can. OpenAI Agents SDK fully supports MCP integration. You get structured tool calling, message history handling, and model orchestration while Tool Router takes care of discovering and serving the right Crustdata tools. ### Can I manage the permissions and scopes for Crustdata while using Tool Router? Yes, absolutely. You can configure which Crustdata scopes and actions are allowed when connecting your account to Composio. You can also bring your own OAuth credentials or API configuration so you keep full control over what the agent can do. ### How safe is my data with Composio Tool Router? All sensitive data such as tokens, keys, and configuration is fully encrypted at rest and in transit. Composio is SOC 2 Type 2 compliant and follows strict security practices so your Crustdata data and credentials are handled as safely as possible. --- [See all toolkits](https://composio.dev/toolkits) · [Composio docs](https://docs.composio.dev/llms.txt)