Linear - Parable

Linear is a project management and issue tracking tool for software teams, offering a GraphQL API for accessing issues, teams, projects, cycles, users, roadmaps, initiatives, and customers.

Overview
Setup Guide
Permissions
Troubleshooting

Connect Parable to Linear for issues, projects, and teams using the GraphQL API.

Issues & Projects

Issues, projects, cycles, milestones

Teams & Users

Team structure, user assignments

Query Issues with Details

query {
  issues(first: 100) {
    nodes {
      id
      title
      description
      state { name }
      assignee { name email }
      project { name }
      labels { nodes { name } }
      createdAt
      updatedAt
    }
    pageInfo {
      hasNextPage
      endCursor
    }
  }
}

Query Team Members

query {
  users {
    nodes {
      id
      name
      email
      active
      admin
    }
  }
}

Data streams

This Provider Plugin defines 16 data streams.

Stream	Description	Sync
`issues`	Extracts all issues (tasks/tickets) from Linear, including title, description, priority, state, assignee, labels, and relationships.	incremental
`teams`	Extracts all teams within the Linear organization, including name, key, and settings.	full
`projects`	Extracts all projects from Linear, including name, status, progress, and milestone relationships.	full
`active_cycles`	Extracts all cycles (sprints) from Linear, including name, number, start/end dates, and team relationships.	full
`users`	Extracts all members of the Linear organization, including profile information and roles.	full
`roadmaps`	Extracts all roadmaps from Linear providing a high-level view of projects and initiatives over time.	full
`initiatives`	Extracts all initiatives (strategic goals) from Linear that group related projects at a higher level.	full
`customers`	Extracts all customer records from Linear used for tracking customer-related issues and requests.	full
`comments`	Extracts all comments posted on Linear issues, including body text, author, and timestamps.	full
`labels`	Extracts all issue labels from Linear used to categorize and filter issues.	full
`workflow_states`	Extracts all workflow states from Linear defining lifecycle stages for issues within teams.	full
`attachments`	Extracts all file and link attachments associated with Linear issues.	full
`project_milestones`	Extracts all project milestones from Linear marking significant progress points within projects.	full
`notifications`	Extracts notifications for the authenticated user about issue updates, mentions, and other activity.	full
`custom_views`	Extracts custom saved views from Linear with filters and display settings created by users.	full
`project_updates`	Extracts project status updates from Linear. These are periodic updates posted by team members on projects, including health status, body text, and associated project metadata.	incremental

API token

What You’ll Need

Credential	What it is
API Key	Personal API key from Linear settings

Info: Setup access in Linear. These steps require Administrator, or a colleague with equivalent permissions who can create credentials for you. If that is not you, ask your Linear administrator.

Admin role in Linear workspace (for full data access)
API keys are tied to your user account and its permissions

Step 1: Access Linear Settings

Go to linear.app
Click your avatar → Settings
Navigate to Account → Security & Access

Step 2: Create API Key

Scroll to Personal API keys and click New API key
Enter label: Parable Integration
Choose permissions (full access or restricted) and click Create

Warning: Copy your API key now! This is the only time it will be displayed. Store it in a secure password manager before closing this page.

Step 3: Note Permissions

The API key inherits your account’s permissions:

Admin users have access to all workspace data
Member users have access based on team membership

Tip: For comprehensive data access, create the key with an admin account.

Step 4: Enter values in the form

API Key: Paste your Linear personal API key.
Click Save & test connection.

Test with GraphQL

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

List Issues

curl -X POST "https://api.linear.app/graphql" \
  -H "Authorization: Bearer YOUR_LINEAR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"query": "{ issues(first: 5) { nodes { id title } } }"}'

Success: Success! If you received a 200 OK response with valid data, your credentials are configured correctly. You can now configure this Provider in Parable.

Tip: Rate Limits: Linear enforces rate limits of 1,500 requests/hour; complexity-based limits for GraphQL. Parable handles rate limiting automatically with exponential backoff, but initial syncs of large datasets may take longer due to these limits.

Active Cycles

Developer identifier: active_cyclesActive Cycles contain all cycles (sprints) from Linear, including name, number, start/end dates, and team relationships.

Enables: place issues in their current planning cycles and compare cycle dates and recorded scope.
Scope: Reads the declared collection through the declared GraphQL operation as a full snapshot. Results are limited to objects visible to the configured API key or OAuth grant; private or restricted records not returned by Linear are absent.

Archived At

Developer identifier: active_cycles.archivedAtArchived At captures the time at which the cycle was archived, if applicable. It preserves the provider’s current classification of this record.

Enables: separate active cycle records by the exact provider-reported archived at value when describing their recorded state.
Interpretation: The provider supplies archivedAt per linear active cycle record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, archived at is the work record’s classification, not an individual-performance measure.

Completed At

Developer identifier: active_cycles.completedAtCompleted At captures the time at which the cycle was marked as completed. It preserves the provider’s current classification of this record.

Enables: separate active cycle records by the exact provider-reported completed at value when describing their recorded state.
Interpretation: The provider supplies completedAt per linear active cycle record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, completed at is the work record’s classification, not an individual-performance measure.

Completed Issue Count History

Developer identifier: active_cycles.completedIssueCountHistoryCompleted Issue Count History states historical snapshot of the completed issue count over the cycle’s duration. It preserves the provider’s current classification of this record.

Enables: separate active cycle records by the exact provider-reported completed issue count history value when describing their recorded state.
Interpretation: The provider supplies completedIssueCountHistory per linear active cycle record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, completed issue count history is the work record’s classification, not an individual-performance measure.

Completed Scope History

Developer identifier: active_cycles.completedScopeHistoryCompleted Scope History states historical snapshot of the completed scope (number of points or issues) over the cycle’s duration. It preserves the provider’s current classification of this record.

Enables: separate active cycle records by the exact provider-reported completed scope history value when describing their recorded state.
Interpretation: The provider supplies completedScopeHistory per linear active cycle record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, completed scope history is the work record’s classification, not an individual-performance measure.

Created At

Developer identifier: active_cycles.createdAtCreated At captures the time at which the cycle was created. It anchors the named event or boundary on the record’s timeline.

Enables: place active cycle records on a timeline by created at and select the records within an explicit reporting window.
Interpretation: The provider supplies createdAt per linear active cycle record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Description

Developer identifier: active_cycles.descriptionDescription contains a description of the cycle, often in markdown. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact description value attached to each linear active cycle record.
Interpretation: The provider supplies description at linear active cycle granularity in the format stated by its description; omitted or redacted content remains unknown.

Ends At

Developer identifier: active_cycles.endsAtEnds At records end date of the cycle. It anchors the named event or boundary on the record’s timeline.

Enables: place active cycle records on a timeline by ends at and select the records within an explicit reporting window.
Interpretation: The provider supplies endsAt per linear active cycle record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Developer identifier: active_cycles.idID is the unique identifier for the cycle. It supplies the declared record identity used when repeated ingestions represent the same source row.

Enables: recognize repeated ingestions of the same linear active cycle source row before constructing its represented state.
Interpretation: The provider supplies id at one value per linear active cycle record, and x-transformDedupKey explicitly marks it as the record key.

Issue Count History

Developer identifier: active_cycles.issueCountHistoryIssue Count History records the ordered series of issue-count snapshots captured during the cycle. It preserves how the number of in-scope issues changed over time.

Enables: analyze issues added or removed during a sprint and compare scope churn between cycles.
Interpretation: The provider supplies issueCountHistory as an array of issue-count samples, not an elapsed interval; an empty series and a missing series are distinct.

Name

Developer identifier: active_cycles.nameName captures the name of the cycle. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact name value attached to each linear active cycle record.
Interpretation: The provider supplies name at linear active cycle granularity in the format stated by its description; omitted or redacted content remains unknown.

Number

Developer identifier: active_cycles.numberNumber identifies the active cycle’s auto-incrementing sequence within its team. It anchors sprint history to team-local chronology.

Enables: order cycles for velocity trends and compare consecutive sprints within the same team.
Interpretation: The provider scopes number to a team; it is a cycle sequence, not a cycle count or cross-team measure.

Progress

Developer identifier: active_cycles.progressProgress reports cycle completion as a decimal ratio from 0 to 1. It captures the provider’s current sprint progress.

Enables: compare cycle advancement and support sprint progress or burndown analysis.
Interpretation: The provider supplies progress as a ratio where 0 means no reported completion and 1 means complete; missing remains unknown.

Scope History

Developer identifier: active_cycles.scopeHistoryScope History records the ordered series of total-scope snapshots captured during the cycle. It preserves how planned points or issue scope changed over time.

Enables: analyze scope growth or reduction during a sprint and compare the shape of scope change between cycles.
Interpretation: The provider supplies scopeHistory as an array of scope samples, not an elapsed interval; interpret each value using the team’s point or issue-count convention.

Starts At

Developer identifier: active_cycles.startsAtStarts At records start date of the cycle. It anchors the named event or boundary on the record’s timeline.

Enables: place active cycle records on a timeline by starts at and select the records within an explicit reporting window.
Interpretation: The provider supplies startsAt per linear active cycle record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Team

Developer identifier: active_cycles.teamTeam captures the team that owns this cycle. It preserves the containing or referenced object needed to reconstruct the provider relationship.

Enables: associate each linear active cycle record with the specific provider container named by team.
Interpretation: The provider returns team as a nested object or reference on LinearActiveCycle; an absent value does not prove that no related object exists outside the credential’s visibility.

Developer identifier: active_cycles.team.idID is the unique identifier for the team. It is needed to resolve references that repeat the same provider identifier.

Enables: match active cycle records to provider records that carry the same ID, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies id as a record-level identifier on LinearCycleTeam. It is not a uniqueness guarantee unless a connector directive says so.

Key

Developer identifier: active_cycles.team.keyKey captures the short key identifier for the team, used as a prefix for issue identifiers. It is needed to resolve references that repeat the same provider identifier.

Enables: match active cycle records to provider records that carry the same key, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies key as a record-level identifier on LinearCycleTeam. It is not a uniqueness guarantee unless a connector directive says so.

Name

Developer identifier: active_cycles.team.nameName captures the name of the team. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact name value attached to each linear cycle team record.
Interpretation: The provider supplies name at linear cycle team granularity in the format stated by its description; omitted or redacted content remains unknown.

Updated At

Developer identifier: active_cycles.updatedAtUpdated At captures the last time at which the cycle was meaningfully updated. It anchors the named event or boundary on the record’s timeline.

Enables: place active cycle records on a timeline by updated at and select the records within an explicit reporting window.
Interpretation: The provider supplies updatedAt per linear active cycle record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Attachments

Developer identifier: attachmentsAttachments contain all file and link attachments associated with Linear issues.

Enables: trace files and external links attached to issues.
Scope: Reads the declared collection through the declared GraphQL operation as a full snapshot. Results are limited to objects visible to the configured API key or OAuth grant; private or restricted records not returned by Linear are absent.

Archived At

Developer identifier: attachments.archivedAtArchived At records the timestamp when the attachment was archived, or null if not archived. It preserves the provider’s current classification of this record.

Enables: separate attachment records by the exact provider-reported archived at value when describing their recorded state.
Interpretation: The provider supplies archivedAt per linear attachment record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, archived at is the work record’s classification, not an individual-performance measure.

Created At

Developer identifier: attachments.createdAtCreated At records the timestamp when the attachment was created. It anchors the named event or boundary on the record’s timeline.

Enables: place attachment records on a timeline by created at and select the records within an explicit reporting window.
Interpretation: The provider supplies createdAt per linear attachment record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Creator

Developer identifier: attachments.creatorCreator captures the user who created the attachment. It keeps the provider-reported person or account context attached to the record.

Enables: attribute the linear attachment record to the provider-reported actor represented by creator.
Interpretation: The provider supplies creator as identity or attribution context on each linear attachment record. In Linear, creator is attribution or membership context for the work record, not a measure of an individual’s performance.

Developer identifier: attachments.creator.emailEmail records email address of the creator. It keeps the provider-reported person or account context attached to the record.

Enables: attribute the attachment creator record to the provider-reported person or account represented by email.
Interpretation: The provider supplies email as identity or attribution context on each attachment creator record. In Linear, email is attribution or membership context for the work record, not a measure of an individual’s performance.

Developer identifier: attachments.creator.idID is the unique identifier of the creator user. It is needed to resolve references that repeat the same provider identifier.

Enables: match attachment records to provider records that carry the same ID, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies id as a record-level identifier on AttachmentCreator. It is not a uniqueness guarantee unless a connector directive says so.

Name

Developer identifier: attachments.creator.nameName records display name of the creator. It keeps the provider-reported person or account context attached to the record.

Enables: attribute the attachment creator record to the provider-reported person or account represented by name.
Interpretation: The provider supplies name as identity or attribution context on each attachment creator record. In Linear, name is attribution or membership context for the work record, not a measure of an individual’s performance.

Group By Source

Developer identifier: attachments.groupBySourceGroup By Source indicates whether attachments from this source should be grouped together in the UI. It preserves the provider-reported yes-or-no condition for this record.

Enables: select attachment records for which the provider reports group by source as true or false.
Interpretation: The provider supplies groupBySource as a boolean per linear attachment record; false and missing are distinct when the field is optional. In Linear, group by source is a condition on the work record, not an individual-performance measure.

Developer identifier: attachments.idID is the unique identifier for the attachment. It supplies the declared record identity used when repeated ingestions represent the same source row.

Enables: recognize repeated ingestions of the same linear attachment source row before constructing its represented state.
Interpretation: The provider supplies id at one value per linear attachment record, and x-transformDedupKey explicitly marks it as the record key.

Issue

Developer identifier: attachments.issueIssue captures the issue this attachment is linked to. It preserves the containing or referenced object needed to reconstruct the provider relationship.

Enables: enumerate the nested issue records contained by each linear attachment record.
Interpretation: The provider returns issue as a nested object or reference on LinearAttachment; an absent value does not prove that no related object exists outside the credential’s visibility.

Developer identifier: attachments.issue.idID is the unique identifier of the linked issue. It is needed to resolve references that repeat the same provider identifier.

Enables: match attachment records to provider records that carry the same ID, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies id as a record-level identifier on AttachmentIssue. It is not a uniqueness guarantee unless a connector directive says so.

Identifier

Developer identifier: attachments.issue.identifierIdentifier identifies human-readable issue identifier (e.g., ENG-123). It is needed to resolve references that repeat the same provider identifier.

Enables: match attachment records to provider records that carry the same identifier, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies identifier as a record-level identifier on AttachmentIssue. It is not a uniqueness guarantee unless a connector directive says so.

Metadata

Developer identifier: attachments.metadataMetadata records arbitrary metadata associated with the attachment, typically populated by integrations. It retains configured attributes whose keys or shape are not fixed by this base schema.

Enables: interpret metadata according to the provider and Workspace configuration that produced each attachment record.
Interpretation: Keys and value shapes within metadata can vary with provider and customer configuration; consumers must inspect the observed Workspace schema rather than assume a fixed contract.

Source

Developer identifier: attachments.sourceSource records source of the attachment as a JSON object (e.g. {type, imageUrl}) describing the integration that created it. It preserves the configuration or technical value needed to explain how the provider object is defined.

Enables: inspect the exact source when validating the configuration or technical definition of a linear attachment record.
Interpretation: The provider supplies source as configuration or technical metadata on LinearAttachment; consumers must preserve the exact syntax and documented vocabulary.

Source Type

Developer identifier: attachments.sourceTypeSource Type states type of the source resource within the source service (e.g., pull_request, commit, comment, file). It preserves the provider’s current classification of this record.

Enables: separate attachment records by the exact provider-reported source type value when describing their recorded state.
Interpretation: The provider supplies sourceType per linear attachment record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, source type is the work record’s classification, not an individual-performance measure.

Subtitle

Developer identifier: attachments.subtitleSubtitle records subtitle or secondary description of the attachment. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact subtitle value attached to each linear attachment record.
Interpretation: The provider supplies subtitle at linear attachment granularity in the format stated by its description; omitted or redacted content remains unknown.

Title

Developer identifier: attachments.titleTitle records title of the attachment. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact title value attached to each linear attachment record.
Interpretation: The provider supplies title at linear attachment granularity in the format stated by its description; omitted or redacted content remains unknown.

Updated At

Developer identifier: attachments.updatedAtUpdated At records the timestamp when the attachment was last meaningfully updated. It anchors the named event or boundary on the record’s timeline.

Enables: place attachment records on a timeline by updated at and select the records within an explicit reporting window.
Interpretation: The provider supplies updatedAt per linear attachment record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

URL

Developer identifier: attachments.urlURL records URL of the attachment resource (e.g., link to a GitHub PR, Figma file, or uploaded document). It retains the exact provider location for the referenced resource.

Enables: open or trace the exact provider resource referenced by URL on a linear attachment record.
Interpretation: The provider supplies url as a URL or resource locator on each linear attachment record. Availability still follows the provider’s permissions and retention.

Comments

Developer identifier: commentsComments contain all comments posted on Linear issues, including body text, author, and timestamps.

Enables: inspect issue discussion text with its author and timestamps.
Scope: Reads the declared collection through the declared GraphQL operation as a full snapshot. Results are limited to objects visible to the configured API key or OAuth grant; private or restricted records not returned by Linear are absent.

Archived At

Developer identifier: comments.archivedAtArchived At captures the time at which the comment was archived, if applicable. It preserves the provider’s current classification of this record.

Enables: separate comment records by the exact provider-reported archived at value when describing their recorded state.
Interpretation: The provider supplies archivedAt per linear comment record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, archived at is the work record’s classification, not an individual-performance measure.

Body

Developer identifier: comments.bodyBody captures the text content of the comment in Markdown format. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact body value attached to each linear comment record.
Interpretation: The provider supplies body at linear comment granularity in the format stated by its description; omitted or redacted content remains unknown.

Body Data

Developer identifier: comments.bodyDataBody Data captures the rich text body data of the comment as a JSON document (ProseMirror format). It preserves the configuration or technical value needed to explain how the provider object is defined.

Enables: inspect the exact body data when validating the configuration or technical definition of a linear comment record.
Interpretation: The provider supplies bodyData as configuration or technical metadata on LinearComment; consumers must preserve the exact syntax and documented vocabulary.

Created At

Developer identifier: comments.createdAtCreated At captures the time at which the comment was created. It anchors the named event or boundary on the record’s timeline.

Enables: place comment records on a timeline by created at and select the records within an explicit reporting window.
Interpretation: The provider supplies createdAt per linear comment record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Edited At

Developer identifier: comments.editedAtEdited At captures the time at which the comment was edited by the user, if applicable. It anchors the named event or boundary on the record’s timeline.

Enables: place comment records on a timeline by edited at and select the records within an explicit reporting window.
Interpretation: The provider supplies editedAt per linear comment record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Developer identifier: comments.idID is the unique identifier for the comment. It supplies the declared record identity used when repeated ingestions represent the same source row.

Enables: recognize repeated ingestions of the same linear comment source row before constructing its represented state.
Interpretation: The provider supplies id at one value per linear comment record, and x-transformDedupKey explicitly marks it as the record key.

Issue

Developer identifier: comments.issueIssue captures the issue this comment belongs to. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact issue value attached to each linear comment record.
Interpretation: The provider supplies issue at linear comment granularity in the format stated by its description; omitted or redacted content remains unknown.

Developer identifier: comments.issue.idID is the unique identifier for the issue. It is needed to resolve references that repeat the same provider identifier.

Enables: match comment records to provider records that carry the same ID, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies id as a record-level identifier on LinearCommentIssue. It is not a uniqueness guarantee unless a connector directive says so.

Identifier

Developer identifier: comments.issue.identifierIdentifier captures the human-readable identifier of the issue (e.g., ENG-123). It is needed to resolve references that repeat the same provider identifier.

Enables: match comment records to provider records that carry the same identifier, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies identifier as a record-level identifier on LinearCommentIssue. It is not a uniqueness guarantee unless a connector directive says so.

Parent

Developer identifier: comments.parentParent captures the parent comment in a threaded discussion, if this is a reply. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact parent value attached to each linear comment record.
Interpretation: The provider supplies parent at linear comment granularity in the format stated by its description; omitted or redacted content remains unknown.

Developer identifier: comments.parent.idID is the unique identifier of the parent comment. It is needed to resolve references that repeat the same provider identifier.

Enables: match comment records to provider records that carry the same ID, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies id as a record-level identifier on LinearCommentParent. It is not a uniqueness guarantee unless a connector directive says so.

Resolved At

Developer identifier: comments.resolvedAtResolved At captures the time at which the comment was resolved, if applicable. It anchors the named event or boundary on the record’s timeline.

Enables: place comment records on a timeline by resolved at and select the records within an explicit reporting window.
Interpretation: The provider supplies resolvedAt per linear comment record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Updated At

Developer identifier: comments.updatedAtUpdated At captures the last time at which the comment was meaningfully updated. Used as incremental sync cursor. It anchors the named event or boundary on the record’s timeline.

Enables: place comment records on a timeline by updated at and select the records within an explicit reporting window.
Interpretation: The provider supplies updatedAt per linear comment record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

User

Developer identifier: comments.userUser captures the user who authored the comment. It keeps the provider-reported person or account context attached to the record.

Enables: attribute the linear comment record to the provider-reported actor represented by user.
Interpretation: The provider supplies user as identity or attribution context on each linear comment record. In Linear, user is attribution or membership context for the work record, not a measure of an individual’s performance.

Developer identifier: comments.user.emailEmail captures the email address of the user. It keeps the provider-reported person or account context attached to the record.

Enables: attribute the linear comment user record to the provider-reported person or account represented by email.
Interpretation: The provider supplies email as identity or attribution context on each linear comment user record. In Linear, email is attribution or membership context for the work record, not a measure of an individual’s performance.

Developer identifier: comments.user.idID is the unique identifier for the user. It is needed to resolve references that repeat the same provider identifier.

Enables: match comment records to provider records that carry the same ID, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies id as a record-level identifier on LinearCommentUser. It is not a uniqueness guarantee unless a connector directive says so.

Name

Developer identifier: comments.user.nameName captures the display name of the user. It keeps the provider-reported person or account context attached to the record.

Enables: attribute the linear comment user record to the provider-reported person or account represented by name.
Interpretation: The provider supplies name as identity or attribution context on each linear comment user record. In Linear, name is attribution or membership context for the work record, not a measure of an individual’s performance.

Custom Views

Developer identifier: custom_viewsCustom Views contain custom saved views from Linear with filters and display settings created by users.

Enables: reproduce the saved filters and display settings of Linear custom views.
Scope: Reads the declared collection through the declared GraphQL operation as a full snapshot. Results are limited to objects visible to the configured API key or OAuth grant; private or restricted records not returned by Linear are absent.

Archived At

Developer identifier: custom_views.archivedAtArchived At records the timestamp when the custom view was archived, if applicable. It retains configured attributes whose keys or shape are not fixed by this base schema.

Enables: interpret archived at according to the provider and Workspace configuration that produced each custom view record.
Interpretation: Keys and value shapes within archivedAt can vary with provider and customer configuration; consumers must inspect the observed Workspace schema rather than assume a fixed contract.

Color

Developer identifier: custom_views.colorColor records color value associated with the custom view for display purposes. It retains configured attributes whose keys or shape are not fixed by this base schema.

Enables: interpret color according to the provider and Workspace configuration that produced each custom view record.
Interpretation: Keys and value shapes within color can vary with provider and customer configuration; consumers must inspect the observed Workspace schema rather than assume a fixed contract.

Created At

Developer identifier: custom_views.createdAtCreated At records the timestamp when the custom view was created. It retains configured attributes whose keys or shape are not fixed by this base schema.

Enables: interpret created at according to the provider and Workspace configuration that produced each custom view record.
Interpretation: Keys and value shapes within createdAt can vary with provider and customer configuration; consumers must inspect the observed Workspace schema rather than assume a fixed contract.

Creator

Developer identifier: custom_views.creatorCreator captures the user who created this custom view. It retains configured attributes whose keys or shape are not fixed by this base schema.

Enables: interpret creator according to the provider and Workspace configuration that produced each custom view record.
Interpretation: Keys and value shapes within creator can vary with provider and customer configuration; consumers must inspect the observed Workspace schema rather than assume a fixed contract.

Developer identifier: custom_views.creator.emailEmail records email address of the user. It keeps the provider-reported person or account context attached to the record.

Enables: attribute the linear user record to the provider-reported person or account represented by email.
Interpretation: The provider supplies email as identity or attribution context on each linear user record. In Linear, email is attribution or membership context for the work record, not a measure of an individual’s performance.

Developer identifier: custom_views.creator.idID is the unique identifier for the user. It is needed to resolve references that repeat the same provider identifier.

Enables: match custom view records to provider records that carry the same ID, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies id as a record-level identifier on LinearUser. It is not a uniqueness guarantee unless a connector directive says so.

Name

Developer identifier: custom_views.creator.nameName records display name of the user. It keeps the provider-reported person or account context attached to the record.

Enables: attribute the linear user record to the provider-reported person or account represented by name.
Interpretation: The provider supplies name as identity or attribution context on each linear user record. In Linear, name is attribution or membership context for the work record, not a measure of an individual’s performance.

Description

Developer identifier: custom_views.descriptionDescription records description of the custom view explaining its purpose or contents. It retains configured attributes whose keys or shape are not fixed by this base schema.

Enables: interpret description according to the provider and Workspace configuration that produced each custom view record.
Interpretation: Keys and value shapes within description can vary with provider and customer configuration; consumers must inspect the observed Workspace schema rather than assume a fixed contract.

Filter Data

Developer identifier: custom_views.filterDataFilter Data records JSON object containing the filter configuration and criteria for this custom view. It retains configured attributes whose keys or shape are not fixed by this base schema.

Enables: interpret filter data according to the provider and Workspace configuration that produced each custom view record.
Interpretation: Keys and value shapes within filterData can vary with provider and customer configuration; consumers must inspect the observed Workspace schema rather than assume a fixed contract.

Icon

Developer identifier: custom_views.iconIcon records icon identifier associated with the custom view. It retains configured attributes whose keys or shape are not fixed by this base schema.

Enables: interpret icon according to the provider and Workspace configuration that produced each custom view record.
Interpretation: Keys and value shapes within icon can vary with provider and customer configuration; consumers must inspect the observed Workspace schema rather than assume a fixed contract.

Developer identifier: custom_views.idID is the unique identifier for the custom view. It supplies the declared record identity used when repeated ingestions represent the same source row.

Enables: recognize repeated ingestions of the same linear custom view source row before constructing its represented state.
Interpretation: The provider supplies id at one value per linear custom view record, and x-transformDedupKey explicitly marks it as the record key.

Name

Developer identifier: custom_views.nameName records name of the custom view. It retains configured attributes whose keys or shape are not fixed by this base schema.

Enables: interpret name according to the provider and Workspace configuration that produced each custom view record.
Interpretation: Keys and value shapes within name can vary with provider and customer configuration; consumers must inspect the observed Workspace schema rather than assume a fixed contract.

Shared

Developer identifier: custom_views.sharedShared indicates whether the view is shared with the team or is a personal/private view. It preserves the provider-reported yes-or-no condition for this record.

Enables: select custom view records for which the provider reports shared as true or false.
Interpretation: The provider supplies shared as a boolean per linear custom view record; false and missing are distinct when the field is optional. In Linear, shared is a condition on the work record, not an individual-performance measure.

Team

Developer identifier: custom_views.teamTeam captures the team this custom view is associated with, if any. It retains configured attributes whose keys or shape are not fixed by this base schema.

Enables: interpret team according to the provider and Workspace configuration that produced each custom view record.
Interpretation: Keys and value shapes within team can vary with provider and customer configuration; consumers must inspect the observed Workspace schema rather than assume a fixed contract.

Developer identifier: custom_views.team.idID is the unique identifier for the team. It is needed to resolve references that repeat the same provider identifier.

Enables: match custom view records to provider records that carry the same ID, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies id as a record-level identifier on LinearTeam. It is not a uniqueness guarantee unless a connector directive says so.

Key

Developer identifier: custom_views.team.keyKey identifies short unique key/prefix used for the team’s issue identifiers. It is needed to resolve references that repeat the same provider identifier.

Enables: match custom view records to provider records that carry the same key, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies key as a record-level identifier on LinearTeam. It is not a uniqueness guarantee unless a connector directive says so.

Name

Developer identifier: custom_views.team.nameName records name of the team. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact name value attached to each linear team record.
Interpretation: The provider supplies name at linear team granularity in the format stated by its description; omitted or redacted content remains unknown.

Updated At

Developer identifier: custom_views.updatedAtUpdated At records the timestamp when the custom view was last meaningfully updated. It retains configured attributes whose keys or shape are not fixed by this base schema.

Enables: interpret updated at according to the provider and Workspace configuration that produced each custom view record.
Interpretation: Keys and value shapes within updatedAt can vary with provider and customer configuration; consumers must inspect the observed Workspace schema rather than assume a fixed contract.

Customers

Developer identifier: customersCustomers contain all customer records from Linear used for tracking customer-related issues and requests.

Enables: associate customer-request records with the Linear issues that reference them.
Scope: Reads the declared collection through the declared GraphQL operation as a full snapshot. Results are limited to objects visible to the configured API key or OAuth grant; private or restricted records not returned by Linear are absent.

Archived At

Developer identifier: customers.archivedAtArchived At captures the time at which the customer was archived, if applicable. It preserves the provider’s current classification of this record.

Enables: separate customer records by the exact provider-reported archived at value when describing their recorded state.
Interpretation: The provider supplies archivedAt per linear customer record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, archived at is the work record’s classification, not an individual-performance measure.

Created At

Developer identifier: customers.createdAtCreated At captures the time at which the customer was created. It anchors the named event or boundary on the record’s timeline.

Enables: place customer records on a timeline by created at and select the records within an explicit reporting window.
Interpretation: The provider supplies createdAt per linear customer record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Domains

Developer identifier: customers.domainsDomains records domain names associated with the customer. It preserves the containing or referenced object needed to reconstruct the provider relationship.

Enables: associate each linear customer record with the specific provider container named by domains.
Interpretation: The provider returns domains as a list on LinearCustomer; an absent value does not prove that no related object exists outside the credential’s visibility.

External IDs

Developer identifier: customers.externalIdsExternal IDs identifies external identifiers associated with the customer from integrated systems. It is needed to resolve references that repeat the same provider identifier.

Enables: match customer records to provider records that carry the same external ids, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies externalIds as a record-level identifier on LinearCustomer. It is not a uniqueness guarantee unless a connector directive says so.

Developer identifier: customers.idID is the unique identifier for the customer. It supplies the declared record identity used when repeated ingestions represent the same source row.

Enables: recognize repeated ingestions of the same linear customer source row before constructing its represented state.
Interpretation: The provider supplies id at one value per linear customer record, and x-transformDedupKey explicitly marks it as the record key.

Logo URL

Developer identifier: customers.logoUrlLogo URL records URL of the customer’s logo image. It retains the exact provider location for the referenced resource.

Enables: open or trace the exact provider resource referenced by logo URL on a linear customer record.
Interpretation: The provider supplies logoUrl as a URL or resource locator on each linear customer record. Availability still follows the provider’s permissions and retention.

Name

Developer identifier: customers.nameName records name of the customer. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact name value attached to each linear customer record.
Interpretation: The provider supplies name at linear customer granularity in the format stated by its description; omitted or redacted content remains unknown.

Revenue

Developer identifier: customers.revenueRevenue reports revenue associated with the customer. It preserves the source-domain financial amount at this record’s granularity.

Enables: compare the revenue recorded in the source business process across customer records using the accompanying currency when one is supplied.
Interpretation: The source supplies revenue as a financial value in its actual business domain; no currency conversion is implied, and currency is unknown unless a companion field states it.

Size

Developer identifier: customers.sizeSize records Linear’s stated size for the customer organization. It preserves the organization-scale attribute without assuming a storage interpretation.

Enables: segment customer records by the provider-reported organization size.
Interpretation: The provider supplies size as an integer organization attribute whose unit is not declared by this schema; do not interpret it as bytes or headcount without provider context.

Updated At

Developer identifier: customers.updatedAtUpdated At captures the last time at which the customer was meaningfully updated. Used as incremental sync cursor. It anchors the named event or boundary on the record’s timeline.

Enables: place customer records on a timeline by updated at and select the records within an explicit reporting window.
Interpretation: The provider supplies updatedAt per linear customer record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Initiatives

Developer identifier: initiativesInitiatives contain all initiatives (strategic goals) from Linear that group related projects at a higher level.

Enables: trace strategic initiative records to their related projects.
Scope: Reads the declared collection through the declared GraphQL operation as a full snapshot. Results are limited to objects visible to the configured API key or OAuth grant; private or restricted records not returned by Linear are absent.

Archived At

Developer identifier: initiatives.archivedAtArchived At records the timestamp when the initiative was archived, if applicable. It preserves the provider’s current classification of this record.

Enables: separate initiative records by the exact provider-reported archived at value when describing their recorded state.
Interpretation: The provider supplies archivedAt per linear initiative record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, archived at is the work record’s classification, not an individual-performance measure.

Color

Developer identifier: initiatives.colorColor records display color for the initiative in the UI. It preserves the provider’s visual treatment for the represented object.

Enables: reproduce or compare the provider-supplied color for the represented design or board object.
Interpretation: The provider supplies color in its own color, opacity, stroke, emoji, or style vocabulary for the represented object.

Created At

Developer identifier: initiatives.createdAtCreated At records the timestamp when the initiative was created. It anchors the named event or boundary on the record’s timeline.

Enables: place initiative records on a timeline by created at and select the records within an explicit reporting window.
Interpretation: The provider supplies createdAt per linear initiative record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Creator

Developer identifier: initiatives.creatorCreator captures the user who created this initiative. It keeps the provider-reported person or account context attached to the record.

Enables: attribute the linear initiative record to the provider-reported actor represented by creator.
Interpretation: The provider supplies creator as identity or attribution context on each linear initiative record. In Linear, creator is attribution or membership context for the work record, not a measure of an individual’s performance.

Display Name

Developer identifier: initiatives.creator.displayNameDisplay Name records preferred display name of the user. It keeps the provider-reported person or account context attached to the record.

Enables: attribute the linear user summary record to the provider-reported person or account represented by display name.
Interpretation: The provider supplies displayName as identity or attribution context on each linear user summary record. In Linear, display name is attribution or membership context for the work record, not a measure of an individual’s performance.

Developer identifier: initiatives.creator.emailEmail records email address of the user. It keeps the provider-reported person or account context attached to the record.

Enables: attribute the linear user summary record to the provider-reported person or account represented by email.
Interpretation: The provider supplies email as identity or attribution context on each linear user summary record. In Linear, email is attribution or membership context for the work record, not a measure of an individual’s performance.

Developer identifier: initiatives.creator.idID is the unique identifier for the user. It is needed to resolve references that repeat the same provider identifier.

Enables: match initiative records to provider records that carry the same ID, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies id as a record-level identifier on LinearUserSummary. It is not a uniqueness guarantee unless a connector directive says so.

Name

Developer identifier: initiatives.creator.nameName records display name of the user. It keeps the provider-reported person or account context attached to the record.

Enables: attribute the linear user summary record to the provider-reported person or account represented by name.
Interpretation: The provider supplies name as identity or attribution context on each linear user summary record. In Linear, name is attribution or membership context for the work record, not a measure of an individual’s performance.

Description

Developer identifier: initiatives.descriptionDescription records detailed description of the initiative, typically in markdown format. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact description value attached to each linear initiative record.
Interpretation: The provider supplies description at linear initiative granularity in the format stated by its description; omitted or redacted content remains unknown.

Icon

Developer identifier: initiatives.iconIcon records icon identifier associated with the initiative. It retains the exact provider location for the referenced resource.

Enables: open or trace the exact provider resource referenced by icon on a linear initiative record.
Interpretation: The provider supplies icon as a URL or resource locator on each linear initiative record. Availability still follows the provider’s permissions and retention.

Developer identifier: initiatives.idID is the unique identifier for the initiative. It supplies the declared record identity used when repeated ingestions represent the same source row.

Enables: recognize repeated ingestions of the same linear initiative source row before constructing its represented state.
Interpretation: The provider supplies id at one value per linear initiative record, and x-transformDedupKey explicitly marks it as the record key.

Name

Developer identifier: initiatives.nameName records name of the initiative. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact name value attached to each linear initiative record.
Interpretation: The provider supplies name at linear initiative granularity in the format stated by its description; omitted or redacted content remains unknown.

Owner

Developer identifier: initiatives.ownerOwner captures the user who owns this initiative. It keeps the provider-reported person or account context attached to the record.

Enables: attribute the linear initiative record to the provider-reported actor represented by owner.
Interpretation: The provider supplies owner as identity or attribution context on each linear initiative record. In Linear, owner is attribution or membership context for the work record, not a measure of an individual’s performance.

Projects

Developer identifier: initiatives.projectsProjects records projects associated with this initiative. It preserves the containing or referenced object needed to reconstruct the provider relationship.

Enables: associate each linear initiative record with the specific provider container named by projects.
Interpretation: The provider returns projects as a nested object or reference on LinearInitiative; an absent value does not prove that no related object exists outside the credential’s visibility.

Nodes

Developer identifier: initiatives.projects.nodesNodes records project nodes in the connection. It preserves the containing or referenced object needed to reconstruct the provider relationship.

Enables: associate each linear project connection record with the specific provider container named by nodes.
Interpretation: The provider returns nodes as a list on LinearProjectConnection; an absent value does not prove that no related object exists outside the credential’s visibility.

Developer identifier: initiatives.projects.nodes.idID is the unique identifier for the project. It is needed to resolve references that repeat the same provider identifier.

Enables: match initiative records to provider records that carry the same ID, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies id as a record-level identifier on LinearProjectSummary. It is not a uniqueness guarantee unless a connector directive says so.

Name

Developer identifier: initiatives.projects.nodes.nameName records name of the project. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact name value attached to each linear project summary record.
Interpretation: The provider supplies name at linear project summary granularity in the format stated by its description; omitted or redacted content remains unknown.

Slug ID

Developer identifier: initiatives.slugIdSlug ID identifies URL-friendly slug identifier for the initiative. It is needed to resolve references that repeat the same provider identifier.

Enables: match initiative records to provider records that carry the same slug ID, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies slugId as a record-level identifier on LinearInitiative. It is not a uniqueness guarantee unless a connector directive says so.

Sort Order

Developer identifier: initiatives.sortOrderSort Order reports sort order value used for ordering initiatives in the UI. It preserves the stated measure at this record’s granularity.

Enables: order or classify initiative records using the provider-defined sort order value.
Interpretation: The provider supplies sortOrder at linear initiative granularity as a provider-defined ordinal or planning value rather than elapsed time or money; zero and missing are not interchangeable.

Status

Developer identifier: initiatives.statusStatus states current status of the initiative. It preserves the provider’s current classification of this record.

Enables: separate initiative records by the exact provider-reported status value when describing their recorded state.
Interpretation: The provider supplies status per linear initiative record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, status is the work record’s classification, not an individual-performance measure.

Target Date

Developer identifier: initiatives.targetDateTarget Date records target completion date for the initiative. It anchors the named event or boundary on the record’s timeline.

Enables: place initiative records on a timeline by target date and select the records within an explicit reporting window.
Interpretation: The provider supplies targetDate per linear initiative record as a calendar date without a time of day; missing values mean the event or boundary was not reported.

Updated At

Developer identifier: initiatives.updatedAtUpdated At records the timestamp when the initiative was last meaningfully updated. Used as incremental sync cursor. It anchors the named event or boundary on the record’s timeline.

Enables: place initiative records on a timeline by updated at and select the records within an explicit reporting window.
Interpretation: The provider supplies updatedAt per linear initiative record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

URL

Developer identifier: initiatives.urlURL records URL to view the initiative in Linear. It retains the exact provider location for the referenced resource.

Enables: open or trace the exact provider resource referenced by URL on a linear initiative record.
Interpretation: The provider supplies url as a URL or resource locator on each linear initiative record. Availability still follows the provider’s permissions and retention.

Issues

Developer identifier: issuesIssues contain all issues (tasks/tickets) from Linear, including title, description, priority, state, assignee, labels, and relationships.

Enables: report issue scope, workflow state, assignment, and relationships as work-record context.
Scope: Reads provider changes through the declared GraphQL operation using the declared incremental request boundary. Results are limited to objects visible to the configured API key or OAuth grant; private or restricted records not returned by Linear are absent.

Added To Cycle At

Developer identifier: issues.addedToCycleAtAdded To Cycle At records when the issue was added to its cycle. It anchors the named event or boundary on the record’s timeline.

Enables: place issue records on a timeline by added to cycle at and select the records within an explicit reporting window.
Interpretation: The provider supplies addedToCycleAt per linear issue record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Added To Project At

Developer identifier: issues.addedToProjectAtAdded To Project At records when the issue was added to its project. It anchors the named event or boundary on the record’s timeline.

Enables: place issue records on a timeline by added to project at and select the records within an explicit reporting window.
Interpretation: The provider supplies addedToProjectAt per linear issue record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Added To Team At

Developer identifier: issues.addedToTeamAtAdded To Team At records when the issue was added to its team. It anchors the named event or boundary on the record’s timeline.

Enables: place issue records on a timeline by added to team at and select the records within an explicit reporting window.
Interpretation: The provider supplies addedToTeamAt per linear issue record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Archived At

Developer identifier: issues.archivedAtArchived At records when the issue was archived. It preserves the provider’s current classification of this record.

Enables: separate issue records by the exact provider-reported archived at value when describing their recorded state.
Interpretation: The provider supplies archivedAt per linear issue record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, archived at is the work record’s classification, not an individual-performance measure.

Assignee

Developer identifier: issues.assigneeAssignee records user currently assigned to this issue. It keeps the provider-reported person or account context attached to the record.

Enables: attribute the linear issue record to the provider-reported actor represented by assignee.
Interpretation: The provider supplies assignee as identity or attribution context on each linear issue record. In Linear, assignee is attribution or membership context for the work record, not a measure of an individual’s performance.

Developer identifier: issues.assignee.emailEmail records email address of the user. It keeps the provider-reported person or account context attached to the record.

Enables: attribute the linear user ref record to the provider-reported person or account represented by email.
Interpretation: The provider supplies email as identity or attribution context on each linear user ref record. In Linear, email is attribution or membership context for the work record, not a measure of an individual’s performance.

Developer identifier: issues.assignee.idID is the unique identifier for the user. It is needed to resolve references that repeat the same provider identifier.

Enables: match issue records to provider records that carry the same ID, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies id as a record-level identifier on LinearUserRef. It is not a uniqueness guarantee unless a connector directive says so.

Name

Developer identifier: issues.assignee.nameName records display name of the user. It keeps the provider-reported person or account context attached to the record.

Enables: attribute the linear user ref record to the provider-reported person or account represented by name.
Interpretation: The provider supplies name as identity or attribution context on each linear user ref record. In Linear, name is attribution or membership context for the work record, not a measure of an individual’s performance.

Auto Archived At

Developer identifier: issues.autoArchivedAtAuto Archived At records when the issue was automatically archived. It preserves the provider’s current classification of this record.

Enables: separate issue records by the exact provider-reported auto archived at value when describing their recorded state.
Interpretation: The provider supplies autoArchivedAt per linear issue record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, auto archived at is the work record’s classification, not an individual-performance measure.

Auto Closed At

Developer identifier: issues.autoClosedAtAuto Closed At records when the issue was automatically closed by the system. It anchors the named event or boundary on the record’s timeline.

Enables: place issue records on a timeline by auto closed at and select the records within an explicit reporting window.
Interpretation: The provider supplies autoClosedAt per linear issue record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Board Order

Developer identifier: issues.boardOrderBoard Order reports position of the issue on the board view. It preserves the stated measure at this record’s granularity.

Enables: order or classify issue records using the provider-defined board order value.
Interpretation: The provider supplies boardOrder at linear issue granularity as a provider-defined ordinal or planning value rather than elapsed time or money; zero and missing are not interchangeable.

Branch Name

Developer identifier: issues.branchNameBranch Name records suggested branch name for the issue. It preserves the configuration or technical value needed to explain how the provider object is defined.

Enables: inspect the exact branch name when validating the configuration or technical definition of a linear issue record.
Interpretation: The provider supplies branchName as configuration or technical metadata on LinearIssue; consumers must preserve the exact syntax and documented vocabulary.

Canceled At

Developer identifier: issues.canceledAtCanceled At records when the issue was cancelled. It anchors the named event or boundary on the record’s timeline.

Enables: place issue records on a timeline by canceled at and select the records within an explicit reporting window.
Interpretation: The provider supplies canceledAt per linear issue record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Completed At

Developer identifier: issues.completedAtCompleted At records when the issue was marked as complete. It preserves the provider’s current classification of this record.

Enables: separate issue records by the exact provider-reported completed at value when describing their recorded state.
Interpretation: The provider supplies completedAt per linear issue record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, completed at is the work record’s classification, not an individual-performance measure.

Created At

Developer identifier: issues.createdAtCreated At records when the issue was created. It anchors the named event or boundary on the record’s timeline.

Enables: place issue records on a timeline by created at and select the records within an explicit reporting window.
Interpretation: The provider supplies createdAt per linear issue record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Creator

Developer identifier: issues.creatorCreator records user who created this issue. It keeps the provider-reported person or account context attached to the record.

Enables: attribute the linear issue record to the provider-reported actor represented by creator.
Interpretation: The provider supplies creator as identity or attribution context on each linear issue record. In Linear, creator is attribution or membership context for the work record, not a measure of an individual’s performance.

Cycle

Developer identifier: issues.cycleCycle records cycle (sprint) this issue is assigned to. It preserves the containing or referenced object needed to reconstruct the provider relationship.

Enables: associate each linear issue record with the specific provider container named by cycle.
Interpretation: The provider returns cycle as a nested object or reference on LinearIssue; an absent value does not prove that no related object exists outside the credential’s visibility.

Developer identifier: issues.cycle.idID is the unique identifier for the cycle. It is needed to resolve references that repeat the same provider identifier.

Enables: match issue records to provider records that carry the same ID, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies id as a record-level identifier on LinearCycleRef. It is not a uniqueness guarantee unless a connector directive says so.

Name

Developer identifier: issues.cycle.nameName records optional name of the cycle. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact name value attached to each linear cycle ref record.
Interpretation: The provider supplies name at linear cycle ref granularity in the format stated by its description; omitted or redacted content remains unknown.

Number

Developer identifier: issues.cycle.numberNumber identifies the cycle’s auto-incrementing sequence within its team. It keeps an issue’s cycle reference tied to the team’s sprint chronology.

Enables: resolve and order referenced cycles within the same team.
Interpretation: The provider scopes number to a team; it is a cycle sequence, not a cycle count or cross-team measure.

Description

Developer identifier: issues.descriptionDescription records full description of the issue in markdown format. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact description value attached to each linear issue record.
Interpretation: The provider supplies description at linear issue granularity in the format stated by its description; omitted or redacted content remains unknown.

Due Date

Developer identifier: issues.dueDateDue Date records due date for the issue in YYYY-MM-DD format. It anchors the named event or boundary on the record’s timeline.

Enables: place issue records on a timeline by due date and select the records within an explicit reporting window.
Interpretation: The provider supplies dueDate per linear issue record as a calendar date without a time of day; missing values mean the event or boundary was not reported.

Estimate

Developer identifier: issues.estimateEstimate reports point estimate for the issue used in velocity calculations. It preserves the stated measure at this record’s granularity.

Enables: order or classify issue records using the provider-defined estimate value.
Interpretation: The provider supplies estimate at linear issue granularity as a provider-defined ordinal or planning value rather than elapsed time or money; zero and missing are not interchangeable.

Developer identifier: issues.idID is the unique identifier for the issue. It supplies the declared record identity used when repeated ingestions represent the same source row.

Enables: recognize repeated ingestions of the same linear issue source row before constructing its represented state.
Interpretation: The provider supplies id at one value per linear issue record, and x-transformDedupKey explicitly marks it as the record key.

Identifier

Developer identifier: issues.identifierIdentifier identifies human-readable issue identifier like TEAM-123. It is needed to resolve references that repeat the same provider identifier.

Enables: match issue records to provider records that carry the same identifier, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies identifier as a record-level identifier on LinearIssue. It is not a uniqueness guarantee unless a connector directive says so.

Labels

Developer identifier: issues.labelsLabels records labels applied to this issue. It preserves the containing or referenced object needed to reconstruct the provider relationship.

Enables: apply the provider-defined labels classifications to each linear issue record.
Interpretation: The provider returns labels as a nested object or reference on LinearIssue; an absent value does not prove that no related object exists outside the credential’s visibility.

Nodes

Developer identifier: issues.labels.nodesNodes records list of labels applied to the issue. It preserves the containing or referenced object needed to reconstruct the provider relationship.

Enables: apply the provider-defined nodes classifications to each linear label connection record.
Interpretation: The provider returns nodes as a list on LinearLabelConnection; an absent value does not prove that no related object exists outside the credential’s visibility.

Developer identifier: issues.labels.nodes.idID is the unique identifier for the label. It is needed to resolve references that repeat the same provider identifier.

Enables: match issue records to provider records that carry the same ID, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies id as a record-level identifier on LinearLabelRef. It is not a uniqueness guarantee unless a connector directive says so.

Name

Developer identifier: issues.labels.nodes.nameName records name of the label. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact name value attached to each linear label ref record.
Interpretation: The provider supplies name at linear label ref granularity in the format stated by its description; omitted or redacted content remains unknown.

Number

Developer identifier: issues.numberNumber identifies the issue’s auto-incrementing sequence within its team. It supplies the numeric portion used to reference the issue in team context.

Enables: locate issues by team and number and order issue creation within the same team sequence.
Interpretation: The provider scopes number to a team; it is a reference sequence, not a quantity comparable across teams.

Parent

Developer identifier: issues.parentParent records parent issue if this is a sub-issue. It preserves the containing or referenced object needed to reconstruct the provider relationship.

Enables: reconstruct the parent-child structure expressed by parent on each linear issue record.
Interpretation: The provider returns parent as a nested object or reference on LinearIssue; an absent value does not prove that no related object exists outside the credential’s visibility.

Developer identifier: issues.parent.idID is the unique identifier of the parent issue. It is needed to resolve references that repeat the same provider identifier.

Enables: match issue records to provider records that carry the same ID, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies id as a record-level identifier on LinearIssueParentRef. It is not a uniqueness guarantee unless a connector directive says so.

Identifier

Developer identifier: issues.parent.identifierIdentifier identifies human-readable identifier of the parent issue. It is needed to resolve references that repeat the same provider identifier.

Enables: match issue records to provider records that carry the same identifier, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies identifier as a record-level identifier on LinearIssueParentRef. It is not a uniqueness guarantee unless a connector directive says so.

Priority

Developer identifier: issues.priorityPriority reports the numeric priority level (0=none, 1=urgent, 2=high, 3=medium, 4=low). It preserves the provider’s current classification of this record.

Enables: separate issue records by the exact provider-reported priority value when describing their recorded state.
Interpretation: The provider supplies priority per linear issue record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, priority is the work record’s classification, not an individual-performance measure.

Priority Label

Developer identifier: issues.priorityLabelPriority Label states human-readable label for the priority level (e.g., Urgent, High, Medium, Low, No priority). It preserves the provider’s current classification of this record.

Enables: separate issue records by the exact provider-reported priority label value when describing their recorded state.
Interpretation: The provider supplies priorityLabel per linear issue record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, priority label is the work record’s classification, not an individual-performance measure.

Project

Developer identifier: issues.projectProject records project this issue belongs to. It preserves the containing or referenced object needed to reconstruct the provider relationship.

Enables: associate each linear issue record with the specific provider container named by project.
Interpretation: The provider returns project as a nested object or reference on LinearIssue; an absent value does not prove that no related object exists outside the credential’s visibility.

Developer identifier: issues.project.idID is the unique identifier for the project. It is needed to resolve references that repeat the same provider identifier.

Enables: match issue records to provider records that carry the same ID, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies id as a record-level identifier on LinearProjectRef. It is not a uniqueness guarantee unless a connector directive says so.

Name

Developer identifier: issues.project.nameName records name of the project. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact name value attached to each linear project ref record.
Interpretation: The provider supplies name at linear project ref granularity in the format stated by its description; omitted or redacted content remains unknown.

Status

Developer identifier: issues.project.statusStatus states project status for this issue’s project. It preserves the provider’s current classification of this record.

Enables: separate issue records by the exact provider-reported status value when describing their recorded state.
Interpretation: The provider supplies status per linear project ref record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, status is the work record’s classification, not an individual-performance measure.

Developer identifier: issues.project.status.idID is the unique identifier for the project status. It is needed to resolve references that repeat the same provider identifier.

Enables: match issue records to provider records that carry the same ID, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies id as a record-level identifier on LinearProjectStatusRef. It is not a uniqueness guarantee unless a connector directive says so.

Name

Developer identifier: issues.project.status.nameName states name of the project status. It preserves the provider’s current classification of this record.

Enables: filter and group issue records by the Linear linear project status ref name exposed by the nested object.
Interpretation: The provider supplies name per linear project status ref record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, name is the work record’s classification, not an individual-performance measure.

Type

Developer identifier: issues.project.status.typeType states lifecycle type of the project status. It preserves the provider’s current classification of this record.

Enables: filter and group issue records by the Linear linear project status ref type exposed by the nested object.
Interpretation: The provider supplies type per linear project status ref record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, type is the work record’s classification, not an individual-performance measure.

Snoozed Until At

Developer identifier: issues.snoozedUntilAtSnoozed Until At records when the issue snooze period ends and it becomes active again. It anchors the named event or boundary on the record’s timeline.

Enables: place issue records on a timeline by snoozed until at and select the records within an explicit reporting window.
Interpretation: The provider supplies snoozedUntilAt per linear issue record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Sort Order

Developer identifier: issues.sortOrderSort Order reports position of the issue when ordered in a list. It preserves the stated measure at this record’s granularity.

Enables: order or classify issue records using the provider-defined sort order value.
Interpretation: The provider supplies sortOrder at linear issue granularity as a provider-defined ordinal or planning value rather than elapsed time or money; zero and missing are not interchangeable.

Started At

Developer identifier: issues.startedAtStarted At records when work on the issue was started (transitioned to a started state). It anchors the named event or boundary on the record’s timeline.

Enables: place issue records on a timeline by started at and select the records within an explicit reporting window.
Interpretation: The provider supplies startedAt per linear issue record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

State

Developer identifier: issues.stateState states current workflow state of the issue. It preserves the provider’s current classification of this record.

Enables: separate issue records by the exact provider-reported state value when describing their recorded state.
Interpretation: The provider supplies state per linear issue record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, state is the work record’s classification, not an individual-performance measure.

Developer identifier: issues.state.idID is the unique identifier for the workflow state. It is needed to resolve references that repeat the same provider identifier.

Enables: match issue records to provider records that carry the same ID, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies id as a record-level identifier on LinearWorkflowState. It is not a uniqueness guarantee unless a connector directive says so.

Name

Developer identifier: issues.state.nameName states name of the workflow state (e.g., Todo, In Progress, Done). It preserves the provider’s current classification of this record.

Enables: filter and group issue records by the Linear linear workflow state name exposed by the nested object.
Interpretation: The provider supplies name per linear workflow state record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, name is the work record’s classification, not an individual-performance measure.

Type

Developer identifier: issues.state.typeType states category type of the workflow state. It preserves the provider’s current classification of this record.

Enables: filter and group issue records by the Linear linear workflow state type exposed by the nested object.
Interpretation: The provider supplies type per linear workflow state record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, type is the work record’s classification, not an individual-performance measure.

Team

Developer identifier: issues.teamTeam records team that owns this issue. It preserves the containing or referenced object needed to reconstruct the provider relationship.

Enables: associate each linear issue record with the specific provider container named by team.
Interpretation: The provider returns team as a nested object or reference on LinearIssue; an absent value does not prove that no related object exists outside the credential’s visibility.

Developer identifier: issues.team.idID is the unique identifier for the team. It is needed to resolve references that repeat the same provider identifier.

Enables: match issue records to provider records that carry the same ID, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies id as a record-level identifier on LinearTeamRef. It is not a uniqueness guarantee unless a connector directive says so.

Key

Developer identifier: issues.team.keyKey identifies short key/prefix used in issue identifiers (e.g., ENG, DES). It is needed to resolve references that repeat the same provider identifier.

Enables: match issue records to provider records that carry the same key, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies key as a record-level identifier on LinearTeamRef. It is not a uniqueness guarantee unless a connector directive says so.

Name

Developer identifier: issues.team.nameName records name of the team. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact name value attached to each linear team ref record.
Interpretation: The provider supplies name at linear team ref granularity in the format stated by its description; omitted or redacted content remains unknown.

Title

Developer identifier: issues.titleTitle records title of the issue. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact title value attached to each linear issue record.
Interpretation: The provider supplies title at linear issue granularity in the format stated by its description; omitted or redacted content remains unknown.

Trashed

Developer identifier: issues.trashedTrashed indicates whether the issue has been trashed. It preserves the provider-reported yes-or-no condition for this record.

Enables: select issue records for which the provider reports trashed as true or false.
Interpretation: The provider supplies trashed as a boolean per linear issue record; false and missing are distinct when the field is optional. In Linear, trashed is a condition on the work record, not an individual-performance measure.

Triaged At

Developer identifier: issues.triagedAtTriaged At records when the issue was triaged. It anchors the named event or boundary on the record’s timeline.

Enables: place issue records on a timeline by triaged at and select the records within an explicit reporting window.
Interpretation: The provider supplies triagedAt per linear issue record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Updated At

Developer identifier: issues.updatedAtUpdated At records when the issue was last meaningfully updated. It anchors the named event or boundary on the record’s timeline.

Enables: place issue records on a timeline by updated at and select the records within an explicit reporting window.
Interpretation: The provider supplies updatedAt per linear issue record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

URL

Developer identifier: issues.urlURL records URL to view the issue in Linear. It retains the exact provider location for the referenced resource.

Enables: open or trace the exact provider resource referenced by URL on a linear issue record.
Interpretation: The provider supplies url as a URL or resource locator on each linear issue record. Availability still follows the provider’s permissions and retention.

Labels

Developer identifier: labelsLabels contain all issue labels from Linear used to categorize and filter issues.

Enables: categorize issues using the labels defined in Linear.
Scope: Reads the declared collection through the declared GraphQL operation as a full snapshot. Results are limited to objects visible to the configured API key or OAuth grant; private or restricted records not returned by Linear are absent.

Archived At

Developer identifier: labels.archivedAtArchived At captures the time at which the label was archived, or null if not archived. It preserves the provider’s current classification of this record.

Enables: separate label records by the exact provider-reported archived at value when describing their recorded state.
Interpretation: The provider supplies archivedAt per linear label record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, archived at is the work record’s classification, not an individual-performance measure.

Color

Developer identifier: labels.colorColor records color of the label for visual identification, typically a hex color string. It preserves the provider’s visual treatment for the represented object.

Enables: reproduce or compare the provider-supplied color for the represented design or board object.
Interpretation: The provider supplies color in its own color, opacity, stroke, emoji, or style vocabulary for the represented object.

Created At

Developer identifier: labels.createdAtCreated At captures the time at which the label was created. It anchors the named event or boundary on the record’s timeline.

Enables: place label records on a timeline by created at and select the records within an explicit reporting window.
Interpretation: The provider supplies createdAt per linear label record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Creator

Developer identifier: labels.creatorCreator records user who created the label. It keeps the provider-reported person or account context attached to the record.

Enables: attribute the linear label record to the provider-reported actor represented by creator.
Interpretation: The provider supplies creator as identity or attribution context on each linear label record. In Linear, creator is attribution or membership context for the work record, not a measure of an individual’s performance.

Developer identifier: labels.creator.emailEmail carries the source person or account value named Email for each linear label row. It keeps the provider-reported person or account context attached to the record.

Enables: attribute the linear label record to the provider-reported person or account represented by email.
Interpretation: The provider supplies email as identity or attribution context on each linear label record. In Linear, email is attribution or membership context for the work record, not a measure of an individual’s performance.

Developer identifier: labels.creator.idID carries the source identifier named ID for each linear label row. It is needed to resolve references that repeat the same provider identifier.

Enables: match label records to provider records that carry the same ID, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies id as a record-level identifier on LinearLabel. It is not a uniqueness guarantee unless a connector directive says so.

Name

Developer identifier: labels.creator.nameName carries the source-authored value named Name for each linear label row. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact name value attached to each linear label record.
Interpretation: The provider supplies name at linear label granularity in the format stated by its description; omitted or redacted content remains unknown.

Description

Developer identifier: labels.descriptionDescription records description of the label explaining its intended use. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact description value attached to each linear label record.
Interpretation: The provider supplies description at linear label granularity in the format stated by its description; omitted or redacted content remains unknown.

Developer identifier: labels.idID is the unique identifier for the label. It supplies the declared record identity used when repeated ingestions represent the same source row.

Enables: recognize repeated ingestions of the same linear label source row before constructing its represented state.
Interpretation: The provider supplies id at one value per linear label record, and x-transformDedupKey explicitly marks it as the record key.

Is Group

Developer identifier: labels.isGroupIs Group indicates whether this label is a group (parent) label that can contain child labels. It preserves the provider-reported yes-or-no condition for this record.

Enables: select label records for which the provider reports is group as true or false.
Interpretation: The provider supplies isGroup as a boolean per linear label record; false and missing are distinct when the field is optional. In Linear, is group is a condition on the work record, not an individual-performance measure.

Name

Developer identifier: labels.nameName records name of the label. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact name value attached to each linear label record.
Interpretation: The provider supplies name at linear label granularity in the format stated by its description; omitted or redacted content remains unknown.

Parent

Developer identifier: labels.parentParent captures the parent label if this label is part of a group hierarchy. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact parent value attached to each linear label record.
Interpretation: The provider supplies parent at linear label granularity in the format stated by its description; omitted or redacted content remains unknown.

Developer identifier: labels.parent.idID is the unique identifier for the parent label. It is needed to resolve references that repeat the same provider identifier.

Enables: match label records to provider records that carry the same ID, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies id as a record-level identifier on LinearLabelParent. It is not a uniqueness guarantee unless a connector directive says so.

Name

Developer identifier: labels.parent.nameName captures the name of the parent label. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact name value attached to each linear label parent record.
Interpretation: The provider supplies name at linear label parent granularity in the format stated by its description; omitted or redacted content remains unknown.

Team

Developer identifier: labels.teamTeam captures the team this label belongs to. Null for workspace-level labels. It preserves the provider’s current classification of this record.

Enables: separate label records by the exact provider-reported team value when describing their recorded state.
Interpretation: The provider supplies team per linear label record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, team is the work record’s classification, not an individual-performance measure.

Developer identifier: labels.team.idID is the unique identifier for the team. It is needed to resolve references that repeat the same provider identifier.

Enables: match label records to provider records that carry the same ID, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies id as a record-level identifier on LinearLabelTeam. It is not a uniqueness guarantee unless a connector directive says so.

Key

Developer identifier: labels.team.keyKey captures the short key identifier for the team, used as a prefix for issue identifiers. It is needed to resolve references that repeat the same provider identifier.

Enables: match label records to provider records that carry the same key, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies key as a record-level identifier on LinearLabelTeam. It is not a uniqueness guarantee unless a connector directive says so.

Name

Developer identifier: labels.team.nameName captures the name of the team. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact name value attached to each linear label team record.
Interpretation: The provider supplies name at linear label team granularity in the format stated by its description; omitted or redacted content remains unknown.

Updated At

Developer identifier: labels.updatedAtUpdated At captures the last time at which the label was meaningfully updated. It anchors the named event or boundary on the record’s timeline.

Enables: place label records on a timeline by updated at and select the records within an explicit reporting window.
Interpretation: The provider supplies updatedAt per linear label record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Notifications

Developer identifier: notificationsNotifications contain notifications for the authenticated user about issue updates, mentions, and other activity.

Enables: review notifications returned for the authenticated account and the records they reference.
Scope: Reads the declared collection through the declared GraphQL operation as a full snapshot. Results are limited to objects visible to the configured API key or OAuth grant; private or restricted records not returned by Linear are absent.

Actor

Developer identifier: notifications.actorActor captures the user who triggered the notification. It keeps the provider-reported person or account context attached to the record.

Enables: attribute the linear notification record to the provider-reported actor represented by actor.
Interpretation: The provider supplies actor as identity or attribution context on each linear notification record. In Linear, actor is attribution or membership context for the work record, not a measure of an individual’s performance.

Developer identifier: notifications.actor.emailEmail captures the email address of the user. It keeps the provider-reported person or account context attached to the record.

Enables: attribute the notification user record to the provider-reported person or account represented by email.
Interpretation: The provider supplies email as identity or attribution context on each notification user record. In Linear, email is attribution or membership context for the work record, not a measure of an individual’s performance.

Developer identifier: notifications.actor.idID is the unique identifier for the user. It is needed to resolve references that repeat the same provider identifier.

Enables: match notification records to provider records that carry the same ID, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies id as a record-level identifier on NotificationUser. It is not a uniqueness guarantee unless a connector directive says so.

Name

Developer identifier: notifications.actor.nameName captures the display name of the user. It keeps the provider-reported person or account context attached to the record.

Enables: attribute the notification user record to the provider-reported person or account represented by name.
Interpretation: The provider supplies name as identity or attribution context on each notification user record. In Linear, name is attribution or membership context for the work record, not a measure of an individual’s performance.

Archived At

Developer identifier: notifications.archivedAtArchived At captures the time at which the notification was archived. It preserves the provider’s current classification of this record.

Enables: separate notification records by the exact provider-reported archived at value when describing their recorded state.
Interpretation: The provider supplies archivedAt per linear notification record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, archived at is the work record’s classification, not an individual-performance measure.

Created At

Developer identifier: notifications.createdAtCreated At captures the time at which the notification was created. It anchors the named event or boundary on the record’s timeline.

Enables: place notification records on a timeline by created at and select the records within an explicit reporting window.
Interpretation: The provider supplies createdAt per linear notification record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Emailed At

Developer identifier: notifications.emailedAtEmailed At captures the time at which the notification was emailed to the user. It anchors the named event or boundary on the record’s timeline.

Enables: place notification records on a timeline by emailed at and select the records within an explicit reporting window.
Interpretation: The provider supplies emailedAt per linear notification record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Developer identifier: notifications.idID is the unique identifier for the notification. It supplies the declared record identity used when repeated ingestions represent the same source row.

Enables: recognize repeated ingestions of the same linear notification source row before constructing its represented state.
Interpretation: The provider supplies id at one value per linear notification record, and x-transformDedupKey explicitly marks it as the record key.

Read At

Developer identifier: notifications.readAtRead At captures the time at which the notification was read by the user. It anchors the named event or boundary on the record’s timeline.

Enables: place notification records on a timeline by read at and select the records within an explicit reporting window.
Interpretation: The provider supplies readAt per linear notification record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Snoozed Until At

Developer identifier: notifications.snoozedUntilAtSnoozed Until At captures the time until which the notification is snoozed. It anchors the named event or boundary on the record’s timeline.

Enables: place notification records on a timeline by snoozed until at and select the records within an explicit reporting window.
Interpretation: The provider supplies snoozedUntilAt per linear notification record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Type

Developer identifier: notifications.typeType states type of notification (e.g., issueAssignment, issueMention, issueStatusChanged). It preserves the provider’s current classification of this record.

Enables: separate notification records by the exact provider-reported type value when describing their recorded state.
Interpretation: The provider supplies type per linear notification record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, type is the work record’s classification, not an individual-performance measure.

Unsnoozed At

Developer identifier: notifications.unsnoozedAtUnsnoozed At captures the time at which the notification was unsnoozed. It anchors the named event or boundary on the record’s timeline.

Enables: place notification records on a timeline by unsnoozed at and select the records within an explicit reporting window.
Interpretation: The provider supplies unsnoozedAt per linear notification record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Updated At

Developer identifier: notifications.updatedAtUpdated At captures the last time at which the notification was meaningfully updated. It anchors the named event or boundary on the record’s timeline.

Enables: place notification records on a timeline by updated at and select the records within an explicit reporting window.
Interpretation: The provider supplies updatedAt per linear notification record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

User

Developer identifier: notifications.userUser captures the user who received the notification. It keeps the provider-reported person or account context attached to the record.

Enables: attribute the linear notification record to the provider-reported actor represented by user.
Interpretation: The provider supplies user as identity or attribution context on each linear notification record. In Linear, user is attribution or membership context for the work record, not a measure of an individual’s performance.

Project Milestones

Developer identifier: project_milestonesProject Milestones contain all project milestones from Linear marking significant progress points within projects.

Enables: place project work against named milestone records and target dates.
Scope: Reads the declared collection through the declared GraphQL operation as a full snapshot. Results are limited to objects visible to the configured API key or OAuth grant; private or restricted records not returned by Linear are absent.

Archived At

Developer identifier: project_milestones.archivedAtArchived At captures the time at which the milestone was archived, if applicable. It preserves the provider’s current classification of this record.

Enables: separate project milestone records by the exact provider-reported archived at value when describing their recorded state.
Interpretation: The provider supplies archivedAt per linear project milestone record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, archived at is the work record’s classification, not an individual-performance measure.

Created At

Developer identifier: project_milestones.createdAtCreated At captures the time at which the milestone was created. It anchors the named event or boundary on the record’s timeline.

Enables: place project milestone records on a timeline by created at and select the records within an explicit reporting window.
Interpretation: The provider supplies createdAt per linear project milestone record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Description

Developer identifier: project_milestones.descriptionDescription records description of the milestone providing additional context or details. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact description value attached to each linear project milestone record.
Interpretation: The provider supplies description at linear project milestone granularity in the format stated by its description; omitted or redacted content remains unknown.

Developer identifier: project_milestones.idID is the unique identifier for the milestone. It supplies the declared record identity used when repeated ingestions represent the same source row.

Enables: recognize repeated ingestions of the same linear project milestone source row before constructing its represented state.
Interpretation: The provider supplies id at one value per linear project milestone record, and x-transformDedupKey explicitly marks it as the record key.

Name

Developer identifier: project_milestones.nameName records name of the milestone. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact name value attached to each linear project milestone record.
Interpretation: The provider supplies name at linear project milestone granularity in the format stated by its description; omitted or redacted content remains unknown.

Project

Developer identifier: project_milestones.projectProject captures the project this milestone belongs to. It preserves the containing or referenced object needed to reconstruct the provider relationship.

Enables: associate each linear project milestone record with the specific provider container named by project.
Interpretation: The provider returns project as a nested object or reference on LinearProjectMilestone; an absent value does not prove that no related object exists outside the credential’s visibility.

Developer identifier: project_milestones.project.idID is the unique identifier of the parent project. It is needed to resolve references that repeat the same provider identifier.

Enables: match project milestone records to provider records that carry the same ID, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies id as a record-level identifier on LinearProjectMilestoneProject. It is not a uniqueness guarantee unless a connector directive says so.

Name

Developer identifier: project_milestones.project.nameName records name of the parent project. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact name value attached to each linear project milestone project record.
Interpretation: The provider supplies name at linear project milestone project granularity in the format stated by its description; omitted or redacted content remains unknown.

Sort Order

Developer identifier: project_milestones.sortOrderSort Order captures the sort order of the milestone within the project, used for display ordering. It preserves the stated measure at this record’s granularity.

Enables: order or classify project milestone records using the provider-defined sort order value.
Interpretation: The provider supplies sortOrder at linear project milestone granularity as a provider-defined ordinal or planning value rather than elapsed time or money; zero and missing are not interchangeable.

Target Date

Developer identifier: project_milestones.targetDateTarget Date records target date for the milestone completion in YYYY-MM-DD format. It anchors the named event or boundary on the record’s timeline.

Enables: place project milestone records on a timeline by target date and select the records within an explicit reporting window.
Interpretation: The provider supplies targetDate per linear project milestone record as a calendar date without a time of day; missing values mean the event or boundary was not reported.

Updated At

Developer identifier: project_milestones.updatedAtUpdated At captures the last time at which the milestone was meaningfully updated. It anchors the named event or boundary on the record’s timeline.

Enables: place project milestone records on a timeline by updated at and select the records within an explicit reporting window.
Interpretation: The provider supplies updatedAt per linear project milestone record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Project Updates

Developer identifier: project_updatesProject Updates contain project status updates from Linear. These are periodic updates posted by team members on projects, including health status, body text, and associated project metadata.

Enables: review periodic project-update text, health state, author, and publication time.
Scope: Reads provider changes through the declared GraphQL operation using the declared incremental request boundary. Results are limited to objects visible to the configured API key or OAuth grant; private or restricted records not returned by Linear are absent.

Body

Developer identifier: project_updates.bodyBody records update content in markdown format. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact body value attached to each linear project update record.
Interpretation: The provider supplies body at linear project update granularity in the format stated by its description; omitted or redacted content remains unknown.

Created At

Developer identifier: project_updates.createdAtCreated At records when the update was created. It anchors the named event or boundary on the record’s timeline.

Enables: place project update records on a timeline by created at and select the records within an explicit reporting window.
Interpretation: The provider supplies createdAt per linear project update record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Edited At

Developer identifier: project_updates.editedAtEdited At records when the update body was last edited. It anchors the named event or boundary on the record’s timeline.

Enables: place project update records on a timeline by edited at and select the records within an explicit reporting window.
Interpretation: The provider supplies editedAt per linear project update record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Health

Developer identifier: project_updates.healthHealth states project health status at time of update. It preserves the provider’s current classification of this record.

Enables: separate project update records by the exact provider-reported health value when describing their recorded state.
Interpretation: The provider supplies health per linear project update record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, health is the work record’s classification, not an individual-performance measure.

Developer identifier: project_updates.idID is the unique identifier for the project update. It supplies the declared record identity used when repeated ingestions represent the same source row.

Enables: recognize repeated ingestions of the same linear project update source row before constructing its represented state.
Interpretation: The provider supplies id at one value per linear project update record, and x-transformDedupKey explicitly marks it as the record key.

Project

Developer identifier: project_updates.projectProject records project this update belongs to. It preserves the containing or referenced object needed to reconstruct the provider relationship.

Enables: associate each linear project update record with the specific provider container named by project.
Interpretation: The provider returns project as a nested object or reference on LinearProjectUpdate; an absent value does not prove that no related object exists outside the credential’s visibility.

Developer identifier: project_updates.project.idID carries the source identifier named ID for each linear project row. It is needed to resolve references that repeat the same provider identifier.

Enables: match project update records to provider records that carry the same ID, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies id as a record-level identifier on LinearProject. It is not a uniqueness guarantee unless a connector directive says so.

Name

Developer identifier: project_updates.project.nameName carries the source-authored value named Name for each linear project row. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact name value attached to each linear project record.
Interpretation: The provider supplies name at linear project granularity in the format stated by its description; omitted or redacted content remains unknown.

Updated At

Developer identifier: project_updates.updatedAtUpdated At records when the update was last modified. It anchors the named event or boundary on the record’s timeline.

Enables: place project update records on a timeline by updated at and select the records within an explicit reporting window.
Interpretation: The provider supplies updatedAt per linear project update record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

User

Developer identifier: project_updates.userUser records user who posted the update. It keeps the provider-reported person or account context attached to the record.

Enables: attribute the linear project update record to the provider-reported actor represented by user.
Interpretation: The provider supplies user as identity or attribution context on each linear project update record. In Linear, user is attribution or membership context for the work record, not a measure of an individual’s performance.

Developer identifier: project_updates.user.emailEmail carries the source person or account value named Email for each linear user row. It keeps the provider-reported person or account context attached to the record.

Enables: attribute the linear user record to the provider-reported person or account represented by email.
Interpretation: The provider supplies email as identity or attribution context on each linear user record. In Linear, email is attribution or membership context for the work record, not a measure of an individual’s performance.

Developer identifier: project_updates.user.idID carries the source identifier named ID for each linear user row. It is needed to resolve references that repeat the same provider identifier.

Enables: match project update records to provider records that carry the same ID, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies id as a record-level identifier on LinearUser. It is not a uniqueness guarantee unless a connector directive says so.

Name

Developer identifier: project_updates.user.nameName carries the source-authored value named Name for each linear user row. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact name value attached to each linear user record.
Interpretation: The provider supplies name at linear user granularity in the format stated by its description; omitted or redacted content remains unknown.

Projects

Developer identifier: projectsProjects contain all projects from Linear, including name, status, progress, and milestone relationships.

Enables: review project scope, milestones, health updates, and recorded progress.
Scope: Reads the declared collection through the declared GraphQL operation as a full snapshot. Results are limited to objects visible to the configured API key or OAuth grant; private or restricted records not returned by Linear are absent.

Archived At

Developer identifier: projects.archivedAtArchived At records the timestamp when the project was archived, if applicable. It preserves the provider’s current classification of this record.

Enables: separate project records by the exact provider-reported archived at value when describing their recorded state.
Interpretation: The provider supplies archivedAt per linear project record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, archived at is the work record’s classification, not an individual-performance measure.

Canceled At

Developer identifier: projects.canceledAtCanceled At records the timestamp when the project was canceled. It anchors the named event or boundary on the record’s timeline.

Enables: place project records on a timeline by canceled at and select the records within an explicit reporting window.
Interpretation: The provider supplies canceledAt per linear project record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Color

Developer identifier: projects.colorColor records color associated with the project for UI display. It preserves the provider’s visual treatment for the represented object.

Enables: reproduce or compare the provider-supplied color for the represented design or board object.
Interpretation: The provider supplies color in its own color, opacity, stroke, emoji, or style vocabulary for the represented object.

Completed At

Developer identifier: projects.completedAtCompleted At records the timestamp when the project was completed. It preserves the provider’s current classification of this record.

Enables: separate project records by the exact provider-reported completed at value when describing their recorded state.
Interpretation: The provider supplies completedAt per linear project record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, completed at is the work record’s classification, not an individual-performance measure.

Created At

Developer identifier: projects.createdAtCreated At records the timestamp when the project was created. It anchors the named event or boundary on the record’s timeline.

Enables: place project records on a timeline by created at and select the records within an explicit reporting window.
Interpretation: The provider supplies createdAt per linear project record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Description

Developer identifier: projects.descriptionDescription records long-form description of the project, typically in markdown. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact description value attached to each linear project record.
Interpretation: The provider supplies description at linear project granularity in the format stated by its description; omitted or redacted content remains unknown.

Health

Developer identifier: projects.healthHealth states current health status of the project. It preserves the provider’s current classification of this record.

Enables: separate project records by the exact provider-reported health value when describing their recorded state.
Interpretation: The provider supplies health per linear project record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, health is the work record’s classification, not an individual-performance measure.

Icon

Developer identifier: projects.iconIcon records icon emoji or identifier associated with the project. It retains the exact provider location for the referenced resource.

Enables: open or trace the exact provider resource referenced by icon on a linear project record.
Interpretation: The provider supplies icon as a URL or resource locator on each linear project record. Availability still follows the provider’s permissions and retention.

Developer identifier: projects.idID is the unique identifier for the project. It supplies the declared record identity used when repeated ingestions represent the same source row.

Enables: recognize repeated ingestions of the same linear project source row before constructing its represented state.
Interpretation: The provider supplies id at one value per linear project record, and x-transformDedupKey explicitly marks it as the record key.

Lead

Developer identifier: projects.leadLead records user who is the lead of this project. It keeps the provider-reported person or account context attached to the record.

Enables: attribute the linear project record to the provider-reported person or account represented by lead.
Interpretation: The provider supplies lead as identity or attribution context on each linear project record. In Linear, lead is attribution or membership context for the work record, not a measure of an individual’s performance.

Developer identifier: projects.lead.emailEmail records email address of the user. It keeps the provider-reported person or account context attached to the record.

Enables: attribute the linear user record to the provider-reported person or account represented by email.
Interpretation: The provider supplies email as identity or attribution context on each linear user record. In Linear, email is attribution or membership context for the work record, not a measure of an individual’s performance.

Developer identifier: projects.lead.idID is the unique identifier for the user. It is needed to resolve references that repeat the same provider identifier.

Enables: match project records to provider records that carry the same ID, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies id as a record-level identifier on LinearUser. It is not a uniqueness guarantee unless a connector directive says so.

Name

Developer identifier: projects.lead.nameName records display name of the user. It keeps the provider-reported person or account context attached to the record.

Enables: attribute the linear user record to the provider-reported person or account represented by name.
Interpretation: The provider supplies name as identity or attribution context on each linear user record. In Linear, name is attribution or membership context for the work record, not a measure of an individual’s performance.

Name

Developer identifier: projects.nameName records name of the project. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact name value attached to each linear project record.
Interpretation: The provider supplies name at linear project granularity in the format stated by its description; omitted or redacted content remains unknown.

Priority

Developer identifier: projects.priorityPriority states priority level of the project (lower number is higher priority). It preserves the provider’s current classification of this record.

Enables: separate project records by the exact provider-reported priority value when describing their recorded state.
Interpretation: The provider supplies priority per linear project record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, priority is the work record’s classification, not an individual-performance measure.

Progress

Developer identifier: projects.progressProgress reports project completion as a decimal ratio from 0 to 1. It captures the provider’s current completion state.

Enables: compare project advancement and identify work that is not started, partial, or complete.
Interpretation: The provider supplies progress as a ratio where 0 means no reported completion and 1 means complete; missing remains unknown.

Scope

Developer identifier: projects.scopeScope reports the total scope (points) of the project. It preserves the stated measure at this record’s granularity.

Enables: measure the provider-reported scope for each linear project record.
Interpretation: The provider supplies scope at linear project granularity as a count at one value per record; zero and missing are not interchangeable.

Slug ID

Developer identifier: projects.slugIdSlug ID identifies URL-friendly slug identifier for the project. It is needed to resolve references that repeat the same provider identifier.

Enables: match project records to provider records that carry the same slug ID, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies slugId as a record-level identifier on LinearProject. It is not a uniqueness guarantee unless a connector directive says so.

Sort Order

Developer identifier: projects.sortOrderSort Order reports sort order value used for manual ordering of projects. It preserves the stated measure at this record’s granularity.

Enables: order or classify project records using the provider-defined sort order value.
Interpretation: The provider supplies sortOrder at linear project granularity as a provider-defined ordinal or planning value rather than elapsed time or money; zero and missing are not interchangeable.

Start Date

Developer identifier: projects.startDateStart Date records planned start date of the project. It anchors the named event or boundary on the record’s timeline.

Enables: place project records on a timeline by start date and select the records within an explicit reporting window.
Interpretation: The provider supplies startDate per linear project record as a calendar date without a time of day; missing values mean the event or boundary was not reported.

Started At

Developer identifier: projects.startedAtStarted At records the timestamp when the project was actually started. It anchors the named event or boundary on the record’s timeline.

Enables: place project records on a timeline by started at and select the records within an explicit reporting window.
Interpretation: The provider supplies startedAt per linear project record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

State

Developer identifier: projects.stateState states current lifecycle state of the project. It preserves the provider’s current classification of this record.

Enables: separate project records by the exact provider-reported state value when describing their recorded state.
Interpretation: The provider supplies state per linear project record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, state is the work record’s classification, not an individual-performance measure.

Target Date

Developer identifier: projects.targetDateTarget Date records target completion date of the project. It anchors the named event or boundary on the record’s timeline.

Enables: place project records on a timeline by target date and select the records within an explicit reporting window.
Interpretation: The provider supplies targetDate per linear project record as a calendar date without a time of day; missing values mean the event or boundary was not reported.

Updated At

Developer identifier: projects.updatedAtUpdated At records the timestamp when the project was last meaningfully updated. Used as incremental sync cursor. It anchors the named event or boundary on the record’s timeline.

Enables: place project records on a timeline by updated at and select the records within an explicit reporting window.
Interpretation: The provider supplies updatedAt per linear project record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Roadmaps

Developer identifier: roadmapsRoadmaps contain all roadmaps from Linear providing a high-level view of projects and initiatives over time.

Enables: organize projects and initiatives using Linear’s roadmap records.
Scope: Reads the declared collection through the declared GraphQL operation as a full snapshot. Results are limited to objects visible to the configured API key or OAuth grant; private or restricted records not returned by Linear are absent.

Archived At

Developer identifier: roadmaps.archivedAtArchived At records the timestamp when the roadmap was archived, if applicable. It preserves the provider’s current classification of this record.

Enables: separate roadmap records by the exact provider-reported archived at value when describing their recorded state.
Interpretation: The provider supplies archivedAt per linear roadmap record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, archived at is the work record’s classification, not an individual-performance measure.

Color

Developer identifier: roadmaps.colorColor records color of the roadmap. It preserves the provider’s visual treatment for the represented object.

Enables: reproduce or compare the provider-supplied color for the represented design or board object.
Interpretation: The provider supplies color in its own color, opacity, stroke, emoji, or style vocabulary for the represented object.

Created At

Developer identifier: roadmaps.createdAtCreated At records the timestamp when the roadmap was created. It anchors the named event or boundary on the record’s timeline.

Enables: place roadmap records on a timeline by created at and select the records within an explicit reporting window.
Interpretation: The provider supplies createdAt per linear roadmap record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Creator

Developer identifier: roadmaps.creatorCreator captures the user who created this roadmap. It keeps the provider-reported person or account context attached to the record.

Enables: attribute the linear roadmap record to the provider-reported actor represented by creator.
Interpretation: The provider supplies creator as identity or attribution context on each linear roadmap record. In Linear, creator is attribution or membership context for the work record, not a measure of an individual’s performance.

Developer identifier: roadmaps.creator.emailEmail records email address of the user. It keeps the provider-reported person or account context attached to the record.

Enables: attribute the linear user record to the provider-reported person or account represented by email.
Interpretation: The provider supplies email as identity or attribution context on each linear user record. In Linear, email is attribution or membership context for the work record, not a measure of an individual’s performance.

Developer identifier: roadmaps.creator.idID is the unique identifier for the user. It is needed to resolve references that repeat the same provider identifier.

Enables: match roadmap records to provider records that carry the same ID, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies id as a record-level identifier on LinearUser. It is not a uniqueness guarantee unless a connector directive says so.

Name

Developer identifier: roadmaps.creator.nameName records display name of the user. It keeps the provider-reported person or account context attached to the record.

Enables: attribute the linear user record to the provider-reported person or account represented by name.
Interpretation: The provider supplies name as identity or attribution context on each linear user record. In Linear, name is attribution or membership context for the work record, not a measure of an individual’s performance.

Description

Developer identifier: roadmaps.descriptionDescription records description of the roadmap, providing context about its strategic purpose. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact description value attached to each linear roadmap record.
Interpretation: The provider supplies description at linear roadmap granularity in the format stated by its description; omitted or redacted content remains unknown.

Developer identifier: roadmaps.idID is the unique identifier for the roadmap. It supplies the declared record identity used when repeated ingestions represent the same source row.

Enables: recognize repeated ingestions of the same linear roadmap source row before constructing its represented state.
Interpretation: The provider supplies id at one value per linear roadmap record, and x-transformDedupKey explicitly marks it as the record key.

Name

Developer identifier: roadmaps.nameName records name of the roadmap. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact name value attached to each linear roadmap record.
Interpretation: The provider supplies name at linear roadmap granularity in the format stated by its description; omitted or redacted content remains unknown.

Slug ID

Developer identifier: roadmaps.slugIdSlug ID identifies URL-friendly slug identifier for the roadmap. It is needed to resolve references that repeat the same provider identifier.

Enables: match roadmap records to provider records that carry the same slug ID, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies slugId as a record-level identifier on LinearRoadmap. It is not a uniqueness guarantee unless a connector directive says so.

Sort Order

Developer identifier: roadmaps.sortOrderSort Order captures the sort order of the roadmap relative to other roadmaps. It preserves the stated measure at this record’s granularity.

Enables: order or classify roadmap records using the provider-defined sort order value.
Interpretation: The provider supplies sortOrder at linear roadmap granularity as a provider-defined ordinal or planning value rather than elapsed time or money; zero and missing are not interchangeable.

Updated At

Developer identifier: roadmaps.updatedAtUpdated At records the timestamp when the roadmap was last meaningfully updated. Used as incremental sync cursor. It anchors the named event or boundary on the record’s timeline.

Enables: place roadmap records on a timeline by updated at and select the records within an explicit reporting window.
Interpretation: The provider supplies updatedAt per linear roadmap record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Teams

Developer identifier: teamsTeams contain all teams within the Linear organization, including name, key, and settings.

Enables: map issues, cycles, and projects to the Linear teams that contain them.
Scope: Reads the declared collection through the declared GraphQL operation as a full snapshot. Results are limited to objects visible to the configured API key or OAuth grant; private or restricted records not returned by Linear are absent.

Active Cycle

Developer identifier: teams.activeCycleActive Cycle states current active cycle for the team. It preserves the provider’s current classification of this record.

Enables: separate team records by the exact provider-reported active cycle value when describing their recorded state.
Interpretation: The provider supplies activeCycle per linear team record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, active cycle is the work record’s classification, not an individual-performance measure.

Developer identifier: teams.activeCycle.idID is the unique identifier for the cycle. It is needed to resolve references that repeat the same provider identifier.

Enables: match team records to provider records that carry the same ID, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies id as a record-level identifier on LinearCycleRef. It is not a uniqueness guarantee unless a connector directive says so.

Name

Developer identifier: teams.activeCycle.nameName records optional cycle name. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact name value attached to each linear cycle ref record.
Interpretation: The provider supplies name at linear cycle ref granularity in the format stated by its description; omitted or redacted content remains unknown.

Number

Developer identifier: teams.activeCycle.numberNumber identifies the cycle’s sequence within its team. It preserves sprint chronology on the cycle reference.

Enables: resolve and order cycles within the same team when following team relationships.
Interpretation: The provider scopes number to a team; it is a cycle sequence, not a cycle count or cross-team measure.

Archived At

Developer identifier: teams.archivedAtArchived At records when the team was archived, if applicable. It preserves the provider’s current classification of this record.

Enables: separate team records by the exact provider-reported archived at value when describing their recorded state.
Interpretation: The provider supplies archivedAt per linear team record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, archived at is the work record’s classification, not an individual-performance measure.

Children

Developer identifier: teams.childrenChildren records child teams nested under this team. It preserves the containing or referenced object needed to reconstruct the provider relationship.

Enables: reconstruct the parent-child structure expressed by children on each linear team record.
Interpretation: The provider returns children as a list on LinearTeam; an absent value does not prove that no related object exists outside the credential’s visibility.

Developer identifier: teams.children.idID is the unique identifier for the team. It supplies the declared record identity used when repeated ingestions represent the same source row.

Enables: recognize repeated ingestions of the same linear team ref source row before constructing its represented state.
Interpretation: The provider supplies id at one value per linear team ref record, and x-transformDedupKey explicitly marks it as the record key.

Key

Developer identifier: teams.children.keyKey identifies short team key used in issue identifiers. It is needed to resolve references that repeat the same provider identifier.

Enables: match team records to provider records that carry the same key, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies key as a record-level identifier on LinearTeamRef. It is not a uniqueness guarantee unless a connector directive says so.

Name

Developer identifier: teams.children.nameName records name of the team. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact name value attached to each linear team ref record.
Interpretation: The provider supplies name at linear team ref granularity in the format stated by its description; omitted or redacted content remains unknown.

Color

Developer identifier: teams.colorColor records team color used in the Linear UI. It preserves the provider’s visual treatment for the represented object.

Enables: reproduce or compare the provider-supplied color for the represented design or board object.
Interpretation: The provider supplies color in its own color, opacity, stroke, emoji, or style vocabulary for the represented object.

Created At

Developer identifier: teams.createdAtCreated At records when the team was created. It anchors the named event or boundary on the record’s timeline.

Enables: place team records on a timeline by created at and select the records within an explicit reporting window.
Interpretation: The provider supplies createdAt per linear team record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Description

Developer identifier: teams.descriptionDescription records description of the team’s purpose or scope. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact description value attached to each linear team record.
Interpretation: The provider supplies description at linear team granularity in the format stated by its description; omitted or redacted content remains unknown.

Display Name

Developer identifier: teams.displayNameDisplay Name records team name including parent team name when applicable. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact display name value attached to each linear team record.
Interpretation: The provider supplies displayName at linear team granularity in the format stated by its description; omitted or redacted content remains unknown.

Icon

Developer identifier: teams.iconIcon records icon identifier or emoji for the team. It retains the exact provider location for the referenced resource.

Enables: open or trace the exact provider resource referenced by icon on a linear team record.
Interpretation: The provider supplies icon as a URL or resource locator on each linear team record. Availability still follows the provider’s permissions and retention.

Developer identifier: teams.idID is the unique identifier for the team. It supplies the declared record identity used when repeated ingestions represent the same source row.

Enables: recognize repeated ingestions of the same linear team source row before constructing its represented state.
Interpretation: The provider supplies id at one value per linear team record, and x-transformDedupKey explicitly marks it as the record key.

Issue Count

Developer identifier: teams.issueCountIssue Count reports the number of issues in the team. It preserves the stated measure at this record’s granularity.

Enables: measure the provider-reported issue count for each linear team record.
Interpretation: The provider supplies issueCount at linear team granularity as a count at one value per record; zero and missing are not interchangeable.

Key

Developer identifier: teams.keyKey identifies short key/prefix used in issue identifiers (e.g., ENG, DES). It is needed to resolve references that repeat the same provider identifier.

Enables: match team records to provider records that carry the same key, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies key as a record-level identifier on LinearTeam. It is not a uniqueness guarantee unless a connector directive says so.

Name

Developer identifier: teams.nameName records display name of the team. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact name value attached to each linear team record.
Interpretation: The provider supplies name at linear team granularity in the format stated by its description; omitted or redacted content remains unknown.

Organization

Developer identifier: teams.organizationOrganization records Linear organization associated with the team. It preserves the containing or referenced object needed to reconstruct the provider relationship.

Enables: associate each linear team record with the specific provider container named by organization.
Interpretation: The provider returns organization as a nested object or reference on LinearTeam; an absent value does not prove that no related object exists outside the credential’s visibility.

Developer identifier: teams.organization.idID is the unique identifier for the organization. It is needed to resolve references that repeat the same provider identifier.

Enables: match team records to provider records that carry the same ID, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies id as a record-level identifier on LinearOrganizationRef. It is not a uniqueness guarantee unless a connector directive says so.

Name

Developer identifier: teams.organization.nameName records name of the organization. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact name value attached to each linear organization ref record.
Interpretation: The provider supplies name at linear organization ref granularity in the format stated by its description; omitted or redacted content remains unknown.

Parent

Developer identifier: teams.parentParent records parent team, if this is a child team. It preserves the containing or referenced object needed to reconstruct the provider relationship.

Enables: reconstruct the parent-child structure expressed by parent on each linear team record.
Interpretation: The provider returns parent as a nested object or reference on LinearTeam; an absent value does not prove that no related object exists outside the credential’s visibility.

Private

Developer identifier: teams.privatePrivate indicates whether the team is private. It documents the access-related value reported for this object or membership.

Enables: describe the provider-reported private attached to each linear team record.
Interpretation: The provider supplies private at linear team granularity. It describes provider-reported context and does not prove effective access beyond the returned record.

Timezone

Developer identifier: teams.timezoneTimezone records IANA timezone identifier for the team. It preserves the geographic, locale, time-zone, or coordinate context represented by the field.

Enables: interpret dates, times, or localized text for teams using the recorded timezone.
Interpretation: The provider supplies timezone as location or localization context per linear team record; it does not establish a person’s real-time physical location.

Updated At

Developer identifier: teams.updatedAtUpdated At records when the team was last updated. Used as incremental sync cursor. It anchors the named event or boundary on the record’s timeline.

Enables: place team records on a timeline by updated at and select the records within an explicit reporting window.
Interpretation: The provider supplies updatedAt per linear team record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Users

Developer identifier: usersUsers contain all members of the Linear organization, including profile information and roles.

Enables: resolve Linear member identities and organization roles for attribution and membership context.
Scope: Reads the declared collection through the declared GraphQL operation as a full snapshot. Results are limited to objects visible to the configured API key or OAuth grant; private or restricted records not returned by Linear are absent.

Active

Developer identifier: users.activeActive indicates whether the user account is currently active in the workspace. It preserves the provider-reported yes-or-no condition for this record.

Enables: select user records for which the provider reports active as true or false.
Interpretation: The provider supplies active as a boolean per linear user record; false and missing are distinct when the field is optional. In Linear, active is a condition on the work record, not an individual-performance measure.

Admin

Developer identifier: users.adminAdmin indicates whether the user has admin privileges in the workspace. It documents the access-related value reported for this object or membership.

Enables: describe the provider-reported admin attached to each linear user record.
Interpretation: The provider supplies admin at linear user granularity. It describes provider-reported context and does not prove effective access beyond the returned record. In Linear, admin is access or membership context, not an individual-performance measure.

Archived At

Developer identifier: users.archivedAtArchived At states ISO8601 datetime when the user was archived, if applicable. It preserves the provider’s current classification of this record.

Enables: separate user records by the exact provider-reported archived at value when describing their recorded state.
Interpretation: The provider supplies archivedAt per linear user record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, archived at is the work record’s classification, not an individual-performance measure.

Avatar URL

Developer identifier: users.avatarUrlAvatar URL records URL of the user’s avatar image. It retains the exact provider location for the referenced resource.

Enables: open or trace the exact provider resource referenced by avatar URL on a linear user record.
Interpretation: The provider supplies avatarUrl as a URL or resource locator on each linear user record. Availability still follows the provider’s permissions and retention.

Created At

Developer identifier: users.createdAtCreated At records ISO8601 datetime when the user record was created. It anchors the named event or boundary on the record’s timeline.

Enables: place user records on a timeline by created at and select the records within an explicit reporting window.
Interpretation: The provider supplies createdAt per linear user record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Created Issue Count

Developer identifier: users.createdIssueCountCreated Issue Count reports the number of issues created by the user. It anchors the named event or boundary on the record’s timeline.

Enables: place user records on a timeline by created issue count and select the records within an explicit reporting window.
Interpretation: The provider supplies createdIssueCount per linear user record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Description

Developer identifier: users.descriptionDescription records user-provided bio or description text. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact description value attached to each linear user record.
Interpretation: The provider supplies description at linear user granularity in the format stated by its description; omitted or redacted content remains unknown.

Disable Reason

Developer identifier: users.disableReasonDisable Reason records reason the user account was disabled, if applicable. It keeps the provider-reported person or account context attached to the record.

Enables: attribute the linear user record to the provider-reported person or account represented by disable reason.
Interpretation: The provider supplies disableReason as identity or attribution context on each linear user record. In Linear, disable reason is attribution or membership context for the work record, not a measure of an individual’s performance.

Display Name

Developer identifier: users.displayNameDisplay Name records display name of the user, typically their preferred name shown in the UI. It keeps the provider-reported person or account context attached to the record.

Enables: attribute the linear user record to the provider-reported person or account represented by display name.
Interpretation: The provider supplies displayName as identity or attribution context on each linear user record. In Linear, display name is attribution or membership context for the work record, not a measure of an individual’s performance.

Developer identifier: users.emailEmail records email address of the user. It keeps the provider-reported person or account context attached to the record.

Enables: attribute the linear user record to the provider-reported person or account represented by email.
Interpretation: The provider supplies email as identity or attribution context on each linear user record. In Linear, email is attribution or membership context for the work record, not a measure of an individual’s performance.

Guest

Developer identifier: users.guestGuest indicates whether the user is a guest (external collaborator) rather than a full member. It documents the access-related value reported for this object or membership.

Enables: describe the provider-reported guest attached to each linear user record.
Interpretation: The provider supplies guest at linear user granularity. It describes provider-reported context and does not prove effective access beyond the returned record. In Linear, guest is access or membership context, not an individual-performance measure.

Developer identifier: users.idID is the unique identifier for the user. It supplies the declared record identity used when repeated ingestions represent the same source row.

Enables: recognize repeated ingestions of the same linear user source row before constructing its represented state.
Interpretation: The provider supplies id at one value per linear user record, and x-transformDedupKey explicitly marks it as the record key.

Initials

Developer identifier: users.initialsInitials records initials displayed for the user. It keeps the provider-reported person or account context attached to the record.

Enables: attribute the linear user record to the provider-reported person or account represented by initials.
Interpretation: The provider supplies initials as identity or attribution context on each linear user record. In Linear, initials is attribution or membership context for the work record, not a measure of an individual’s performance.

Last Seen

Developer identifier: users.lastSeenLast Seen records ISO8601 datetime of when the user was last seen active in Linear. It anchors the named event or boundary on the record’s timeline.

Enables: place user records on a timeline by last seen and select the records within an explicit reporting window.
Interpretation: The provider supplies lastSeen per linear user record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Name

Developer identifier: users.nameName records full name of the user. It keeps the provider-reported person or account context attached to the record.

Enables: attribute the linear user record to the provider-reported person or account represented by name.
Interpretation: The provider supplies name as identity or attribution context on each linear user record. In Linear, name is attribution or membership context for the work record, not a measure of an individual’s performance.

Organization

Developer identifier: users.organizationOrganization records organization the user belongs to. It preserves the containing or referenced object needed to reconstruct the provider relationship.

Enables: associate each linear user record with the specific provider container named by organization.
Interpretation: The provider returns organization as a nested object or reference on LinearUser; an absent value does not prove that no related object exists outside the credential’s visibility.

Developer identifier: users.organization.idID is the unique identifier for the organization. It is needed to resolve references that repeat the same provider identifier.

Enables: match user records to provider records that carry the same ID, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies id as a record-level identifier on LinearOrganizationRef. It is not a uniqueness guarantee unless a connector directive says so.

Name

Developer identifier: users.organization.nameName records name of the organization. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact name value attached to each linear organization ref record.
Interpretation: The provider supplies name at linear organization ref granularity in the format stated by its description; omitted or redacted content remains unknown.

Status Emoji

Developer identifier: users.statusEmojiStatus Emoji states emoji representing the user’s current status. It preserves the provider’s current classification of this record.

Enables: separate user records by the exact provider-reported status emoji value when describing their recorded state.
Interpretation: The provider supplies statusEmoji per linear user record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, status emoji is the work record’s classification, not an individual-performance measure.

Status Label

Developer identifier: users.statusLabelStatus Label states text label for the user’s current status. It preserves the provider’s current classification of this record.

Enables: separate user records by the exact provider-reported status label value when describing their recorded state.
Interpretation: The provider supplies statusLabel per linear user record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, status label is the work record’s classification, not an individual-performance measure.

Status Until At

Developer identifier: users.statusUntilAtStatus Until At states ISO8601 datetime indicating when the user’s current status expires. It preserves the provider’s current classification of this record.

Enables: separate user records by the exact provider-reported status until at value when describing their recorded state.
Interpretation: The provider supplies statusUntilAt per linear user record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, status until at is the work record’s classification, not an individual-performance measure.

Teams

Developer identifier: users.teamsTeams records teams the user belongs to. It preserves the containing or referenced object needed to reconstruct the provider relationship.

Enables: associate each linear user record with the specific provider container named by teams.
Interpretation: The provider returns teams as a nested object or reference on LinearUser; an absent value does not prove that no related object exists outside the credential’s visibility.

Nodes

Developer identifier: users.teams.nodesNodes records team nodes in the connection. It preserves the containing or referenced object needed to reconstruct the provider relationship.

Enables: associate each linear team connection record with the specific provider container named by nodes.
Interpretation: The provider returns nodes as a list on LinearTeamConnection; an absent value does not prove that no related object exists outside the credential’s visibility.

Developer identifier: users.teams.nodes.idID is the unique identifier for the team. It is needed to resolve references that repeat the same provider identifier.

Enables: match user records to provider records that carry the same ID, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies id as a record-level identifier on LinearTeamRef. It is not a uniqueness guarantee unless a connector directive says so.

Key

Developer identifier: users.teams.nodes.keyKey identifies short team key used in issue identifiers. It is needed to resolve references that repeat the same provider identifier.

Enables: match user records to provider records that carry the same key, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies key as a record-level identifier on LinearTeamRef. It is not a uniqueness guarantee unless a connector directive says so.

Name

Developer identifier: users.teams.nodes.nameName records name of the team. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact name value attached to each linear team ref record.
Interpretation: The provider supplies name at linear team ref granularity in the format stated by its description; omitted or redacted content remains unknown.

Timezone

Developer identifier: users.timezoneTimezone records user’s configured timezone (IANA timezone identifier). It preserves the geographic, locale, time-zone, or coordinate context represented by the field.

Enables: interpret dates, times, or localized text for users using the recorded timezone.
Interpretation: The provider supplies timezone as location or localization context per linear user record; it does not establish a person’s real-time physical location.

Updated At

Developer identifier: users.updatedAtUpdated At records ISO8601 datetime when the user record was last meaningfully updated. It anchors the named event or boundary on the record’s timeline.

Enables: place user records on a timeline by updated at and select the records within an explicit reporting window.
Interpretation: The provider supplies updatedAt per linear user record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

URL

Developer identifier: users.urlURL records URL to the user’s profile page in Linear. It retains the exact provider location for the referenced resource.

Enables: open or trace the exact provider resource referenced by URL on a linear user record.
Interpretation: The provider supplies url as a URL or resource locator on each linear user record. Availability still follows the provider’s permissions and retention.

Workflow States

Developer identifier: workflow_statesWorkflow States contain all workflow states from Linear defining lifecycle stages for issues within teams.

Enables: interpret issue state using each team’s configured workflow stages.
Scope: Reads the declared collection through the declared GraphQL operation as a full snapshot. Results are limited to objects visible to the configured API key or OAuth grant; private or restricted records not returned by Linear are absent.

Archived At

Developer identifier: workflow_states.archivedAtArchived At records the timestamp when the workflow state was archived, null if not archived. It preserves the provider’s current classification of this record.

Enables: filter and group workflow state records by the Linear linear workflow state archived at exposed by the nested object.
Interpretation: The provider supplies archivedAt per linear workflow state record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, archived at is the work record’s classification, not an individual-performance measure.

Color

Developer identifier: workflow_states.colorColor records color of the workflow state displayed in the UI, typically a hex color code. It preserves the provider’s visual treatment for the represented object.

Enables: reproduce or compare the provider-supplied color for the represented design or board object.
Interpretation: The provider supplies color in its own color, opacity, stroke, emoji, or style vocabulary for the represented object.

Created At

Developer identifier: workflow_states.createdAtCreated At records the timestamp when the workflow state was created. It anchors the named event or boundary on the record’s timeline.

Enables: place workflow state records on a timeline by created at and select the records within an explicit reporting window.
Interpretation: The provider supplies createdAt per linear workflow state record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Description

Developer identifier: workflow_states.descriptionDescription records description of the workflow state explaining its purpose or usage. It keeps the exact text, label, or authored value needed to interpret the record.

Enables: inspect the exact description value attached to each linear workflow state record.
Interpretation: The provider supplies description at linear workflow state granularity in the format stated by its description; omitted or redacted content remains unknown.

Developer identifier: workflow_states.idID is the unique identifier for the workflow state. It supplies the declared record identity used when repeated ingestions represent the same source row.

Enables: recognize repeated ingestions of the same linear workflow state source row before constructing its represented state.
Interpretation: The provider supplies id at one value per linear workflow state record, and x-transformDedupKey explicitly marks it as the record key.

Name

Developer identifier: workflow_states.nameName states name of the workflow state (e.g., Todo, In Progress, Done). It preserves the provider’s current classification of this record.

Enables: filter and group workflow state records by the Linear linear workflow state name exposed by the nested object.
Interpretation: The provider supplies name per linear workflow state record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, name is the work record’s classification, not an individual-performance measure.

Position

Developer identifier: workflow_states.positionPosition reports sort position of the state within the team’s workflow, used for ordering. It preserves the stated measure at this record’s granularity.

Enables: order or classify workflow state records using the provider-defined position value.
Interpretation: The provider supplies position at linear workflow state granularity as a provider-defined ordinal or planning value rather than elapsed time or money; zero and missing are not interchangeable.

Team

Developer identifier: workflow_states.teamTeam captures the team this workflow state belongs to. It preserves the provider’s current classification of this record.

Enables: filter and group workflow state records by the Linear linear workflow state team exposed by the nested object.
Interpretation: The provider supplies team per linear workflow state record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, team is the work record’s classification, not an individual-performance measure.

Developer identifier: workflow_states.team.idID is the unique identifier of the team. It is needed to resolve references that repeat the same provider identifier.

Enables: match workflow state records to provider records that carry the same ID, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies id as a record-level identifier on LinearWorkflowStateTeam. It is not a uniqueness guarantee unless a connector directive says so.

Key

Developer identifier: workflow_states.team.keyKey identifies short key or abbreviation for the team, used as a prefix in issue identifiers. It is needed to resolve references that repeat the same provider identifier.

Enables: match workflow state records to provider records that carry the same key, without assuming that this field alone makes every row unique.
Interpretation: The provider supplies key as a record-level identifier on LinearWorkflowStateTeam. It is not a uniqueness guarantee unless a connector directive says so.

Name

Developer identifier: workflow_states.team.nameName states name of the team. It preserves the provider’s current classification of this record.

Enables: filter and group workflow state records by the Linear linear workflow state team name exposed by the nested object.
Interpretation: The provider supplies name per linear workflow state team record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, name is the work record’s classification, not an individual-performance measure.

Type

Developer identifier: workflow_states.typeType states category type classifying the workflow state into a standardized lifecycle stage. It preserves the provider’s current classification of this record.

Enables: filter and group workflow state records by the Linear linear workflow state type exposed by the nested object.
Interpretation: The provider supplies type per linear workflow state record using its own state vocabulary; unknown and missing values must remain distinct. In Linear, type is the work record’s classification, not an individual-performance measure.

Updated At

Developer identifier: workflow_states.updatedAtUpdated At records the timestamp when the workflow state was last meaningfully updated. It anchors the named event or boundary on the record’s timeline.

Enables: place workflow state records on a timeline by updated at and select the records within an explicit reporting window.
Interpretation: The provider supplies updatedAt per linear workflow state record as a timestamp at the precision returned by the provider; missing values mean the event or boundary was not reported.

Error	Meaning	Solution
`Authentication required`	Missing or invalid token	Verify API key in header
`Forbidden`	Insufficient permissions	Use admin account or check team access
`Rate limit exceeded`	Too many requests	Implement backoff

Common Issues

Can’t see certain teams

API keys inherit user permissions. If you can’t see certain teams, verify the user account has access.

GraphQL errors

Check your query syntax. Use Linear’s API explorer to test queries.Linear API — Official API documentationGraphQL Schema — GraphQL reference

​Issues & Projects

​Teams & Users

​Query Issues with Details

​Query Team Members

​Data streams

​API token

​What You’ll Need

​Step 1: Access Linear Settings

​Step 2: Create API Key

​Step 3: Note Permissions

​Step 4: Enter values in the form

​Common Issues

​Can’t see certain teams

​GraphQL errors

Issues & Projects

Teams & Users

Query Issues with Details

Query Team Members

Data streams

API token

What You’ll Need

Step 1: Access Linear Settings

Step 2: Create API Key

Step 3: Note Permissions

Step 4: Enter values in the form

Common Issues

Can’t see certain teams

GraphQL errors