---
title: "Konektor Linear"
description: "Kompletny przewodnik integracji Linear do synchronizacji zgłoszeń, projektów i danych aktywności zespołu z Brevo przez Tajo."
url: https://tajo.io/pl/docs/connectors/custom/linear/
markdown: https://tajo.io/pl/docs/connectors/custom/linear.md
lang: pl-PL
robots: noindex
---

Poproś o wcześniejszy dostęp

Podaj imię i firmowy adres e-mail. Wyślemy Ci link potwierdzający prośbę o dostęp do Tajo.

# Konektor Linear

Status konektora: Planowany Jeszcze niezbudowany. Tajo nie uruchamia dziś tego konektora.

| Pole źródłowe | Pole docelowe | Przykładowa wartość |
| --- | --- | --- |
| `record.id` | `source_id` | `record_1042` |
| `record.updated_at` | `updated_at` | `2026-10-18T08:00:00Z` |
| `record.value` | `value` | `sample_value` |

Połącz swój workspace Linear z Brevo, aby śledzić zgłoszenia skierowane do klientów, wysyłać powiadomienia o aktualizacjach produktu i prowadzić kampanie o kamieniach milowych deweloperskich przez Tajo.

## Przegląd

| Właściwość | Wartość |
| --- | --- |
| **Platforma** | Linear |
| **Kategoria** | Niestandardowa |
| **Poziom konfiguracji** | Łatwy |
| **Integracja oficjalna** | Nie |
| **Synchronizowane dane** | Zgłoszenia, Projekty, Użytkownicy, Zdarzenia |
| **Typ API** | GraphQL API |
| **Uwierzytelnianie** | OAuth 2.0 / Personal API Key |
| **Bazowy URL** | `https://api.linear.app/graphql` |

## Funkcje

- **Synchronizacja zdarzeń zgłoszeń** - Przekazuj zdarzenia tworzenia, aktualizacji i ukończenia zgłoszeń do osi czasu kontaktów Brevo
- **Śledzenie kamieni milowych projektu** - Wyzwalaj kampanie Brevo, gdy projekty osiągają kluczowe kamienie milowe
- **Łączenie zgłoszeń z klientami** - Powiązuj zgłoszenia Linear z kontaktami Brevo dla widoczności wsparcia
- **Segmentacja oparta na etykietach** - Mapuj etykiety Linear na atrybuty kontaktów Brevo
- **Analityka cykli** - Synchronizuj dane ukończenia sprintów/cykli dla raportowania wydajności zespołu
- **Automatyzacja sterowana webhookami** - Przekazywanie zdarzeń w czasie rzeczywistym przez webhooki Linear

## Wymagania wstępne

Zanim zaczniesz, upewnij się, że masz:

1. Workspace Linear z dostępem administratora
2. Skonfigurowany Personal API key lub aplikację OAuth
3. Konto Brevo z dostępem do API
4. Konto Tajo z aktywną subskrypcją

## Uwierzytelnianie

Linear obsługuje Personal API keys i OAuth 2.0.

### Opcja 1: Personal API Key

1. Przejdź do **Linear** > **Settings** > **API** > **Personal API keys**
2. Kliknij **Create key**
3. Nazwij go „Tajo Integration”
4. Skopiuj wygenerowany klucz (zaczyna się od `lin_api_`)

```bash
curl -X POST https://api.linear.app/graphql \
  -H "Authorization: $LINEAR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "{ viewer { id name email } }"}'
```

### Opcja 2: OAuth 2.0

Dla integracji obsługujących wiele workspace’ów:

1. Utwórz aplikację OAuth na [linear.app/settings/api/applications](https://linear.app/settings/api/applications)
2. Skonfiguruj URI przekierowania: `https://app.tajo.io/callbacks/linear`
3. Zażądaj zakresów: `read`, `write`, `issues:create`, `comments:create`

GraphQL API

Linear używa wyłącznie GraphQL API. Wszystkie zapytania i mutacje przechodzą przez jeden endpoint: `https://api.linear.app/graphql`. Tajo obsługuje automatycznie całą konstrukcję zapytań GraphQL.

### Połączenie z Tajo

```bash
# Using Personal API Key
tajo connectors install linear \
  --api-key $LINEAR_API_KEY

# Using OAuth
tajo connectors install linear \
  --client-id $LINEAR_CLIENT_ID \
  --client-secret $LINEAR_CLIENT_SECRET
```

## Konfiguracja

### Podstawowa konfiguracja

```yaml
connectors:
  linear:
    enabled: true

    sync:
      issues: true
      projects: true
      cycles: true
      users: true

    teams:
      - key: "ENG"
        sync_to_list: 38
      - key: "SUPPORT"
        sync_to_list: 39

    issue_states:
      - Backlog
      - Todo
      - "In Progress"
      - Done
      - Canceled
```

### Mapowanie pól

Mapuj dane użytkowników i zgłoszeń Linear na atrybuty Brevo:

```yaml
field_mapping:
  # User fields
  id: LINEAR_USER_ID
  email: email
  name: FIRSTNAME

  # Issue metrics mapped to contact events
  last_issue_identifier: LAST_LINEAR_ISSUE
  last_issue_state: LAST_ISSUE_STATUS
  last_issue_priority: LAST_ISSUE_PRIORITY
  total_issues: LINEAR_ISSUE_COUNT

  # Project data
  current_project: ACTIVE_PROJECT
  team_key: LINEAR_TEAM
```

### Mapowanie zdarzeń

```yaml
event_mapping:
  Issue.create: ISSUE_CREATED
  Issue.update: ISSUE_UPDATED
  Issue.remove: ISSUE_DELETED
  Comment.create: COMMENT_ADDED
  Project.update: PROJECT_UPDATED
  Cycle.update: CYCLE_UPDATED
```

## Endpointy API

Linear używa jednego endpointu GraphQL. Kluczowe zapytania i mutacje używane przez Tajo:

| Operacja | Typ | Cel |
| --- | --- | --- |
| `issues` | Zapytanie | Lista i filtrowanie zgłoszeń |
| `issue` | Zapytanie | Pobierz pojedyncze zgłoszenie po ID |
| `projects` | Zapytanie | Lista wszystkich projektów |
| `cycles` | Zapytanie | Lista cykli (sprintów) |
| `teams` | Zapytanie | Lista zespołów workspace |
| `users` | Zapytanie | Lista członków workspace |
| `viewer` | Zapytanie | Pobierz informacje o uwierzytelnionym użytkowniku |
| `issueCreate` | Mutacja | Utwórz nowe zgłoszenie |
| `issueUpdate` | Mutacja | Aktualizuj istniejące zgłoszenie |
| `commentCreate` | Mutacja | Dodaj komentarz do zgłoszenia |
| `webhookCreate` | Mutacja | Zarejestruj webhook |

### Przykładowe zapytanie GraphQL

```graphql
query GetIssues($filter: IssueFilter, $first: Int, $after: String) {
  issues(filter: $filter, first: $first, after: $after) {
    nodes {
      id
      identifier
      title
      state { name }
      priority
      assignee { email name }
      labels { nodes { name } }
      createdAt
      updatedAt
    }
    pageInfo {
      hasNextPage
      endCursor
    }
  }
}
```

## Przykłady kodu

### Inicjalizacja konektora

```javascript
import { TajoClient } from '@tajo/sdk';

const tajo = new TajoClient({
  apiKey: process.env.TAJO_API_KEY,
  brevoApiKey: process.env.BREVO_API_KEY
});

await tajo.connectors.connect('linear', {
  apiKey: process.env.LINEAR_API_KEY
});
```

### Synchronizuj zgłoszenia

```javascript
await tajo.connectors.sync('linear', {
  type: 'incremental',
  resources: ['issues'],
  teams: ['ENG', 'SUPPORT'],
  since: '2024-01-01'
});

const status = await tajo.connectors.status('linear');
console.log(status);
// {
//   connected: true,
//   lastSync: '2024-03-15T18:00:00Z',
//   issuesTracked: 3200,
//   projectsMonitored: 8,
//   usersLinked: 45
// }
```

### Obsługa webhooków Linear

```javascript
app.post('/webhooks/linear', async (req, res) => {
  const event = req.body;

  // Verify webhook signature
  const signature = req.get('Linear-Signature');
  if (!verifyLinearSignature(req.body, signature)) {
    return res.status(401).send('Unauthorized');
  }

  await tajo.connectors.handleWebhook('linear', {
    type: event.type,
    action: event.action,
    payload: {
      issueId: event.data?.id,
      identifier: event.data?.identifier,
      title: event.data?.title,
      state: event.data?.state?.name,
      assigneeEmail: event.data?.assignee?.email
    }
  });

  res.status(200).send('OK');
});
```

### Utwórz zgłoszenie ze zdarzenia Brevo

```javascript
// Create a Linear issue when a Brevo contact submits a request
tajo.events.on('contact.event', async (event) => {
  if (event.name === 'FEATURE_REQUEST') {
    await tajo.connectors.create('linear', {
      teamId: 'ENG',
      title: `Feature Request: ${event.data.subject}`,
      description: event.data.description,
      priority: 3,
      labelIds: ['feature-request']
    });
  }
});
```

## Limity API

Linear stosuje limity szybkości na GraphQL API:

| Typ limitu | Wartość |
| --- | --- |
| **Szybkość żądań** | 1 500 żądań na godzinę na klucz API |
| **Złożoność zapytania** | 10 000 punktów złożoności na żądanie |
| **Paginacja** | Maks. 250 węzłów na stronę (domyślnie 50) |
| **Webhooki** | Nieograniczone przychodzące zdarzenia |

Budżet złożoności

Linear używa systemu ograniczania szybkości opartego na złożoności. Proste zapytania kosztują mniej punktów. Tajo optymalizuje zapytania, aby zminimalizować złożoność, żądając tylko potrzebnych pól i używając efektywnej paginacji.

Linear zwraca `429 Too Many Requests` z nagłówkiem `Retry-After` po przekroczeniu limitów.

## Rozwiązywanie problemów

### Typowe problemy

| Problem | Przyczyna | Rozwiązanie |
| --- | --- | --- |
| 401 Unauthorized | Nieprawidłowy lub odwołany klucz API | Wygeneruj nowy klucz API w Linear Settings |
| Błędy zapytania | Nieprawidłowa składnia GraphQL | Waliduj zapytania używając eksploratora API Linear |
| Brakujące zgłoszenia | Ograniczony dostęp do zespołu | Upewnij się, że właściciel klucza API ma dostęp do docelowych zespołów |
| Webhook nie odpala | Nieprawidłowy URL lub wyłączony | Sprawdź status webhooka w Linear Settings > API > Webhooks |
| Niepełna paginacja | Brakujący kursor `after` | Upewnij się, że pętla paginacji działa do czasu, gdy `hasNextPage` jest false |

### Tryb debug

```yaml
connectors:
  linear:
    debug: true
    log_level: verbose
    log_queries: true
```

### Test połączenia

```bash
tajo connectors test linear
# ✓ GraphQL API connection successful
# ✓ Workspace access verified
# ✓ Team list readable
# ✓ Issue query operational
# ✓ Webhook registration available
```

## Najlepsze praktyki

1. **Używaj webhooków w czasie rzeczywistym** - Rejestruj webhooki zamiast odpytywania o zmiany zgłoszeń
2. **Filtruj według zespołu** - Synchronizuj tylko zgłoszenia z odpowiednich zespołów, aby zmniejszyć użycie API
3. **Optymalizuj zapytania GraphQL** - Żądaj tylko potrzebnych pól, aby pozostać w ramach limitów złożoności
4. **Mapuj etykiety na segmenty** - Używaj etykiet Linear do napędzania segmentacji kontaktów Brevo
5. **Obsługuj paginację** - Zawsze sprawdzaj `hasNextPage` i używaj `endCursor` dla kompletnych danych
6. **Weryfikuj podpisy webhook** - Zawsze waliduj nagłówek `Linear-Signature`

## Bezpieczeństwo

- **Uwierzytelnianie kluczem API** - Klucze osobiste ograniczone do workspace
- **OAuth 2.0** - Bezpieczny przepływ autoryzacji dla integracji wieloworkspace’owych
- **Tylko HTTPS** - Cała komunikacja API zaszyfrowana przez TLS 1.2+
- **Podpisy webhook** - Weryfikacja podpisu oparta na HMAC
- **Szyfrowane przechowywanie** - Klucze API szyfrowane w spoczynku w Tajo
- **Zgodność SOC 2** - Platforma Linear posiada certyfikat SOC 2 Type II

## Powiązane zasoby

- [Konektor GitHub](https://tajo.io/pl/docs/connectors/custom/github)
- [Konektor Jira](https://tajo.io/pl/docs/connectors/custom/jira)
- [Konektor Notion](https://tajo.io/pl/docs/connectors/custom/notion)
- [Brevo Contacts API](https://tajo.io/pl/docs/contact-management)