# Understanding the Synqly Model

Synqly is a unified API for security and IT integrations. Your application connects to Synqly
once, and then works with the products your customers use, such as Jira, Slack, and Microsoft
Teams, through one consistent API. Synqly builds and maintains each integration, so your team
does not have to manage vendor-specific APIs, authentication, or data formats.

This page introduces the model behind that API: who owns which resources, how a request reaches a
Provider, and how access is controlled. Each concept has its own page if you want to go deeper.
This page is an overview, not a tutorial. To build your first integration step by step, see the
[Quick Start](/guides/getting-started/overview).

## The Synqly Data Model

Each of your customers can use a different product for the same job. In this example, Customers A, B, and C each use a different identity Provider. Your application sends all three the same Identity Connector request, and the token on that request tells Synqly which customer it belongs to. Synqly then passes the request to that customer's Integration, which calls their Provider.

To achieve this, Synqly needs:

- To know who owns what, so that each customer's data stays separate.
- A way of connecting to Providers so that many different Providers can sit behind a unified interface.
- Strong access controls, with separate tokens for setting things up and for making requests.


Let’s look at how Synqly handles each of these.

### Ownership and Tenancy

Before Synqly can route a request, it has to know which of your customers the request belongs to.

Everything you create in Synqly belongs to your **Organization**. Within your Organization, you create one **Account** for each of your customers, or tenants. An Account is an isolated space: the Integrations configured in it, and the data that flows through them, belong to that customer alone. An **Integration** is the connection to the Provider that customer uses, and each Integration belongs to exactly one Account.

```mermaid
flowchart TD
    org("Organization")
    acc("Accounts<br/><small>one per customer</small>")
    int("Integrations<br/><small>one per connected Provider</small>")

    org --> acc
    acc --> int
```

To learn more, see:

Organization
The root container that owns all Synqly resources and establishes the governance boundary.

Accounts
Synqly's representation of your customers, providing strict data isolation between tenants.

### Connecting to Providers

Your customers use many different providers, but your application does not have to learn each one. Synqly solves this by placing a few layers between your application and each provider, each with its own job.

At a high level, the model separates:

- What your application integrates with (**Connector**)
- How that integration is governed (**Integration Point**)
- Which Provider is actually connected (**Integration**)


This separation allows applications to integrate against a stable, unified interface while retaining the flexibility to connect different providers for different customers or environments.

```mermaid
flowchart TD
    conn("Connector<br/><small>Ticketing</small>")
    ip("Integration Point<br/><small>unified interface, allowed providers, shared configuration</small>")
    intA("Integration<br/><small>Customer A</small>")
    intB("Integration<br/><small>Customer B</small>")
    intC("Integration<br/><small>Customer C</small>")
    prov1("Provider<br/><small>Jira</small>")
    prov2("Provider<br/><small>ServiceNow</small>")
    prov3("Provider<br/><small>Zendesk</small>")

    conn --> ip
    ip --> intA & intB & intC
    intA --> prov1
    intB --> prov2
    intC --> prov3
```

To learn more, see:

Connectors
A unified API and data model abstracting a category of Providers, such as Ticketing or Identity.

Integration Points
Reusable rules defined once at the Organization level and applied across many Integrations.

Integrations
The live, authorized connection between an Account and a specific Provider.

Providers
Specific third-party platforms, such as Jira, Okta, Slack, and AWS, that Connectors expose.

### Access and Tokens

Setting up Integrations and using them are different kinds of work, and Synqly provides two distinct API layers to perform these actions:

- **Management APIs** for setup, such as creating Accounts and configuring Integration Points. This work is done by the **Members** of your Organization, which can be people or service accounts.
- **Connector APIs** are for the day-to-day work with Providers, such as fetching tickets or querying identity events.


Each layer accepts its own type of token:

| Token | API layer | Authority |
|  --- | --- | --- |
| **Organization Token** | Management | Broad or narrow: operates across the entire Organization or scoped to specific resources |
| **Integration Token** | Connectors | Narrow: scoped to a single Integration |


Synqly enforces this split at the platform level. An Integration Token cannot change your setup, and an Organization Token cannot call Connector APIs.

To learn more, see:

Organization Tokens
Authenticate calls to the Management APIs for administrative operations across an Organization.

Integration Tokens
Authenticate calls to the Connector APIs, scoped to a single Integration for runtime Provider access.

Members
Personal accounts and service accounts that act within an Organization.

Security Model
How permission sets, roles, and scoped tokens control what each token can do.

## Putting It All Together

Your Organization owns an Account for each customer. Each Account holds the Integrations that connect that customer to their Providers, shaped by the Integration Points you define. Two types of token keep setup and runtime apart.

In practice, an integration usually follows this lifecycle:

1. **Authenticate** to the Management APIs with an Organization Token.
2. **Create** an Account to represent a customer.
3. **Configure** an Integration in that Account for the customer's Provider.
4. **Generate** an Integration Token scoped to that Integration.
5. **Call** the Connector APIs with the Integration Token to work with the Provider.


```mermaid
flowchart TD
    product("Your Product")
    mgmt("Management APIs")
    conn("Connector APIs")
    accounts("Create Accounts & Integrations")
    providers("Interact with Providers")

    product -- "Organization Token" --> mgmt
    product -- "Integration Token" --> conn
    mgmt --> accounts
    conn --> providers
```

To walk through this lifecycle with real API calls, see the [Quick Start](/guides/getting-started/overview).