Superglue - AI Integration Platform for Any API

TL;DR

TL;DR: Superglue is an open-source AI integration platform (YC W25) that turns natural language descriptions into production-grade API workflows, with built-in schema drift detection, MCP support, and compatibility with everything from modern REST APIs to legacy SOAP services.

Source and Accuracy Notes

• Official site: superglue.cloud
• GitHub: superglue-ai/superglue (2,000+ stars, TypeScript)
• Docs: docs.superglue.cloud
• HN discussion: Show HN: A CLI that writes its own integration code

What Is Superglue?

Superglue is an AI-native integration platform that lets you describe what you want in plain English and get a working, deployed API workflow in seconds. Instead of writing boilerplate connector code for every API you need to talk to, you tell Superglue what to do and it handles the rest: authentication, pagination, rate limiting, schema mapping, and error recovery.

The project was born from a common frustration in the AI agent space. Teams building agents found that their users could perfectly describe what they wanted: “pull these three objects from Salesforce and push to nCino when X condition is true.” But translating that intent into working integration code still required days of engineering per API. Superglue eliminates that gap.

The founders, Adina Goerres and Stefan Faistenauer, are Y Combinator W25 alumni. The core platform is open-source under GPL, with MIT-licensed client SDKs.

How It Works

Step 1: Describe Your Workflow in Natural Language

You provide a plain-English instruction along with the systems you want to connect. Superglue parses the instruction, discovers the relevant API endpoints, and generates a workflow definition.

import { SuperglueClient } from "@superglue/client";

const superglue = new SuperglueClient({
  apiKey: "your-api-key"
});

const workflow = await superglue.buildWorkflow({
  instruction: "Get all customers from Stripe who paid over $1000 and create contacts in HubSpot",
  systems: [
    {
      id: "stripe",
      urlHost: "https://api.stripe.com",
      urlPath: "/v1",
      documentationUrl: "https://stripe.com/docs/api"
    },
    {
      id: "hubspot",
      urlHost: "https://api.hubapi.com",
      documentationUrl: "https://developers.hubspot.com/docs/api/overview"
    }
  ]
});

Step 2: Execute with Credentials

Once the workflow is built, you execute it with your API credentials. Superglue handles the orchestration:

const result = await superglue.executeWorkflow({
  workflow: workflow,
  credentials: {
    stripe_api_key: "sk_xxx",
    hubspot_api_key: "pat_xxx"
  }
});

console.log(JSON.stringify(result, null, 2));

Step 3: Connect via MCP (Optional)

Superglue ships an MCP server, so you can connect it directly to Cursor, Claude Desktop, or any MCP-compatible tool. Once configured, you can trigger integrations from your AI assistant with natural language:

{
  "mcpServers": {
    "superglue": {
      "command": "npx",
      "args": ["@superglue/mcp-server"],
      "env": {
        "SUPERGLUE_API_KEY": "your-api-key"
      }
    }
  }
}

Then just say: “Create a workflow to sync Salesforce leads to Stripe customers.”

Deeper Analysis

Schema Drift Detection

The standout feature is automatic schema drift handling. APIs change: fields get renamed, response structures shift, new required parameters appear. Traditional integration code breaks silently or throws errors that require manual fixes.

Superglue monitors API responses and automatically adapts connectors when schemas change. If an endpoint renames a field or restructures its response, Superglue detects the drift and remaps the workflow without human intervention. This is what the team means by “workflows never break.”

Legacy API Support

Most integration tools focus on modern REST APIs. Superglue explicitly targets the long tail: SOAP services from 2003, proprietary enterprise APIs with XML payloads, GraphQL endpoints with complex nested schemas. The AI layer handles the translation between these formats and your workflow’s expected input/output structure.

The CLI Story

The HN launch post described a concrete use case: a YC founder’s customers wanted to create Salesforce Opportunities from inside her app’s chat interface. Instead of building a custom Salesforce connector, she used Superglue’s CLI to describe the integration in natural language. The CLI generated the workflow code, which she deployed and her customers started using immediately.

This pattern: user describes intent, CLI generates integration, deploy and forget: is the core value proposition.

Practical Evaluation Checklist

• GitHub stars: 2,000+ (TypeScript, active development)
• License: GPL for core platform, MIT for client SDKs
• Deployment options: Hosted SaaS, Docker self-hosted, private cloud/on-premises
• MCP support: Yes, via @superglue/mcp-server
• SDK: @superglue/client for JS/TS
• API formats: REST, GraphQL, SOAP, XML, JSON
• Auth support: OAuth, API keys, complex auth flows
• YC batch: W25
• Team: Adina Goerres, Stefan Faistenauer

Security Notes

• API credentials are passed at execution time, not stored in workflow definitions
• EU-based hosting available for compliance with EU Data Act
• SOC 2 and ISO 27001 compliance for enterprise deployments
• Self-hosted option keeps all data within your infrastructure
• The GPL license means derivative works must also be open-source; the MIT-licensed SDKs have no such restriction

FAQ

Q: How is Superglue different from Zapier or n8n?

A: Zapier and n8n are no-code automation tools with pre-built connectors for popular SaaS apps. Superglue is AI-native: you describe integrations in natural language rather than configuring them through a UI. It also handles schema drift automatically, supports legacy SOAP APIs, and is designed specifically for AI agent workflows rather than human-triggered automations.

Q: Can I self-host Superglue?

A: Yes. Superglue offers Docker-based self-hosting via superglueai/superglue on Docker Hub, plus private cloud and on-premises deployment options for enterprise customers. The core platform is open-source under GPL.

Q: What happens when an API changes its response format?

A: Superglue has built-in schema drift detection. It monitors API responses and automatically remaps fields when structures change. Workflows adapt without manual intervention, which is the main advantage over traditional integration code that breaks silently.

Q: Does Superglue work with AI coding agents like Cursor or Claude?

A: Yes. Superglue provides an MCP server (@superglue/mcp-server) that connects to Cursor, Claude Desktop, and any MCP-compatible tool. Once configured, you can trigger and manage integrations directly from your AI assistant using natural language.

Q: Is Superglue free to use?

A: The core platform is open-source (GPL) and can be self-hosted for free. The hosted SaaS version at app.superglue.cloud has a free tier with paid plans for higher usage. Enterprise deployments with private cloud support are available separately.

Conclusion

Superglue addresses a real pain point in the AI agent ecosystem: the integration layer. As more teams build agents that need to talk to multiple APIs, the traditional approach of writing custom connector code for each system becomes a bottleneck. Superglue’s natural-language-to-workflow approach, combined with automatic schema drift handling and MCP integration, makes it a compelling option for teams building AI-powered integrations.

The 2,000 GitHub stars and YC W25 backing suggest growing traction. The GPL license may be a consideration for commercial users, but the MIT-licensed SDKs and self-hosting options provide flexibility. Worth watching as the AI integration space matures.