# Nango MCP > Nango provides a unified API layer for managing complex product integrations. Your agent connects to Nango to audit OAuth connections across hundreds of providers, track real-time data sync status, and access synchronized records from multiple external sources without touching a dashboard. ## Overview - **Category:** friends-mcp - **Price:** Free - **Tags:** api-integration, oauth, data-synchronization, unified-api, connection-management ## Description Look, you're running complex integrations across a bunch of providers, and manually checking everything? Forget about it. Nango gives your agent an API layer to handle the whole mess—auditing OAuth connections, tracking data sync status, and pulling records from multiple sources without you ever having to touch a dashboard. You connect this server, and suddenly your AI client can talk directly to your integration backend. When you need to check specific connection details, you'll use `get_connection` to pull the metadata for an individual Nango link; that gives you the authentication payload and exactly where the tokens start and stop. If you gotta see every single connection linked up—whether it's OAuth or just a set of credentials—you hit `list_connections` to get a full roster of everything authenticated through Nango. You can also check out all the available integration logic configurations in your platform by running `list_integrations`; that tells you what kinds of data connections Nango supports. To monitor how well everything's working, you use `list_syncs`. This tool gives you a record—current or historical—of whether an account connection actually synced its data and if there were any issues. If you need to see the actual records that got synchronized, say contacts or deals, for a specific provider mapping across your whole connected pool, you run `list_records` and get those unified entries right away. You can pull the runtime mapping logic boundaries for the active Nango instance environment using `get_environment`; this shows you exactly how Nango is set up to manage data flow. Finally, if you need more granular info about a specific target integration's configuration—like pulling out explicit parameters or setup details—you call `get_integration`. Here's the deal with getting your agent connected: You subscribe to this server on Vinkius and drop in your Nango Secret Key. After that, your AI client can manage everything. Your agent pulls every data point you need using these tools, letting you bypass any clunky dashboards. For example, if you wanna know what kind of connections are available, `list_connections` shows it all. If you gotta audit the setup, `get_environment` reveals the mapping logic boundaries. You can review the history and status of syncs with `list_syncs`, or pull concrete records using `list_records`. It's a clean way to keep tabs on hundreds of providers without writing a single line of code. ## Tools ### list_integrations Lists all available integration logic configurations defined within the Nango platform. ### get_integration Pulls explicit parameters detailing a single target integration's configuration logic. ### list_connections Lists all instantiated OAuth or credential connections that have been authenticated through Nango. ### get_connection Gets specific metadata detailing a single Nango connection's authentication payload and token boundaries. ### list_syncs Provides a list of the current or historical synchronization status for an account connection. ### list_records Lists actual data records that have been successfully synchronized and match a connected provider mapping. ### get_environment Retrieves the runtime mapping logic bounds for the active Nango instance environment. ## Prompt Examples **Prompt:** ``` List all active Salesforce connections in Nango ``` **Response:** ``` I've retrieved 12 Salesforce connections. 10 are 'Verified', while 2 (ID: conn-abc, conn-xyz) are currently 'Expired' or 'Invalid'. Would you like me to check the sync status for the verified connections? ``` **Prompt:** ``` Show me the last 5 sync logs for connection ID 'conn-123' ``` **Response:** ``` Retrieving sync history… I've identified the 5 most recent syncs for 'conn-123': 4 succeeded (Syncing 'deals'), and 1 'Failed' 2 hours ago with a 'Rate Limit' error. I can provide the detailed error metadata if you'd like. ``` **Prompt:** ``` Fetch the synchronized 'contacts' records for connection 'conn-456' ``` **Response:** ``` Executing record extraction… I've retrieved 50 contact records from Nango's unified storage for connection 'conn-456'. Highlights include 'Alex Smith' (id: 987) and 'Sarah Johnson' (id: 654). Would you like to see the full JSON mapping for these records? ``` ## Capabilities ### Check connection status and details Use `get_connection` to extract specific metadata for an individual Nango connection. ### List all connected accounts Use `list_connections` to get a list of every OAuth or credential-based account linked through Nango. ### Review sync history and status Use `list_syncs` to see the current or historical synchronization status for any given connection. ### Fetch synchronized data records Use `list_records` to retrieve actual, unified data entries (like contacts) matched against a specific provider. ### List available integration logics Use `list_integrations` to see all the different types of integration logic set up in Nango. ### Get environment configuration details Use `get_environment` to pull the literal runtime mapping boundaries for the active Nango instance. ## Use Cases ### Onboarding Audit: Checking Client Access A Product Manager needs to confirm if three key enterprise clients (Salesforce, HubSpot, Jira) are all connected and healthy. Instead of logging into three separate vendor dashboards, they ask their agent: 'List active connections for our top 5 clients.' The agent uses `list_connections` and reports back the status of every single account in one reply. ### Debugging a Data Gap An Integration Lead notices that recent deal records are missing. They ask the agent to 'Show me sync logs for deals related to connection ID conn-abc.' The agent uses `list_syncs`, identifies a failed job, and then can use `get_environment` to check if the mapping logic itself changed. ### Schema Verification A Software Developer needs to build a new feature relying on contact data. They ask: 'What are the synchronized contacts for connection conn-456?' The agent uses `list_records`, pulling 50 records and verifying that the structure (schema) matches what their code expects, without manual SQL queries. ### Pre-Deployment Check Before launching a major feature update, an Integration Lead must confirm all integration logic is correct. They use `list_integrations` to review the setup parameters and then ask for 'the connection metadata' using `get_integration` to ensure every piece of the puzzle is accounted for. ## Benefits - Use `list_connections` to see all connected accounts instantly. You don't have to click through dozens of vendor dashboards just to check if a client's Salesforce connection is active or expired. - The `list_syncs` tool tracks sync history and status, so you can pinpoint exactly when and why data failed to transfer—whether it was a rate limit error or invalid credentials. No more guessing games. - When debugging schemas, the combination of `list_integrations` and `get_environment` lets you inspect the full mapping logic and runtime constraints without needing developer access to the core Nango platform. - Need actual data? Instead of viewing abstract records, `list_records` pulls unified data (like contacts or deals) from all linked providers into one view. It’s instant, consolidated visibility. - `get_connection` provides a deep credential audit. You can verify the exact metadata and token boundaries for any specific connection, which is critical for compliance checks. ## How It Works The bottom line is that you manage complex data pipelines and vendor integrations by talking to them instead of clicking through multiple dashboards. 1. Subscribe to this server and enter your unique Nango Secret Key. 2. Connect your preferred AI client (Claude, Cursor, etc.) through the MCP protocol. 3. Ask your agent to perform an action—for example, 'Show me all expired Salesforce connections'—and receive the results directly in conversation. ## Frequently Asked Questions **How do I check if a client's OAuth connection is expired using list_connections?** The `list_connections` tool lists all instantiated connections. The output for each connection includes its current status (e.g., 'Verified,' 'Expired'). This allows you to quickly filter and identify which accounts need re-authentication. **Can I use get_connection to see the specific data fields that were synced?** Yes, `get_connection` provides precise metadata mapping. It details the authentication payloads and token boundaries for a given connection ID, which confirms exactly what credentials are being used. **What is the difference between list_records and list_connections?** They track different things entirely. `list_connections` tells you if the *account* (the user's system) is linked to Nango. `list_records` shows the actual, synchronized *data* (like 50 contact records) that were pulled from that linked account. **How do I check for data synchronization failures with list_syncs?** The `list_syncs` tool gives you the history and current status of automated sync jobs. You can identify failed attempts, see the error type (like 'Rate Limit'), and determine if the failure is systemic or temporary. **Does get_environment tell me anything about my API key?** `get_environment` retrieves the runtime mapping logic bounds for the Nango instance. While it gives you architectural context, use `get_connection` if you need details specific to a connection's authentication payload. **How does `get_integration` help me understand required sync parameters?** It retrieves explicit, mandatory parameters for a single integration. This output shows exactly what data fields and connection settings Nango requires from that specific provider to run the sync successfully. It's essential for initial setup validation. **Can I use `list_records` to discover all available model types (like 'deals' or 'contacts')?** Yes, you specify the record type you want to check. Nango organizes data into specific models; by using this tool, your agent can filter and confirm if a certain model—say, 'invoices'—has any synchronized records associated with it. **What does `get_environment` tell me about connection capacity or limits?** It reports the operational boundaries for your active Nango instance. This provides visibility into current host constraints and system quotas, letting you know if performance issues stem from hitting a predefined limit. **Can I see which customers have an expired OAuth connection through my agent?** Yes. Use the `list_connections` tool to retrieve all authenticated linked accounts. Your agent will report the current status of each connection, helping you identify which users need to re-authenticate their external platforms. **How do I check if a data synchronization failed recently?** The `list_syncs` tool retrieves the synchronization history for a specific connection. Your agent will expose the log outputs and status indicators, allowing you to debug data processing issues directly from your conversation. **Can my agent retrieve synchronized data records from external APIs?** Absolutely. Use the `list_records` tool with a Connection ID and a model name (e.g., 'contacts'). Your agent will query Nango's storage to fetch the raw synchronized objects, bypassing external API limits natively.