Connect Linear to Lovable using the native Linear shared connector in Settings → Connectors. Once enabled, Lovable's AI can read and write Linear issues, projects, teams, and cycles at runtime — no manual API wiring required. Linear also has a separate MCP personal connector that feeds issue context to the AI while you build. Setup takes under 5 minutes.
Build apps that talk to Linear — without touching an API key
Linear is the go-to issue tracker for fast-moving product teams, and connecting it to a Lovable app lets you surface the right project data exactly where your team needs it. Think internal dashboards that show open issues by cycle, client portals that let stakeholders track progress without Linear access, or ops tools that automatically create Linear issues from form submissions — all built in minutes through Lovable's chat interface.
The Linear shared connector uses a gateway architecture, the same pattern Lovable uses for Slack. This means OAuth tokens are managed centrally by Lovable — they refresh automatically, never appear in your project's codebase, and are shared securely across your workspace. You connect once in Settings → Connectors, and every project in your workspace can tap into Linear data. The gateway caps API usage at 1,000 requests per minute per connector per project, which is more than sufficient for most internal tools.
Linear also ships a second integration path: an MCP personal connector that gives Lovable's AI build-time context from your Linear workspace. When the MCP connector is active, the AI can read your actual issue titles, acceptance criteria, and cycle data while generating code — so your prototypes reflect real requirements rather than placeholder content. The two connectors serve different purposes and can be used independently or together.
Integration method
Linear integrates as a shared connector using a gateway architecture — Lovable manages OAuth automatically, so your app reads and writes Linear data at runtime without storing credentials in your project code.
Prerequisites
- A Lovable account with at least one active project
- A Linear account with at least one workspace, team, and a few issues to test with
- Owner or Admin role in your Lovable workspace (required to configure shared connectors)
- Linear account permissions to authorize third-party OAuth connections
Step-by-step guide
Enable the Linear shared connector in Settings → Connectors
Enable the Linear shared connector in Settings → Connectors
Open your Lovable workspace and click the Settings gear icon in the top-right corner of the editor. In the Settings panel, navigate to the Connectors section and look for the 'Shared connectors' list. Scroll through the list until you find Linear — it appears alongside Slack, Stripe, Twilio, and the other 17 available connectors. Click the Linear connector card to open its configuration panel. You will see a description of what the connector provides (issue management, projects, teams, cycles) and a button to initiate the OAuth connection. Click 'Connect Linear' and a browser popup will open prompting you to sign in to your Linear account (if you are not already signed in) and authorize Lovable to access your workspace data. Once you approve the OAuth authorization, the popup closes and the connector status changes to 'Connected' with a green indicator. Lovable stores the OAuth tokens in its gateway infrastructure — you will never see a client ID, client secret, or access token anywhere in your project code. This connection is workspace-level, meaning every project under your workspace can now use Linear data. If your team has multiple Lovable workspaces, you will need to connect Linear separately in each one.
Expected result: The Linear connector shows a green 'Connected' status in Settings → Connectors → Shared connectors. No API keys or credentials appear anywhere in your project files.
Ask Lovable to build a Linear issues dashboard
Ask Lovable to build a Linear issues dashboard
With the Linear connector active, open the chat panel in your Lovable project and describe the view you want to build. Lovable's AI now has full context about the Linear connector's capabilities — it knows the available API endpoints, data shapes (issues, projects, teams, cycles, labels, assignees), and the right code patterns to use with the gateway. Be specific about which data you want to display and how you want it organized. Mention filters like team, cycle, status, or priority if they are relevant. If you want write capabilities (creating or updating issues from the app), include that in your prompt too. The AI will generate all necessary frontend components and the server-side calls needed to interact with Linear through the gateway — no manual wiring required. After Lovable generates the initial build, check the live preview and refine with follow-up prompts. You can ask it to add filters, change the card layout, add a status badge with color coding, or include a link that opens the issue directly in Linear. The AI retains context across the conversation, so incremental refinements work well.
Using the Linear connector, build an issues dashboard page. Show all open issues from my workspace in a card grid — each card should display the issue ID, title, priority (color-coded: Urgent = red, High = orange, Medium = yellow, No priority = gray), status, assignee name, and the team it belongs to. Add a filter bar at the top to filter by team and by status. Clicking a card should open the full issue in Linear in a new tab.
Paste this in Lovable chat
Expected result: Lovable generates a functional issues dashboard page in the preview. The grid populates with real Linear data from your workspace, cards show priority colors and assignee names, and the team/status filter dropdowns work correctly.
Add write capabilities — create issues from your app
Add write capabilities — create issues from your app
Read-only dashboards are useful, but many of the most powerful Linear + Lovable use cases involve writing back to Linear: a client feedback form that auto-creates an issue, an internal tool that converts meeting action items into Linear tasks, or a bug report button embedded in your product that files issues directly to the right team and cycle. In the Lovable chat, describe the write behavior you want. Be specific about which Linear fields should be populated: team, project, cycle, title, description, priority, labels, and assignee are all writable through the connector. If you want to map form inputs to Linear fields, describe that mapping explicitly — for example, 'use the dropdown to set priority' or 'auto-assign to the on-call team based on the category selected'. Lovable will generate the form component and the server-side logic to call Linear's create/update endpoints through the gateway. Because the gateway handles authentication, there is no webhook secret to configure and no Edge Function for you to write. The AI handles the integration plumbing — your job is to describe the user experience accurately so the generated code matches your intended behavior. For more complex workflows — like automatically moving an issue to a specific cycle when a status changes, or triggering a Linear issue from a Supabase database event — you can describe the full flow in one prompt and Lovable will generate both the frontend trigger and the backend logic.
Add a 'Report a bug' button to the top of the issues dashboard. When clicked, it opens a slide-over panel with a form: Title (text input, required), Description (textarea), Priority (dropdown: Urgent / High / Medium / No priority), and Team (dropdown populated from my Linear teams). When submitted, create a new issue in Linear with those fields and show a success toast with the new issue ID and a link to open it in Linear. Close the panel after success.
Paste this in Lovable chat
Expected result: A 'Report a bug' button appears in the dashboard header. Clicking it opens a slide-over with the form. After submission, a new issue appears in your Linear workspace with the correct fields populated, and a toast notification confirms success with the issue ID.
Enable the Linear MCP personal connector for build-time context
Enable the Linear MCP personal connector for build-time context
The Linear MCP personal connector is separate from the shared connector and serves a completely different purpose. While the shared connector gives your deployed app runtime access to Linear data, the MCP personal connector gives Lovable's AI context about your Linear workspace while you are building — it reads your actual issues, cycle goals, and acceptance criteria so the code it generates matches your real project structure. To enable it, go to Settings → Connectors and find the 'Personal connectors (MCP)' section, which is listed separately from Shared connectors. Click on Linear in the personal connectors list and authorize access to your Linear account. This is a per-user setting, not workspace-wide — each team member configures their own personal connectors. Once connected, try starting a new feature build by referencing your Linear issues directly. You can use @Linear syntax in the Lovable chat to pull in specific issue content as context. For example, referencing an issue like ENG-142 tells the AI exactly what feature you are building, including acceptance criteria written by your product team. The AI uses this context to generate more accurate components, field names, data structures, and edge case handling — without you having to re-explain the requirements. This connector is never included in the deployed application. It is purely a development-time tool that makes the AI a better collaborator by grounding it in your actual project context.
I have the Linear MCP connector active. Using issue ENG-142 as context for the requirements, build the feature described in that issue. Match the acceptance criteria exactly and use the field names and statuses from our Linear workspace.
Paste this in Lovable chat
Expected result: Lovable's AI reads the referenced Linear issue and generates components that match the acceptance criteria and field definitions from that issue, without you needing to re-describe the requirements manually.
Build a cycle progress tracker showing team velocity
Build a cycle progress tracker showing team velocity
One of the most requested Linear dashboard components for internal tools is a cycle tracker — a view that shows how a team is tracking against their current cycle goals. With the Linear shared connector, you can build this as a dedicated page or as a section within a broader engineering dashboard, and it will reflect live data from your Linear workspace whenever the page loads. A cycle tracker typically shows the current cycle name and dates, the total number of issues scoped to the cycle, a breakdown by status (Todo, In Progress, Done, Cancelled), a completion percentage, and optionally a list of unstarted issues with their assignees and priorities to surface blockers at a glance. You can also include a comparison to the previous cycle to indicate whether velocity is improving. In your Lovable chat, describe the exact metrics and layout you want. If your organization uses multiple teams, you can ask Lovable to add a team selector so the same page works across teams without rebuilding it. For teams that run multiple concurrent cycles or have custom cycle naming conventions, specify that in your prompt so the AI accounts for it in the data fetching logic. This is also a good place to use Lovable's visual editing tools (Design view) to fine-tune typography, spacing, and color after the initial build — adjusting visual styling in Design view costs no credits.
Build a cycle progress page using the Linear connector. For each of my Linear teams, show the current active cycle: cycle name, start and end dates, total issues, a status breakdown (Todo / In Progress / Done / Cancelled) shown as both numbers and a horizontal progress bar, and an overall completion percentage. If a cycle has more than 30% of issues still in Todo with fewer than 5 days remaining, highlight that team's card in amber as a warning. Add a 'View in Linear' button on each card that links directly to that team's cycle in Linear.
Paste this in Lovable chat
Expected result: A cycle progress page renders with live data from all your Linear teams' current cycles. Progress bars update based on issue statuses, and teams with at-risk cycles are highlighted in amber. Each card links directly to the corresponding cycle in Linear.
Common use cases
Add write capabilities — create issues from your app
Use Linear with Lovable to add write capabilities — create issues from your app. This is one of the most common use cases when integrating Linear into your Lovable application.
Using the Linear connector, build an issues dashboard page. Show all open issues from my workspace in a card grid — each card should display the issue ID, title, priority (color-coded: Urgent = red, High = orange, Medium = yellow, No priority = gray), status, assignee name, and the team it belongs to. Add a filter bar at the top to filter by team and by status. Clicking a card should open the full issue in Linear in a new tab.
Copy this prompt to try it in Lovable
Enable the Linear MCP personal connector for build-time context
Take your Linear integration further by enable the linear mcp personal connector for build-time context. This builds on the basic setup to create a more complete experience.
Add a 'Report a bug' button to the top of the issues dashboard. When clicked, it opens a slide-over panel with a form: Title (text input, required), Description (textarea), Priority (dropdown: Urgent / High / Medium / No priority), and Team (dropdown populated from my Linear teams). When submitted, create a new issue in Linear with those fields and show a success toast with the new issue ID and a link to open it in Linear. Close the panel after success.
Copy this prompt to try it in Lovable
Build a cycle progress tracker showing team velocity
Prepare your Linear integration for production by build a cycle progress tracker showing team velocity. Ensures your integration works reliably for real users.
I have the Linear MCP connector active. Using issue ENG-142 as context for the requirements, build the feature described in that issue. Match the acceptance criteria exactly and use the field names and statuses from our Linear workspace.
Copy this prompt to try it in Lovable
Troubleshooting
Linear connector shows 'Connected' but no data appears in the app preview
Cause: The connector is authorized but the AI-generated code may be referencing an incorrect team ID, project ID, or filter that returns zero results from your workspace.
Solution: Open Cloud → Logs to check whether the Linear API calls are returning errors or empty arrays. In Lovable chat, ask: 'Debug the Linear data fetch — log the raw API response and show me what teams and projects are being returned.' This will surface whether the issue is an empty result set, a permissions scope mismatch, or a data shape the component is not handling. If your Linear workspace is new or sparsely populated, add a few test issues first, then refresh the preview.
OAuth authorization popup closes immediately or shows an error
Cause: Browser popup blockers can prevent the OAuth window from opening, or a previous partial authorization left the connector in a broken state.
Solution: Check your browser's popup blocker settings and explicitly allow popups from lovable.dev. If the popup opens but shows an OAuth error, go to your Linear account settings, revoke the existing Lovable authorization under Authorized Applications, then return to Lovable Settings → Connectors and reconnect from scratch. Using a non-incognito browser window typically resolves cookie-related OAuth issues.
Issue creation via the app succeeds but fields like cycle or project are not set
Cause: Linear requires issue creation requests to include explicit IDs for optional fields like cycle, project, and label. If the AI-generated form does not include these selectors, those fields are omitted from the API call.
Solution: In Lovable chat, specify exactly which Linear fields should be settable in the form: 'Update the issue creation form to include a Project dropdown (populated from my Linear projects) and a Cycle dropdown (showing only active cycles for the selected team).' Providing that level of detail lets the AI generate the correct data-fetching logic for the dropdowns and include those IDs in the create-issue payload.
Best practices
- Use the shared connector for all runtime data needs — never store a Linear API key in Cloud → Secrets and call Linear directly from an Edge Function, as this bypasses the gateway's automatic token refresh and rate limit management.
- When building dashboards for external stakeholders (clients, investors), apply Supabase RLS policies to control which Linear data each authenticated user can see — the Linear connector does not enforce row-level access on its own.
- Scope your Linear API calls to specific teams or projects rather than fetching workspace-wide data; this keeps response payloads small, reduces latency, and stays well within the 1,000 req/min gateway limit.
- Use the Linear MCP personal connector during the design phase of a new feature to ground the AI in your actual acceptance criteria — then switch to building with the shared connector once the spec is clear.
- Add pagination to any issue list component — Linear workspaces with hundreds of issues will cause slow renders and poor UX if all results are fetched in a single unbounded query.
- For write operations (creating or updating issues), always show a confirmation step or success toast with the new issue ID and a direct link back to Linear, so users can verify the data was saved correctly.
- When building cycle or project dashboards, cache the Linear data in Supabase (a simple `linear_cache` table with a TTL) for frequently accessed views — this avoids repeated API calls for data that only changes a few times a day and keeps your app fast for concurrent users.
- Test write functionality in a dedicated Linear team or project first before pointing the app at your active engineering workspace — it is easier to clean up test issues in an isolated area than to sort through real issues mixed with test data.
Alternatives
Choose Slack if your primary use case is team messaging, notifications, or digest summaries — Linear is for structured issue and project tracking, while Slack is for real-time communication and async updates.
Choose JIRA if your team already uses Atlassian's ecosystem (Confluence, Bitbucket) or needs enterprise compliance features — Linear and JIRA cover similar issue-tracking ground but JIRA integrates via Lovable's MCP personal connector rather than a shared runtime connector.
Choose Notion if you need a flexible workspace that blends documents, databases, and project tracking — Linear is purpose-built for engineering issue management with speed as the primary design constraint, while Notion is a more general-purpose knowledge and planning tool.
Frequently asked questions
Do I need a paid Linear plan to use the Lovable connector?
No. The Linear shared connector works with Linear's free tier. However, some Linear features like advanced analytics, priority support, and certain cycle visibility options are only available on paid Linear plans. The connector itself does not require any specific Linear subscription tier — it uses the standard Linear API that is available to all accounts.
What is the difference between the Linear shared connector and the Linear MCP personal connector?
The shared connector gives your deployed app runtime access to Linear data — it runs when your users interact with the app, fetching and writing issues, projects, and cycles in real time. The MCP personal connector is a build-time tool: it gives Lovable's AI context from your Linear workspace while you are describing and building features, but it is never included in the deployed app. Most teams use both: MCP during planning and development, shared connector for the live app.
Can multiple Lovable projects in the same workspace share one Linear connection?
Yes. The Linear shared connector is configured at the workspace level in Settings → Connectors, so every project in your Lovable workspace can access Linear data using the same OAuth connection. You do not need to reconnect Linear for each new project. If you have multiple Lovable workspaces (for example, separate workspaces for different clients), you will need to authorize Linear independently in each workspace.
Is it safe to display Linear data to external users (clients, stakeholders) through a Lovable app?
Yes, but you need to explicitly configure access controls. The Linear connector does not enforce row-level visibility on its own — by default, any authenticated user in your Lovable app could potentially see all Linear data the connector has access to. To restrict access, use Supabase RLS policies to control what each user role can query, and scope your Linear API calls to return only the teams or projects relevant to each user. Never expose Linear data in a public (unauthenticated) Lovable app.
What happens if I hit the 1,000 requests per minute rate limit?
The Linear gateway will return rate limit errors for requests that exceed 1,000 req/min. For most internal tools and dashboards this limit is very generous and will not be reached under normal usage. If you are building a high-traffic app or running background sync jobs that poll Linear frequently, add client-side caching (store fetched data in Supabase with a timestamp and only refresh after a configurable TTL) to reduce the number of live API calls. RapidDev's team can help architect a caching layer for Linear-heavy applications if you need to scale beyond the standard limits.
Can I trigger Linear issue creation from a Supabase database event rather than a user form submission?
Yes. Describe the full automation flow to Lovable in one prompt — for example, 'When a new row is inserted into the support_requests table with priority = high, automatically create a Linear issue in the Engineering team with the request title and description.' Lovable will generate a Supabase database trigger or Edge Function that fires on the relevant event and calls Linear through the gateway. This kind of event-driven issue creation is one of the most powerful use cases for combining the Linear connector with Lovable Cloud's built-in database.
Talk to an Expert
Our team has built 600+ apps. Get personalized help with your project.
Book a free consultation