Skip to main content
Create an integration in superglue to connect tools with external systems. Integrations handle authentication and documentation retrieval automatically. Learn more about how integrations fit into the overall architecture in the core concepts section.

​
Getting started

  • Via Agent
  • Via UI
  • Via SDK
The fastest way to create an integration is through the agent interface. Visit app.superglue.cloud and start chatting with the agent.Example:
Create an integration to my ITSM platform under the URL:
https://my-company.itsm.com using the attached PDF as documentation
superglue will:
  1. Identify the target system
  2. Guide through the authentication flow by collecting all required credentials
  3. Create the integration and make it available immediately
  4. Process and analyze the system’s documentation automatically in the background

Start creating integrations with the agent

​
Authentication and credential management

superglue supports many different authentication methods. All credentials are encrypted both at rest and in transit.
superglue supports both the client credentials flow and authorization code flow with automatic token refresh.superglue handles:
  • Scope validation
  • Token exchange and storage
  • Error handling for token issues
  • Automatic token refresh during tool execution

​
Authorization code flow

Used when end users grant access to their account data.
  1. User clicks the “connect to provider” button
  2. Redirected to the provider’s login page
  3. User grants permissions for requested scopes
  4. superglue exchanges the authorization code for access tokens
  5. Tokens are automatically refreshed on expiration
Examples: Slack, Salesforce, Google Services

​
Client credentials flow

Used for server-to-server communication with no user interaction.
  1. Application requests an access token using client ID and secret
  2. Token is automatically refreshed before expiration
  3. No user consent required
Examples: Twilio, Auth0 Management API, Microsoft Graph

​
Configuration example

await superglue.upsertIntegration({
  id: "custom-oauth",
  urlHost: "https://api.example.com",
  documentationUrl: "https://docs.example.com/quickstart",
  credentials: {
    clientId: "your_client_id",
    clientSecret: "your_client_secret",
    authorizationUrl: "https://auth.example.com/oauth/authorize",
    tokenUrl: "https://auth.example.com/oauth/token",
    scopes: "read:users write:data",
  }
});
Required fields:
  • clientId, clientSecret, authorizationUrl, tokenUrl
Optional fields:
  • scopes: space-separated OAuth scopes
  • redirectUri: redirect URL after authorization
Prebuilt OAuth templates are available for 100+ APIs including HubSpot, Google Ads, and Salesforce. Check the templates dropdown in the creation form.
The simplest authentication method. Provide an API key and superglue automatically determines where to include it based on the API’s documentation.Possible placements:
  • Authorization header: Authorization: Bearer {key}
  • Custom header: X-API-Key: {key}
  • Query parameter: ?api_key={key}

​
Examples

  • SendGrid
  • Airtable
  • Zendesk
  • Shopify
  • Mailchimp
await superglue.upsertIntegration({
  id: "sendgrid",
  urlHost: "https://api.sendgrid.com",
  documentationUrl: "https://docs.sendgrid.com/api-reference",
  credentials: {
    apiKey: "SG.xxx..."
  }
});
SendGrid requires the API key in a custom Authorization header with Bearer prefix.
Connect to databases by providing connection details. Supported types include PostgreSQL and FTP/SFTP servers.

​
Configuration

  • PostgreSQL
  • FTP/SFTP
await superglue.upsertIntegration({
  id: "main-db",
  urlHost: "postgresql://<<user>>:<<password>>@<<host>>:<<port>>",
  urlPath: "/<<database>>",
  credentials: {
    user: "db_user",
    password: "db_password",
    host: "db.example.com",
    port: 5432,
    database: "production_db"
  }
});
For systems with unique authentication requirements, superglue supports multiple custom patterns.
  • Basic Auth
  • Custom Headers
  • JWT/Bearer Tokens
  • Bot Token
credentials: {
  username: "your_username",
  password: "your_password"
}
Used by: Jenkins, Artifactory, legacy APIs

Security first

All secrets are encrypted at rest and in transit. The LLM never accesses real credentials - only placeholders such as <<stripe_api_key>> are exposed during workflow setup and execution.

Not ready to provide credentials?

Integrations can be created without credentials and updated later. Credentials may also be supplied dynamically during tool execution.

Need help identifying credentials?

The agent can assist with figuring out which credentials are required and where to find them. e.g., “I want to connect to my company’s internal API but I’m not sure what authentication it uses.”

​
Automatic documentation crawling

superglue automatically crawls and processes documentation upon integration creation. This makes it possible for superglue to reason about endpoints, authentication, and data models without manual setup. When creating an integration, the documentationUrl or uploaded documentation files (like OpenAPI specs, PDFs, or HTML exports) are used as the primary source for this process. The more complete and accurate the provided material, the better superglue’s internal understanding of the system.

​
Supported documentation formats

superglue’s fetchers handle most modern and legacy documentation types:

OpenAPI/Swagger

Extracts endpoints, parameters, and schemas from .json or .yaml specifications.

Mintlify & modern docs

Fetches content from popular hosted sites like Mintlify, ReadMe, or Docusaurus.

Static HTML & PDFs

Parses legacy or self-hosted documentation, including HTML exports and PDF manuals.

Database schemas

Automatically analyzes PostgreSQL and MySQL schemas to identify tables, columns, and relationships.

​
Documentation filtering with keywords

Large APIs can have hundreds of endpoints. To improve accuracy and reduce processing time, you can provide specific keywords vai the agent or SDK that describe what parts of the documentation are most relevant.
  • Via Chat/Agent
  • Via SDK
The agent automatically adjusts documentation processing based on your instructions:
Connect to Stripe and focus on customer and subscription endpoints
This ensures that only relevant documentation is processed and saved to the integration.

​
Next steps

Ready to create your first integration?

Go to superglue and start connecting your APIs, databases, and systems in minutes.