In the ever-evolving landscape of API integration, developers constantly face challenges with changing schemas, inadequate documentation, and data validation. Superglue, a new API connector tool that writes its own code, has sparked significant discussion in the developer community about how it addresses these common pain points.
Self-Healing Schema Adaptation
One of the most discussed features of Superglue is its ability to handle API schema changes automatically. When APIs evolve or update their response formats, Superglue detects mismatches between the expected schema and actual responses at runtime. Instead of breaking, the system regenerates the JSONata expressions that transform the data, effectively healing the integration without developer intervention. This capability is particularly valuable for applications making frequent API calls where downtime due to schema changes could be problematic.
We get the data from the source and apply the jsonata (that's very fast). We then validate the result against the json schema that you gave us. If it doesn't match, e.g. because the source changed or a required field is missing, we rerun the jsonata generation and try to fix it.
LLM-Powered Integration Without Documentation
Developers frequently highlighted the common problem of working with poorly documented APIs. Superglue approaches this challenge by leveraging large language models to analyze whatever context is available about an API, even if formal documentation is missing or outdated. The tool's creators describe their benchmark as the intern test - if an average college student could figure out the API with enough time and effort, then their LLM approach should be able to succeed as well. This capability significantly reduces the friction of integrating with less-than-ideal API sources.
Validation and Hallucination Prevention
The community discussion revealed significant interest in how Superglue handles LLM hallucinations and ensures data accuracy. The system employs a three-pronged approach to validation: direct validation by checking if generated JSONata expressions produce schema-compliant results, using reasoning models like o3-mini for improved accuracy, and implementing confidence scores to handle ambiguous mapping scenarios. These measures help ensure that the automatically generated code produces reliable and consistent results.
Key Features of Superglue
- Automatic API configuration generation from documentation
- Self-healing schema adaptation for API changes
- Pagination, authentication, and error retry handling
- Response data transformation using JSONata expressions
- Schema validation with automatic transformation fixes
- Available as hosted service or self-hosted Docker container
Validation Approach
- Direct validation: Testing generated JSONata against expected schema
- Reasoning model: Using o3-mini for improved mapping accuracy
- Confidence scoring: Indicating certainty levels for ambiguous mappings
Use Cases and Alternatives
Developers in the discussion explored various use cases where Superglue offers advantages over simply using an LLM to generate integration code directly. The tool's value proposition centers on abstracting away complexity like pagination and format conversion, providing self-healing capabilities, and offering centralized management for multiple API integrations. Some community members also expressed interest in extending similar functionality to HTML data extraction, suggesting potential future applications beyond traditional API integration.
While Superglue currently focuses on API integration, the community discussion highlighted interest in potential future applications, including schema change notifications and browser-based structured data extraction from websites. These discussions point to the growing demand for intelligent, adaptive tools that can reduce the maintenance burden of data integration across the modern web ecosystem.
Reference: Superglue: API Connector That Writes Its Own Code