The official docs, without the jargon.

This page provides ready-to-use prompts you can copy and paste into your Lovable project chat to build common app features. These prompts work with Lovable's built-in backend and don't require external setup unless specified.

To get the best results from Lovable, plan your features, build your app in small pieces, use real words, and describe the visual style using buzzwords. This helps Lovable understand exactly what you want and build it correctly the first time.

This guide shows you how to quickly build and publish your first app with Lovable, taking your idea from a simple description to a live website you can share. You don't need to install anything; just describe what you want, and Lovable builds it for you.

Lovable is a platform where you describe the app you want to build using plain language, and it creates the working app for you. It handles everything from the app's look to its behind-the-scenes functions and database, giving you real code you can change.

The project chat is where you tell Lovable what to build, discuss ideas, or plan features for your app. You can type or speak your requests, attach files, and guide Lovable as it works.

Lovable has a built-in AI connector that lets you add AI features like chatbots, summaries, and image generation to your app without needing API keys or complex setup. You just describe what you want, and Lovable handles the technical details.

You can bring your Figma designs into Lovable in three ways: using a Figma plugin, connecting through the Figma MCP, or uploading a .fig file. Each method helps Lovable understand your design details to build your app accurately.

You can connect your Lovable app to Google BigQuery to run database queries and build features using your data. This lets your app explore data, create reports, or build dashboards without needing to store special keys.

You can connect your Lovable app to a ClickHouse database to run SQL queries and build analytics features. This connection works for both self-hosted and cloud ClickHouse databases using their HTTP interface.

Connect your Lovable app to Google Search Console to monitor how your site performs in Google Search. This lets Lovable help with SEO tasks like verifying your domain, submitting sitemaps, and answering questions about your site's search performance.

You can connect your Lovable app to Storyblok, a content management system, to get content for your app or to create and update content in Storyblok. This lets you manage your app's text, images, and other content outside of your app's code.

You can tell Lovable to reuse parts of other projects in your workspace, like designs, code, or chat history. This helps you keep things consistent and avoids building the same features multiple times.

Before Lovable builds your project, you can choose from three design previews to compare different looks. You can also answer questions about fonts, colors, and layout to guide the visual style.

Design systems in Lovable help you keep your app's look and feel consistent by centralizing your UI components and styling rules. They ensure all your projects use the same building blocks and automatically update them when changes are made.

You can save a Lovable project as a design template to reuse its look and setup for new projects. This helps keep all your projects consistent and speeds up starting new ones.

Chat mode lets you talk about your app with Lovable without changing any code. It's for exploring ideas, understanding your project, or investigating problems before you decide what to build.

This setting makes sure that all your AI requests, both while you build and in your published apps, are processed only within the European Union. This is important if your organization needs to keep data processing inside the EU for legal or policy reasons.

This guide helps you understand the layout of the Lovable editor, showing where to find all the tools for building and managing your app. It covers the main areas like the chat and preview, along with all the menus and controls in the top bar.

This page is a dictionary of words and phrases used in Lovable, split into terms specific to Lovable and general development concepts. It helps you understand what different features and ideas mean when you see them in the documentation.

This guide shows you how to build a complete product with Lovable, from a basic idea to a live, growing app. It focuses on building in small steps and continuously improving based on real user feedback.

This page lists all the recent updates and new features in Lovable. It helps you stay informed about new capabilities, improvements, and bug fixes.

You can quickly add pre-made design parts like hero sections or navigation bars to your Lovable project. Just find a component you like on 21st.dev, copy its special prompt, and paste it into your Lovable project chat.

You can add advanced features like drag-and-drop or charts to your Lovable project by asking for specific JavaScript libraries called npm packages. Lovable will automatically add and integrate these packages into your app without you needing to install anything yourself.

You can learn how to use Lovable by watching video tutorials and courses. These resources cover everything from individual features to building and publishing a complete app.

You can look at and change the code Lovable creates for your project directly in the Lovable editor. This is useful for checking what Lovable built, making small changes yourself, or working with a developer.

Account settings let you manage your personal profile, how Lovable works for you, and your login security. These settings are for you as an individual, not for your team's projects.

Add Sign in with Apple to your app using managed Apple OAuth or your own Apple Developer credentials.

You can add a "Sign in with Google" option to your app so users can log in with their Google accounts instead of creating a new password. You can either let Lovable handle all the technical details for you, or you can use your own Google Cloud settings for more control.

You can let people sign into your app using their Microsoft account, either personal or work/school. You can choose for Lovable to handle the setup for you, or you can use your own Microsoft account settings for more control.

You can manage the technical parts of your app's built-in backend, like checking its health, changing its size, or increasing its storage. This is also where you can get a copy of your app's data, pause it to save money, or completely remove it.

App user connectors let each person using your Lovable app connect their own accounts from other services, like Gmail or Salesforce. This means your app can work with their personal data, not a shared company account.

Audit logs let you see everything that happens in your Lovable workspace, like who did what and when. This helps you keep track of changes, investigate issues, and ensure your project is secure.

You can create special web links that open Lovable with a specific task already typed in, along with any images or web pages you want Lovable to look at. This lets you share pre-made tasks with others or quickly start new projects from a link.

You can connect your Lovable project to your own Supabase project to manage your app's backend directly. This gives you full control over your database, user authentication, file storage, and server-side code.

You can connect your Lovable app to Airtable to read and write information from your Airtable bases. This lets you build custom tools and interfaces that use your Airtable data as the main source.

You can connect your Lovable app to Amazon Redshift, a cloud data warehouse, to run SQL queries and display the results in your app. This lets you build dashboards or reports directly from your data without managing database connections.

Connect your Lovable app to Apollo.io to search its large database of business contacts and companies. This lets your app find new leads, get more details about existing contacts, and manage sales activities.

Connect your Lovable app to Amazon Web Services (AWS) to control your AWS resources like EC2, DynamoDB, or Lambda. This lets you build internal tools and dashboards that interact with your AWS account.

Connect your Lovable app to Microsoft Azure to manage your cloud resources, track costs, and audit activity. This lets your app interact with your Azure subscriptions to build internal tools and dashboards.

You can connect your Lovable app to Cloudflare using an API token. This lets your app manage your Cloudflare services like DNS records, traffic data, and security settings.

Connect your Lovable app to Firebase Cloud Messaging to send push notifications to people's devices and web browsers. This lets your app send updates, announcements, and reminders directly to users.

You can connect your Lovable app to Google Cloud's Gemini Enterprise to search your organization's data and get answers backed by those sources. This lets you build tools like internal knowledge assistants or search portals that use your company's existing information.

Connect your Lovable app to Google Cloud to manage resources, read monitoring data, and inspect access. This connection uses a secure method called Workload Identity Federation, so Lovable never stores your Google Cloud secrets.

You can connect your Lovable app to Microsoft Fabric to work with data from Lakehouses, Warehouses, SQL databases, and mirrored databases. This lets your app query, and sometimes change, your data through a single connection.

You can connect your Lovable app to Notion to read and write content from your Notion workspace. This lets you build apps that use Notion pages and databases as their content source or to store data.

You can connect your Snowflake data platform to Lovable to build apps that query your data securely. This lets your Lovable apps run SQL, use the SQL REST API, and work with your Snowflake data without embedding passwords.

You can connect your Lovable app to the Lovable API to manage your Lovable projects and workspaces from within your own custom tools. This lets you build dashboards, admin pages, or automation tools that interact with your Lovable account.

Connect your Lovable app to Xero to work with your accounting data like contacts, invoices, and financial reports. This lets you build tools for finance dashboards, invoicing, and internal operations using live Xero information.

You can connect any online service or tool that uses a standard way to talk to other programs (a REST API) to your Lovable workspace. This lets everyone in your team use that service in their projects, just like Lovable's built-in connections.

View, edit, and manage your app's built-in database (Cloud): browse tables, edit records, run SQL, review security policies, and restore backups.

This guide shows you how to move your Lovable app's frontend or backend to your own hosting, giving you more control over how it runs. You can choose to move parts of your app or the entire thing, depending on your needs.

Edge functions are small programs that run on Lovable's servers to handle tasks your app can't do in a user's browser, like processing payments or sending emails. Lovable automatically writes, deploys, and scales these functions based on your requests in the project chat.

Configure email sign-in for your app's built-in backend (Cloud): confirmation, password rules, one-time codes, and sending limits.

This page answers common questions about Lovable, covering what you can build, how plans and credits work, managing your account, and security. It clarifies that Lovable builds web apps, not native mobile apps, and you own all the code it creates.

You can check the status and details of a security scan for your project. This tells you when it ran and what checks were performed, but not the actual security issues found.

You can get a summary of security issues across all your projects in Lovable, helping you decide which ones need attention first. This includes problems like public apps with security flaws, unaddressed personal data findings, projects shared externally, and projects owned by inactive team members.

Lovable protects your connection details by storing them securely and using a special gateway for most connections. This gateway acts as a middleman, handling authentication and ensuring your app only sees what the connected account can see.

Jobs are tasks your app runs automatically in the background, like sending daily emails or cleaning up data. This page shows you how to see what jobs are running, check their history, and turn them on or off.

You can get a list of all security issues found in a specific scan of your project. This includes issues that were found before, or have been marked as fixed or ignored.

You can get a list of all security scans that have run on your project, ordered from newest to oldest. This helps you keep track of your project's security history.

This feature helps you see all the projects in your workspace, along with their security risks, how active they are, and how they are published. It's like a dashboard for understanding the security and activity of all your projects at a glance.

Logs help you understand what's happening in your app's backend, like requests, errors, and database activity. You can use them to find out why something isn't working right.

The Lovable API lets you manage your Lovable projects and workspace from your own tools. You can use it to deploy projects, check security, and embed projects in other products.

Lovable Cloud is a built-in backend that hosts your app and provides essential services like a database, user logins, and file storage without any setup. You describe what you want, and Lovable builds both the app's look and its backend features.

Lovable Enterprise helps large organizations build and ship AI apps securely and at scale. It provides advanced controls for identity, security, compliance, and data management that security teams expect.

This page explains how to control who can join your Lovable workspace and how they log in, using your company's email domains and login systems. You can set up automatic ways for team members to join and ensure everyone uses your company's approved login method.

MCP registries let your team easily find and connect to approved AI tools without manually typing in website addresses. Your workspace owner or admin sets up this directory once, and then everyone can pick the tools they need.

Let users sign in to your app with their phone number and an SMS one-time code, using your own SMS provider.

This page helps you control who can access your projects, publish content, and share information across your Lovable workspace. It also covers settings for security checks and how to manage old projects.

The Security view helps you find and fix security problems in your Lovable project, like vulnerable code or outdated dependencies. It shows you scan results and lets you ask Lovable to help fix issues before and after you publish your app.

See what drives your project's run credit usage across hosting and the built-in backend (Cloud), and how monthly grants work.

You can make all your apps use a consistent web address pattern that includes your company's name. This helps your apps look more professional and makes them easier to recognize.

You can use Aikido to run AI-powered penetration tests on your Lovable projects. This helps find real security weaknesses by simulating attacks, and generates reports for compliance.

You can automatically check your Lovable projects for security problems like outdated software parts and risky code. This helps you find and fix issues before your project goes live.

Secrets are a safe place to store important keys and passwords for your app, like API keys, so they don't show up in your code or browser. Lovable automatically uses these secrets in your app's backend when it runs.

To keep your Lovable app safe, always make sure sensitive information and important checks happen on the server, not in the user's browser. This prevents people from easily finding your secrets or bypassing your rules.

Security insights helps you find projects in your Lovable workspace that need attention for security or ownership issues. It combines various signals to prioritize which projects you should review first.

Lovable helps protect your apps by automatically scanning for security issues during development and before publishing. It offers built-in scans, optional integrations, and tools to help you fix findings and ensure your app is secure.

You can send emails from your own domain for things like account access and app notifications, making them look professional and trustworthy. Lovable handles all the technical setup for you, so your emails are more likely to reach inboxes.

Sensitive data scanning helps you find and manage personal information like names, addresses, or credit card numbers in your Lovable project. It can check new messages as they are sent and scan existing project data like chat history or your built-in database.

You can set up Single Sign-On (SSO) for your Lovable workspace so your team can log in using their company credentials from providers like Okta or Auth0. This makes logging in easier and more secure for everyone in your workspace.

Lovable provides built-in storage for your app's files, like photos or documents. You can tell Lovable what files your app needs and where they should go, and it handles the setup.

You can connect your Lovable project to Bitbucket Cloud to automatically save your code, work with others, and deploy it elsewhere. This creates a two-way sync, so changes in Lovable go to Bitbucket, and changes in Bitbucket come back to Lovable.

You can connect your Lovable project to GitHub to automatically save your code there and work with others. This lets you keep a copy of your project outside Lovable, collaborate with developers, and use GitHub's tools.

The Trust Center creates a public page for your app that shows security checks Lovable has verified. This helps you share evidence of your app's security with customers, investors, and reviewers without you having to write or update it yourself.

Two-factor authentication (2FA) adds an extra layer of security to your Lovable account by requiring a one-time code when you log in, in addition to your password or other login method. This protects your account even if someone gets your password.

Lovable automatically handles user sign-up and login for your app, including various sign-in methods like email, Google, and Apple. You can manage users, customize login options, and control who can access your app directly within Lovable.

Verify your company's email domain with Lovable by adding a special record to your domain's settings. This unlocks advanced features like single sign-on, automatic user setup, and custom app links.

Workspace admin settings let you control how your team works in Lovable, from who can access what to how projects are built and secured. These settings apply across your entire workspace and define defaults for all members.

The Workspace Security Center helps you keep an eye on security risks across all your projects in one place. It shows you security issues, scan results, and secrets, helping you decide which projects need attention first.

This document tells me, the Lovable documentation agent, how to write helpful and accurate documentation for you. It ensures that all information is clear, correct, and easy for anyone to understand, without using technical jargon.

You can build an online store by connecting Lovable to Shopify, either by creating a new store or linking an existing one. This lets you use AI to add products, manage details, and launch your e-commerce site.

Chat connectors let Lovable understand your existing tools like Notion or Linear, so it can use your real work to build things for you. This means Lovable can create prototypes, pages, or workflows that match your team's actual documents and data.

You can connect your own custom servers that speak the Model Context Protocol (MCP) to Lovable. This lets Lovable use information from your internal tools, private APIs, or custom data sources when you chat with it.

You can connect your Lovable app to ElevenLabs to add voice AI features like turning text into speech, transcribing audio, or creating sound effects. This lets your app deliver spoken responses or interact with users through voice.

You can connect your Lovable app to Brevo to send emails, manage contacts, and run marketing campaigns. This is useful when your app needs more advanced messaging features than Lovable's built-in email.

You can connect your Lovable app to Fireworks AI to use its advanced AI features like text and image generation, or to fine-tune models. This lets your app use specific open models or custom models hosted on Fireworks AI.

You can connect your Lovable app to Google Ads to manage your advertising campaigns directly from your project chat. This lets you set up ads, track how well they're doing, and adjust them without leaving Lovable.

You can connect your Lovable app to Google Maps Platform to add maps, location search, and routing features. You can use a quick managed connection for prototyping or your own Google API keys for production apps and custom domains.

You can connect your Lovable app to Google services like Gmail, Sheets, Calendar, and Drive to automate tasks and manage data. This lets your app read and send emails, update spreadsheets, create calendar events, and handle files using a shared Google account.

You can connect your Lovable app to Granola to automatically get meeting notes, summaries, and transcripts from your Granola workspace. This lets your app use meeting information to build features or automate tasks.

You can connect your Lovable app to KLIPY to easily add features like searching for GIFs, stickers, and short videos, or creating AI emojis. This connection works for both your building process and your finished app.

You can connect your Lovable app to Lightspeed Retail X-Series to work with your store's products, inventory, customers, and sales data. This lets you build tools like inventory dashboards or customer history portals using your Lightspeed information.

You can connect your Lovable app to Logo.dev to easily show company logos in your app. This lets your app display logos for companies, stock tickers, or crypto symbols directly in the browser.

Connect your Lovable app to Looker to use your analytics team's existing data definitions for building dashboards and reports. This lets your app query metrics without recreating calculations, using a shared connection for both development and published apps.

Connect your Lovable app to Mailgun to send emails like receipts or notifications using your own verified domain. This lets your app send emails programmatically and track their delivery.

You can connect your Lovable app to Perplexity, an AI search engine, to get cited answers from live web, academic, or financial sources. You can either use Lovable's managed connection for basic web search or your own Perplexity API key for full features like deep research and specific search modes.

You can connect your Lovable app to Power BI to use the same numbers and calculations from your Power BI reports. This lets your app show consistent business data without rebuilding complex logic.

You can connect your Lovable app to Replicate to use many different open-source AI models for generating images, video, audio, and text. This is useful when your app needs a specific AI model not built into Lovable.

You can connect your Lovable app to Resend to send emails like order confirmations or newsletters from your own verified domain. This lets your app send emails as part of its normal functions, using your Resend account.

Connect your Lovable app to Semrush to use its SEO data, like keyword research and domain analytics, directly within your deployed app. This lets your app show SEO metrics, track keywords, or build dashboards using your Semrush account information.

You can connect your Lovable app to Slack to send messages, read channels, and automate tasks within your team's communication. You can also add your Lovable app directly to Slack as its own agent, allowing teammates to interact with it by mentioning it or sending direct messages.

Lovable helps your app show up in search engines like Google and AI search like ChatGPT by providing tools to check and fix common issues. You can audit your project, research keywords, and connect a custom domain to improve its visibility.

This guide helps you put your Lovable project on your own web address, making it live and findable by others. It covers publishing your project, getting a custom domain, and making sure search engines can find it.

You can turn your ChatGPT conversations into working apps by tagging Lovable in your chat. This lets you brainstorm and refine your app idea in plain language before Lovable builds it for you.

The Lovable Model Context Protocol (MCP) server lets your AI tools like ChatGPT or Claude manage your Lovable projects. You can create, edit, and deploy apps using natural language commands directly from your AI client.

This page explains how workspace admins control which external tools and services (called 'connectors') are available for people to use in Lovable projects and chats. It also covers who can create new connections to these tools and who can use existing connections.

Lovable may use your project content to improve its AI models, but you can stop this. This guide shows you how to prevent your data from being used for AI training.

You can make your Lovable app show up better in search engines like Google and AI tools like ChatGPT. Lovable helps you check your app for common issues, fix them easily, and research what people are searching for.

Lovable can automatically check your app for problems on a schedule, like broken features or errors visitors encounter. It tells you about these issues so you can decide if Lovable should help fix them.

Project settings let you manage all the important details of your Lovable app, like its name, web address, and how it works with other tools. You can find these settings in various places within the Lovable editor or dashboard.

You can make your Lovable app available to AI assistants like ChatGPT and Claude, so users can ask the assistant to use your app's features. Lovable creates a special server for your app that lets AI assistants discover and use its actions.

You can use your own web address (custom domain) for your Lovable project instead of the default one. This makes your site look more professional, easier to find in searches, and simpler for people to remember.

Subagents help Lovable handle big tasks by splitting them into smaller, focused investigations like research or code review. They work independently and report back to the main Lovable agent, making complex projects easier to manage and understand.

You can move a domain you already own from another provider to Lovable. This makes Lovable responsible for managing your domain, including its yearly renewals and connections to your projects.

App + chat connectors let your Lovable app talk to other tools like Slack or Google Sheets. You connect a tool once, and your app can use it to send messages, read data, and take actions for your users.

You can build apps in Lovable that run inside your company's Microsoft environment, using your existing Microsoft work sign-in and IT rules. This is great for internal tools that need to access data from Microsoft services like SharePoint or Dynamics 365.

You can connect your Google Business Profile to Lovable to manage your business locations, opening hours, reviews, and posts directly. This allows you to keep your business information current and respond to customers easily.

You can connect your Lovable app to Contentful to get published content like text, images, and entries from your Contentful space. This lets you build apps where content editors manage everything in Contentful and your app displays it.

You can connect your Lovable app to LinkedIn to get basic profile information, email addresses, and publish posts on behalf of a user. This is useful for apps that need professional identity, content sharing, or LinkedIn-based workflows.

You can connect your Lovable app to TikTok to get information about a creator's profile and their public videos. This lets you build tools like dashboards or content portfolios for a specific TikTok account.

Lovable gives you many choices for how your app is hosted and where your data lives, so you're never stuck. You can keep everything on Lovable for simplicity, or move parts of your app to other services or your own servers.

After you start publishing your project, you can check its progress and final outcome. You'll need the project ID and the deployment ID to do this.

Groups help you organize people in your Lovable workspace into teams, making it easier to manage who can see and work on projects and published apps. Instead of adding individuals one by one, you can give access to an entire group at once.

Lovable automatically hosts your app when you publish it, handling all the technical details like servers and security. Your app will be available globally, load fast, and scale with your visitors without extra setup.

You can set up a private place within Lovable to store your own special software packages, like shared code or design elements. This keeps them private and secure while making them easy for all your Lovable projects to use.

The preview in Lovable shows your app running live as you build it, letting you test how it looks and works on different devices. You can also share a special link for others to see your progress without needing a Lovable account.

You can see how people are using your published Lovable app, including how many visits it gets, which pages they look at, and where they come from. This helps you understand if your app is reaching people and how they interact with it.

A project in Lovable is like a single app you're building, holding all its parts like the chat, live preview, and code. You can create, organize, and publish these projects, and manage who can access or own them.

This feature lets you build and make your Lovable project available to others. You can also control who can access your published app.

You can make your Lovable project a live website that anyone can visit by publishing it. This creates a shareable web address and lets you control who can see your app.

This guide helps your IT administrator set up your Microsoft account so people in your organization can publish apps built with Lovable to Microsoft Copilot. This is a one-time setup that takes about 20 minutes.

You can connect your Lovable project to a GitHub, GitLab, or Bitbucket account to automatically back up your code and work with it outside Lovable. This creates a two-way sync, so changes you make in Lovable appear in your code repository, and changes you push to the repository appear back in Lovable.

You can connect your Lovable project to GitLab to automatically save your code there, making it easier to back up, work with others, and use outside Lovable. This connection keeps your project in sync between Lovable and GitLab, allowing changes in either place to update the other.

You can take your published Lovable project offline. This makes it unavailable to others, but keeps your audience and visibility settings for when you publish it again.

You can change who can access your published app without needing to rebuild it. This lets you quickly adjust whether your app is public, only for your team, or for specific people.

You can create special keys, called API keys, to let other tools or programs securely connect to your Lovable projects. These keys help manage what those tools can do and how much they can spend on AI features.

Lovable uses a single credit balance for everything you do, from building your app to running its AI features. You can check your credit balance, track usage, and add more credits in your Workspace settings.

When your app breaks, first try Lovable's built-in fix. If that doesn't work, clearly describe the problem and switch to Plan mode to find the real cause before making more changes.

The People tab is where you manage everyone who has access to your Lovable workspace. You can invite new people, change their roles, track their usage, and set individual spending limits.

You can add ways for your app to accept payments for digital products and software, like subscriptions or one-time purchases. Lovable handles the technical setup with Paddle or Stripe, so you can focus on what you're selling.

You can let people sign into your app using their company's existing login system, like Okta or Google Workspace. This makes it easier for them and gives their IT team control over who can access your app.

This page explains the basic rules for using the Lovable API, like where to send your requests and what information to include. It helps you connect your own tools to Lovable to manage your projects.

This page explains how to connect your Lovable projects to other software using the Lovable API. You'll learn how to send commands to Lovable from your own tools, like getting information or making changes.

This page helps you keep track of updates and new versions for the Lovable API. It lists the stable versions and the changes made in each one.

This page announces the first stable version of the Lovable API. It also tells you where to find a full list of all documentation pages.

Build secrets are encrypted, workspace-wide special keys that Lovable makes available to your projects only when they are being built. This is useful for things like installing private software packages that require a login before your app can even run.

Chats are your private conversations with Lovable where you can brainstorm ideas, use your connected tools, and create files, all outside of a specific project. You can then send any work you want built to a project when you're ready.

You can chat with Lovable directly in Slack to create new projects, update existing apps, and ask questions about your work. This lets you build and manage your Lovable projects without leaving your team's communication tool.

You can chat directly with Lovable using Telegram to build and manage your projects. This lets you work on your apps from your messaging app, just like you would on the Lovable website.

You can invite others to work with you on your Lovable projects or your entire workspace. Everyone sees changes as they happen, and you can control what each person can do.

Firecrawl helps your Lovable app get information from websites, even those that load content dynamically. You can use it to turn web pages into clean text or structured data, crawl entire sites, or search the web.

You can connect your Lovable app to Algolia to add powerful search features like instant results, typo correction, and filtering by categories or prices. This lets your app handle complex searches across large amounts of information much better than a standard database.

You can connect your Lovable app to Apify, a web scraping and automation platform, to run automated tasks and read the results. This lets your app scrape websites, automate browser actions, and display the collected data.

You can connect your Lovable app to Asana to automatically create and update tasks, read project data, and automate work tracking. This lets your app interact directly with your team's Asana workspace for things like intake forms, dashboards, and automated reminders.

You can connect your Lovable app to Ashby, a recruiting system, to manage jobs, candidates, and applications. This lets your app read and update hiring data directly from Ashby.

You can connect your Lovable app to Attention, a sales conversation platform, to read meeting details and scorecards, or write back updates and QA results. This lets you build tools like dashboards or coaching apps using your sales conversations.

You can connect your Lovable app to AWS Athena to run SQL queries directly on your data stored in Amazon S3. This lets you build dashboards, reports, and internal tools without needing to manage database servers.

You can connect your Lovable app to an Amazon S3 storage bucket to read and write various data files like CSVs and JSONs. This lets your app work with external data sources, batch exports, or user uploads directly from S3.

This connector lets your Lovable app interact with your organization's Microsoft Entra directory and Microsoft 365 data without a user needing to sign in. It's for building internal tools that manage or read data across your entire organization.

Connect your Lovable app to Calendly to manage scheduling, events, and booking flows. This lets your app read event details, create booking links, and cancel events directly from a connected Calendly account.

You can connect your Lovable app to Chargebee to manage customer subscriptions, invoices, and billing. This lets your app read and manage billing information, create checkout pages, and build internal tools for your team.

You can connect your Lovable app to Clay, a platform for sales and marketing data, to find people and companies, enrich data, and use Clay tables. This lets your app access live prospecting and enrichment data directly from Clay.

You can connect your Lovable app to Databricks to use your existing data for dashboards and tools. This lets your app run queries and manage resources in Databricks without needing to export data manually.

You can connect your Lovable app to Discord to send messages, see which servers your bot is in, and read recent messages in a channel. This lets your app interact with Discord for things like sending alerts or displaying information.

You can connect your Lovable app to Fireflies to automatically get meeting transcripts, summaries, and insights. This lets your app use information from your meetings, like who said what and what decisions were made.

You can connect your Lovable app to GatewayAPI to send SMS and RCS messages, track their delivery, and handle replies. This allows your app to send mobile notifications, alerts, and campaigns directly to phone numbers.

You can connect your Lovable app to GitHub to read and update things like repositories, issues, and pull requests. This lets you build tools and automations that use your GitHub data.

You can connect your Lovable app to GitLab to work with projects, issues, and other data. This lets you build apps that read or update information from GitLab.

You can connect your Lovable app to Gong to use data from sales calls, like transcripts and interaction stats. This lets you build apps that analyze customer conversations and sales team performance.

You can connect your Lovable app to Google Analytics to see how people use your app, like what pages they visit or buttons they click. This helps you understand your app's traffic and user behavior.

You can connect your Lovable app to HubSpot to manage customer information, track sales, and automate marketing tasks. This lets your app read and update customer data directly in HubSpot.

You can connect your Lovable app to incident.io to manage incidents, alerts, and on-call schedules. This lets your app read and update operational data from incident.io.

You can connect your Lovable app to Inngest to add background jobs, scheduled tasks, and multi-step workflows. This lets your app do things like send delayed notifications, process data on a schedule, or handle complex tasks outside of immediate user requests.

You can connect your Lovable app to Lexware, an accounting platform, to manage things like contacts, invoices, and payments. This lets your app read or update your business's financial information directly from Lexware.

Connect your Lovable app to Linear to create and update issues, read project data, and build workflows. This lets your app interact directly with your team's Linear workspace for tasks like bug reporting or sprint dashboards.

Connect your Lovable app to Mapbox to add interactive maps, turn addresses into coordinates, or calculate routes and directions. This lets your app show maps and location features using Mapbox's services.

You can connect your Lovable app to various Microsoft 365 services like Outlook, Teams, or OneDrive. This lets your app work with data from these services using a shared Microsoft account connection.

You can connect your Lovable app to Parallel to search the web, read pages, and do deep research with cited sources. This lets your app get current information from the internet instead of relying on old data.

You can connect your Lovable app to Pipedrive to manage your sales data like deals, contacts, and leads. This lets you build custom tools such as sales dashboards or lead management systems that interact with your Pipedrive information.

You can connect your Lovable app to PostHog to track what users do, use feature flags to show different things to different users, and send data from your app's backend. This lets your app use PostHog for product analytics and experiments.

You can connect your Lovable app to PrestaShop to read and manage your online store's products, orders, customers, and inventory. This lets you build custom tools like dashboards or catalog managers that use your store's data.

Connect your Lovable app to QuickBooks to work with your company's financial data like customers, invoices, and payments. This lets you build apps that track finances, manage invoices, or create new accounting records.

You can connect your Lovable app to Salesforce to read and update customer information like accounts, contacts, and cases. This lets you build internal tools or customer portals that use your live Salesforce data.

You can connect your Lovable app to Sevdesk, an accounting platform, to manage things like contacts, invoices, and orders directly from your app. This lets you build custom tools that interact with your existing Sevdesk data.

You can connect your Lovable app to Tally to create forms, get form submissions, and manage form workflows. This lets your app interact with Tally forms, for example, to build dashboards or manage leads.

You can connect your Lovable app to Telegram to send and receive messages through a Telegram bot. This lets your app automate tasks like sending notifications, responding to user messages, and guiding users through workflows directly within Telegram.

You can connect your Lovable app to the dbt Semantic Layer to easily get important numbers and trends that your data team has already defined. This lets your app show consistent data without you needing to write complex database code.

You can connect your Lovable app to Twilio to send texts, make calls, and use WhatsApp for communication. This lets your app interact with users directly through their phones.

You can connect your Lovable app to Twitch to build custom tools like stream overlays, dashboards, and community features. This lets your app react to live events and data from a Twitch channel.

Connect your Lovable app to Wave to manage your business's accounting and invoicing data. This lets your app read and update customers, invoices, products, and more directly from your Wave account.

Connect your Lovable app to WhatsApp Business to send and receive customer messages directly through WhatsApp. This lets your app handle customer support, send notifications, and manage message templates.

You can connect your Lovable app to Wix to read and manage your Wix sites, online stores, bookings, customer data, and content. This lets you build custom tools and workflows that use your Wix account information.

You can connect your Lovable app to your WooCommerce store to manage products, orders, customers, and reports. This lets you build custom tools like dashboards or inventory managers that interact directly with your store data.

You can connect your Lovable app to your own WordPress website to manage content like posts, pages, and media. This lets you build custom apps that display or update information on your WordPress site without needing to log into WordPress directly.

Connect your Lovable app to WordPress.com to manage content like posts and pages directly from your WordPress.com sites. This lets your app display content that editors update in WordPress without changing app code.

Connect your app to Workday so each user can see their own HR data, like worker profiles or time off, directly within your app. This is useful for building tools like employee portals or team directories that show information based on each person's Workday permissions.

You can connect your Lovable app to X (Twitter) to read public information like user profiles and recent posts. This lets you build features like dashboards or search tools within your app.

You can connect your Lovable app to Zoho Books to manage your accounting records like customers, invoices, and expenses. This lets you build apps that show or update your financial data without needing to open Zoho Books directly.

You can connect your Lovable app to Zoho CRM to read, search, create, and update customer records like leads, contacts, and deals. This connection works for both building your app in chat and for your finished app.

You can connect your own Stripe account to your Lovable project to handle payments directly. Lovable will use your Stripe API key to build checkout flows, subscriptions, and a customer portal for your app.

You can control who sees and works on your Lovable projects in the editor, separate from who can see your published app. By default, new projects are only visible to people in your workspace, but you can make them more private or share them with specific individuals.

Create a Lovable account to start building web applications using natural language. This account is your personal identity for logging in, managing your profile, and accessing project workspaces.

You can get a special web address (URL) for your project's preview that lets others see it without needing a Lovable account. This URL is temporary and only works on a specific website you choose.

The Lovable dashboard is your starting point to create new projects or chats, and to manage your workspace settings and existing work. You can type a description of what you want to build or chat about, or use various menus to access more options.

Skills let you teach Lovable how to handle tasks you do often, like checking a launch list or writing a specific type of content. You set them up once, and Lovable can use them across all your projects when the task comes up.

You can give Lovable persistent instructions about your project or your team's coding rules. This helps Lovable understand what you want without you having to repeat yourself in every conversation.

You can permanently remove a workspace you no longer need, which also deletes all projects and members within it. Lovable keeps it recoverable for 60 days in case you change your mind.

You can permanently delete your Lovable account, but there's a 30-day period where you can change your mind and get it back. If you own workspaces or projects, you need to transfer them before deleting, or they will be removed too.

You can delete a project, but you need a Business plan or higher to do so. If your project has a trash feature, you might be able to restore it later; otherwise, it's gone for good.

You can now make changes to your app directly from the preview screen using a special toolbar. This lets you select parts of your app, edit text, draw notes, or leave comments without needing a separate editing panel.

You can embed editable Google Docs, Sheets, or Slides directly into your Lovable app using an iframe. This lets people edit the original Google file while your app adds extra features around it.

Drafts let you try out changes to your project in a separate copy without affecting the main version. You can compare different ideas and then choose to add the ones you like to your project or discard them.

You can quickly find any project in Lovable using a quick search tool or by filtering and sorting your project lists. This helps you get to the right project fast without sifting through everything.

You can ask Lovable to analyze data, create documents, or transform files directly in your project chat. Lovable runs scripts in an isolated environment and returns the result as a downloadable file or inline analysis.

You can get all the details about a specific project in Lovable, like its name and settings. This helps you check on your project's status and information.

You can get information about how many people visit your published project's website. This data is provided as a timeline for a specific period you choose.

You can get a summary of how people are using your published project, including which pages they visit most, where they come from, what devices they use, and their countries. This helps you understand your audience and popular content.

You can get live visitor numbers for your published project, showing how many people are active right now and how many visited each minute over the last half hour. This helps you see how popular your project is in real-time.

This lets you get all the main details about your Lovable workspace, like its security rules, how many people can use it, and billing information. You'll need a Business plan or higher to use this feature.

You can get a history of how much traffic your Lovable workspace has received. This includes traffic from projects you might have deleted.

You can get details about a specific person in your Lovable workspace, like their display name and when they joined. This helps you confirm their active membership and see their profile information.

Build mode lets Lovable make changes directly to your project, handling the entire process from understanding your request to verifying the outcome. You tell Lovable what you want, and it works to implement and fix things in your app.

Insights shows workspace owners and admins how people are using Lovable in their workspace. It helps you understand which apps are popular, who is building them, and how activity changes over time.

You can connect almost any external service to your Lovable app, even if Lovable doesn't have a ready-made connection for it. You can either create a custom connection that Lovable manages, or you can ask Lovable to connect the service directly to your app's code.

This feature helps you find and list any personal information (like names or addresses) that Lovable has detected in your project. It includes all findings, whether they are new, ignored, or already fixed.

You can get a list of all your projects across different workspaces. This helps you keep track of everything you're working on in one place.

You can get a list of all the groups in your Lovable workspace. This is useful if you want to publish a project to a specific group of people.

You can get a list of all accepted members in your Lovable workspace, including their user ID, type, and display name. You can also search, filter by role or management type, and sort this list.

You can get a list of all the workspaces you have access to. This feature requires a Business plan or higher and a special permission on your API key.

Lovable Connectors link your project to external tools like Slack or Notion, handling how your app and project chat interact with them. You choose how to connect based on whether you need a shared account for your app, your personal context for building, or individual user accounts.

The Lovable desktop app lets you use Lovable on your computer, offering extra features like connecting to local tools and managing multiple projects easily. It's free and works on macOS and Windows, providing a faster, more integrated experience than the web version.

The Lovable mobile app lets you build projects, chat with Lovable, and review your work from your phone or tablet. It shares your account, projects, and credits with the web app, allowing you to pick up where you left off on any device.

A Lovable workspace is your team's central hub for all projects, members, billing, and settings. It allows everyone to share a single pool of credits for building apps, with options to manage individual usage.

You can organize your Lovable projects into folders to keep your workspace tidy and find things easily. This helps group related projects together, making navigation simpler.

Plan mode helps you plan larger or riskier changes by letting Lovable investigate your project and propose a detailed plan. You can review, edit, and approve this plan before any code is written, ensuring you agree with the approach.

You can leave comments directly on elements in your project's preview to discuss changes and give feedback. These comments can also be sent to Lovable's AI to act on your suggestions.

Remixing a project creates your own independent copy of it. This lets you duplicate your work, start from a template, or move a project between accounts.

You can make apps you build in Lovable automatically recognize your teammates who are already logged into Lovable, so they don't have to log in again. This lets your app know their name, email, and Lovable user ID without a separate login screen.

Lovable automatically saves every change to your project as a version. You can look at past versions, go back to an earlier state, or mark important versions to find them easily later.

You can tell Lovable to work on a big task until it's completely finished, even if it takes a long time. This is useful for complex features that need a full solution without constant interruptions.

SCIM automatically manages who can access your Lovable workspace and what they can do, directly from your company's identity system. This keeps your user list and roles in Lovable always up-to-date without manual effort.

You can share your Lovable project with others in a few ways: invite specific people to work on it with you, create a special link for others to join as collaborators, or make a view-only link for reviews without giving editing access. This helps you get feedback or work together on your app.

Lovable offers Free and paid plans with different features and credit allowances for individuals and teams. You can manage your subscription, including upgrading, downgrading, or canceling, directly from your workspace settings.

This page explains how to get help with Lovable, including self-help options and how to contact the support team. What kind of support you get depends on your plan, with paid plans offering direct team help and Enterprise plans providing a dedicated account team.

Lovable provides different ways to check if your app works correctly, including browser testing for user-facing issues, frontend tests for specific UI parts, and backend verification for your server-side logic. You choose the right tool based on what part of your app you need to check.

You can ask Lovable to test your app in a real web browser to make sure everything works as expected. This helps confirm that buttons, forms, and different screen sizes all behave correctly.

You can change your project's name or how it's shared with others. This won't affect who can use your published app, only its internal settings.

Upgrade your older Lovable project to a newer template called TanStack Start. This makes your pages load faster, improves how they appear in search results, and ensures social media links show correct previews.

You can change the fonts in your Lovable project by simply telling it which ones to use. You can pick from common fonts already on computers or choose any font from Google Fonts.

This page describes the building blocks for how Lovable's computer systems talk to each other, defining what information they can send and receive. It's like a dictionary for the Lovable API, showing the types of data used for things like projects, analytics, and errors.