A Connector is Synqly's abstraction layer for a category of integrations. It provides a unified API, common data model, and consistent operational behavior across multiple providers that solve the same business problem.
| Connector | Example Providers |
|---|---|
| Identity | Okta, Microsoft Entra ID, OneLogin |
| Storage | Amazon S3, Azure Blob Storage, Google Cloud Storage |
| Messaging | Slack, Microsoft Teams, PagerDuty |
| Ticketing | Jira, ServiceNow, Zendesk |
For a full list of supported Connectors and Providers, see the Integration Partners page.
Providers within the same category often deliver similar business capabilities, but each exposes different APIs, authentication methods, schemas, and operational behaviors. Without a common abstraction, applications must build and maintain separate integrations for every provider, increasing development and maintenance complexity as provider support expands.
Connectors exist to decouple your application from provider-specific implementations.
Instead of integrating directly with Jira, ServiceNow, or Zendesk, your application integrates with the Ticketing Connector. Instead of learning the unique APIs of Okta and Microsoft Entra ID, your application works with the Identity Connector.
This shifts the integration model:
The Connector becomes the stable contract your application depends on. Synqly manages every provider-specific implementation detail behind it so adding a new provider never requires changes to your application code.
One of the primary benefits of the Connector model is stability.
Provider APIs evolve over time. New providers are introduced. Existing providers change authentication methods, add capabilities, or modify their schemas. When applications integrate directly with providers, each of these changes lands on your engineering team.
Connectors provide a stable interface that insulates your application from provider-specific change. You continue to call the same Connector API while Synqly absorbs the work of translating between your unified model and each provider's implementation.
Connectors provide a shared model across providers within the same category, allowing your application to reuse much of its integration logic across multiple providers.
This can significantly reduce the amount of provider-specific code required when adding support for new providers.
While Connectors provide a common interface, providers do not always support the same fields, filters, or operations. Synqly exposes provider capabilities so applications can understand what functionality is available.
A Connector defines what can be done within a category. An Integration defines which provider performs that work.
For example, an application may use the Ticketing Connector to create and retrieve tickets. One customer may configure an Integration to Jira, while another configures an Integration to ServiceNow. Both customers interact through the same Connector API, even though different providers execute the underlying operations.
Connectors
Define the common interface — the API your application codes against.
Providers
Supply the underlying functionality — the platform that does the actual work.
Integrations
Connect configuration, credentials, and an account to a specific provider.
Together, these three concepts let your application support many providers through a single, stable integration surface.