# Connectors

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](https://www.synqly.com/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.

## Why Connectors Exist

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:

Before: Direct Integrations

```mermaid
flowchart TD
    app(Application)
    jira(Jira Integration)
    snow(ServiceNow Integration)
    zen(Zendesk Integration)

    app --> jira & snow & zen
```

After: With Connectors

```mermaid
flowchart TD
    app(Application)
    conn(Ticketing Connector)
    jira(Jira)
    snow(ServiceNow)
    zen(Zendesk)

    app --> conn
    conn --> jira & snow & zen
```

The Connector contract
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.

## Connectors as a Stability Layer

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.

Your code stays the same
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 as an Interoperability Layer

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.

Provider capabilities may vary
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.

## Connectors, Providers, and Integrations

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.