# Lovable File Limit: 10 MB Code, 256 MB Chat, and 2 GB Storage

Lovable file limits refer to the maximum allowable file sizes for asset uploads (images, schemas, fonts) and the total file footprint supported within a Lovable web application project. While git code commits cap individual files at 10 MB to prevent bundle bloat, chat attachments support up to 256 MB on paid plans, and built-in storage accepts files up to 2 GB by default. Offloading large datasets and media archives to external cloud workspaces preserves build performance.

Source: https://fast.io/resources/lovable-file-limit/
Author: [Derek Labian](https://fast.io/authors/derek-labian/)
Last reviewed: 2026-10-28

## What Is the Lovable File Limit Across Code, Chat, and Storage?

As of October 2026, Lovable enforces a strict `10 MB` per-file commit limit on repository code, chat attachments between `20 MB` and `1 GB` depending on account tier, and an application storage ceiling that defaults to `2 GB`. Lovable file limits refer to the maximum allowable file sizes for asset uploads (images, schemas, fonts) and the total file footprint supported within a Lovable web application project.

Understanding these boundaries requires recognizing that Lovable operates across four separate storage environments. Developers often confuse the files that live inside their git repository with the files attached to the AI chat interface, the files organized in the project Files tab, and the user uploads handled by the application backend. Each environment has distinct file size ceilings, storage mechanisms, and operational constraints.

The four functional file layers in Lovable include:

* Project Codebase and Git Commits: Files committed to the repository, such as components in `/src` or static assets in `/public`. These are subject to a strict `10 MB` per-file ceiling to prevent repository bloat and ensure fast client builds.
* Project Chat Attachments: Files uploaded directly to the prompt box to provide context for the AI agent. Upload limits scale from `20 MB` on the Free plan to `256 MB` on paid plans and `1 GB` on Enterprise.
* Project Files Tab and Collections: Reference documents, schemas, and AI-generated files (such as CSV exports, PDF reports, and slide decks) stored alongside the project. Uploads share the same `20 MB` to `1 GB` per-file caps, organized into `100` collections per project.
* Built-in Backend Application Storage: Cloud storage buckets powered by Supabase where runtime user uploads, profile photos, and document attachments live. Buckets accept files up to `2 GB` by default, configurable up to `5 GB`.

The table below summarizes the official file size boundaries, quantity allowances, and operational restrictions across Lovable environments as of October 2026:

| Platform Environment | Per-File Upload Limit | Quantity or Total Allowance | Primary Operational Constraint | Date Verified |
| :--- | :--- | :--- | :--- | :--- |
| Project Codebase Commits | `10 MB` per file | Unlimited repo files | Git commit ceiling to prevent Vite bundle bloat | October 2026 |
| Chat Attachments (Free Plan) | `20 MB` per file | Up to 10 files per message (15 MB image total) | Free plan context quota | October 2026 |
| Chat Attachments (Paid Plans) | `256 MB` per file | Up to 10 files per message (15 MB image total) | Pro and Business subscription quota | October 2026 |
| Chat Attachments (Enterprise) | `1 GB` per file | Up to 10 files per message (15 MB image total) | Custom contract allowance | October 2026 |
| Project Files Tab & Collections | `20 MB` to `1 GB` | Up to 100 collections, 500 files per collection | Project workspace reference storage | October 2026 |
| App Backend Storage (Default) | `2 GB` per file | Project bucket storage allocation | Default bucket upload size limit | October 2026 |
| App Backend Storage (Configured) | `5 GB` per file | Project bucket storage allocation | Configurable ceiling under More → Storage | October 2026 |
| Fast.io Intelligent Workspaces | `25 GB` to `100 GB` | Unlimited workspace files | External persistent storage with semantic search | October 2026 |

Understanding each lovable dev file limit across repository assets and cloud storage helps teams structure their applications effectively. Whether evaluating the lovable upload limit in backend storage or attaching reference designs to prompts, knowing these thresholds prevents build disruptions.

## Why Does Lovable Block Large Code Files?

Single files larger than 10 MB cannot be saved into your project’s code, usually after adding large images, videos, or other media. When a developer or agent attempts to commit an oversized asset into `/public` or `/src/assets`, Lovable halts the save operation and presents an explicit error message stating that the file exceeds the `10 MB` per-file commit limit.

Lovable enforces individual asset upload boundaries to keep web bundles lightweight. Applications generated in Lovable use modern frontend tooling, primarily Vite, React, TypeScript, and Tailwind CSS. During client build cycles, Vite analyzes code dependencies, optimizes asset imports, and outputs static bundles for browser delivery. Storing massive assets directly in the codebase introduces several severe technical bottlenecks:

* Bundle Bloat and Slow Cold Starts: When large images or binary blobs are imported directly into JavaScript or TypeScript components, bundlers attempt to inline or package them, resulting in massive JavaScript chunks that degrade Core Web Vitals, particularly Largest Contentful Paint (LCP).
* Context Token Saturation: Uploading large static datasets directly into Lovable apps consumes project context and degrades build speeds. When the AI agent plans modifications or refactors features, it inspects repository directory trees and file contents. Oversized files bloat the context window, leaving fewer tokens available for complex logic and causing reasoning degradation.
* Git Repository Degradation: Web-based development containers clone, branch, and sync repository histories. Large binary assets cause git repositories to swell, slowing down commits, merge actions, and GitHub synchronization.

To identify oversized files that risk triggering the `10 MB` commit boundary, developers working with a cloned Lovable repository can run a quick terminal scan:

```bash
find . -type f -not -path '*/.*' -size +5M -exec ls -lh {} +
```

While there is no documented repository file count cap, the practical lovable codebase size limit is governed by Vite bundling speeds and upstream context window budgets. To stay well below the lovable max asset size for code commits, developers should adhere to three core asset practices:

1. Compress and Convert Raster Images: Convert uncompressed PNG and JPEG files to modern WebP or AVIF formats. Converting images can reduce asset sizes by more than half without visible loss of sharpness.
2. Vectorize Graphic Elements: Replace complex raster icons and logo banners with clean SVG markup, which renders crisply at any display resolution while consuming negligible disk space.
3. Decouple Data Fixtures from Code: Avoid committing multi-megabyte JSON or CSV files into `/src/data`. Instead, load structured datasets dynamically from backend database tables or external object storage via API endpoints.

## What Are the Upload Limits for Lovable Chat and Project Knowledge?

Attaching files directly in the project chat provides the AI agent with visual specifications, schema definitions, brand guidelines, and reference code. Lovable reads what you attach, including images, PDF, Word, Excel, and PowerPoint files, alongside audio recordings.

The file upload limits for chat attachments depend strictly on account plan tiers:

* Free Plan: Files can be up to `20 MB` each.
* Paid Plans (Pro and Business): Files can be up to `256 MB` each.
* Enterprise Plan: Files can be up to `1 GB` each.

Across all tiers, users can attach a maximum of `10` files per individual message. Images attached to a single message can total up to `15 MB`, and Lovable compresses large images to optimize transmission.

File preview capabilities within the Lovable interface follow specific formatting boundaries:

* Code Files: Render directly inside the preview drawer with syntax highlighting and automatic language detection.
* Text and Markdown Files: Render as formatted text. However, text-based files exceeding `1 MB` cannot be previewed in the UI, although they continue to function properly as prompt context.
* PDF and ZIP Archives: Have no preview size limit and can be inspected or unpacked by the agent.

Alongside chat attachments, Lovable provides a dedicated Files tab where uploaded documents live alongside AI-generated outputs, such as CSV spreadsheets, PDF summaries, and presentations. Files in this tab do not live in your git code and do not bloat repository commits. Lovable allows users to organize these files into collections. Each project supports a maximum of `100` collections, and each collection can hold a maximum of `500` files.

While attaching large documents into chat is straightforward, developers must respect upstream model context limits. Lovable relies on frontier large language models, primarily Claude Sonnet series models with an effective 200,000 token context window ceiling. Attaching a `50 MB` CSV dataset or a 200-page PDF manual consumes tens of thousands of tokens before the conversation even begins.

When context saturation occurs, the model begins discarding earlier prompt instructions, hallucinating interface types, and generating conflicting component updates. For large reference libraries, technical documentation corpora, or historical product logs, feeding raw documents through chat attachments is inefficient. Those assets belong in an indexed retrieval layer rather than active conversational memory.

## How Does Built-In App Storage Work in Lovable?

Your app's storage accepts files up to 2 GB by default, which can be configured up to 5 GB. Unlike project code or chat context, built-in application storage represents runtime cloud storage for end users of your deployed software, such as profile photos, invoice attachments, and user-generated media.

Under the hood, Lovable provisions cloud storage buckets through its integrated Supabase backend. Developers configure storage settings directly through the graphical user interface:

1. Open the project dashboard and select `More → Storage` from the top navigation bar.
2. Locate the `Upload size limit` field at the top of the Storage view.
3. Enter a new numeric threshold between `1 MB` and `5 GB`.
4. Choose the appropriate unit (`MB` or `GB`) from the dropdown selector.
5. Click `Save`. The updated size ceiling applies immediately to all file upload actions across your application.

Storage organization relies on buckets, which fall into two security categories:

* Private Buckets (Default): Files are secured by Row Level Security (RLS) policies and are accessible only to authenticated users with explicit access permissions. When users download files from private buckets, Lovable generates temporary signed URLs that expire automatically after one hour.
* Public Buckets: Files are accessible to anyone possessing the direct URL. However, public storage buckets are blocked by default on all plans for security reasons. Workspace owners and administrators can toggle this restriction off under Privacy & security settings if public asset delivery is required.

Bucket names must follow strict naming rules: between 3 and 63 characters, containing only lowercase letters, numbers, and hyphens. Once created, a bucket name cannot be renamed.

While Lovable's built-in backend storage is convenient for typical web applications, it introduces architectural constraints that teams must account for:

* Paused Project Billing: Pausing a project pauses database compute, but storage usage continues because files remain stored in the cloud. To eliminate storage charges completely, developers must download their files and delete the storage buckets.
* Shared Lifecycle with Database: Storage runs on the same backend infrastructure as user accounts and database tables. Selecting `Remove storage` in project settings permanently deletes the database, user authentication records, and stored files simultaneously.
* Export Exclusions: Automated database exports contain database schemas and table rows, but they do not include files stored in storage buckets. Developers must download bucket files separately before migrating or deprecating backend services.

## How Do You Host Large Datasets and Media Outside Lovable?

Offloading large files to external cloud workspaces preserves Lovable project performance and keeps web application builds fast. When applications require multi-gigabyte video libraries, extensive PDF archives, or massive machine learning datasets, attempting to store them inside the Lovable codebase or app buckets creates performance friction.

Developers evaluating external storage architectures typically consider three primary options:

1. Cloud Object Storage (Amazon S3, Cloudflare R2, Google Cloud Storage): Useful for delivering high-bandwidth static media via global CDNs. However, object storage requires configuring custom IAM credentials, setting up CORS policies, managing upload signatures, and writing custom API middleware. Raw object storage also lacks native document intelligence or agentic collaboration features.
2. Consumer Cloud Drives (Google Drive, Dropbox, Box, OneDrive): Convenient for human file sharing, but inadequate for programmatic agent workflows due to complex OAuth token lifecycles, aggressive API rate limiting, and the absence of semantic indexing.
3. Intelligent Cloud Workspaces with Fast.io: Combines scalable cloud storage with built-in retrieval-augmented generation (RAG), structured metadata extraction, and native Model Context Protocol (MCP) tooling for AI agents.

Fast.io provides shared, organization-owned workspaces designed for agentic teams and modern web applications. Instead of forcing files into a Lovable repository or consuming token context with massive prompt attachments, developers host assets in Fast.io workspaces:

* High-Capacity Upload Boundaries: Fast.io supports single-file uploads of `25 GB` on the Starter plan, `50 GB` on the Business plan, and `100 GB` on the Enterprise plan. High-resolution product videos, machine learning training corpuses, and multi-gigabyte ZIP archives upload cleanly without chunking workarounds.
* Intelligence Mode and Built-in RAG: Enabling Intelligence on a Fast.io workspace triggers automatic indexing for hybrid search (full-text, semantic meaning, and metadata value filtering). AI agents query indexed documents and receive citation-backed answers without configuring external vector databases or chunking pipelines.
* Metadata Views: Turn unstructured documents into live, queryable databases. Fast.io automatically extracts structured fields (such as contract dates, counterparties, invoice totals, or image tags) into typed schemas (Text, Integer, Decimal, Boolean, URL, JSON, Date & Time). Teams can explore document data through [Metadata Views](/product/document-data-extraction/) and query extracted rows via MCP or REST APIs.
* Native MCP Integration: Coding agents (such as Claude Code, Cursor, Cline, and Devin) connect directly to Fast.io using Streamable HTTP at `https://mcp.fast.io/mcp/code`. General personal agents and Claude applications connect at `https://mcp.fast.io/mcp/tools`. AI assistants can search workspaces, retrieve relevant text extracts, and execute file operations without loading entire documents into the active LLM context window.
* Cloud Sync: Connects Google Drive, Dropbox, Box, and OneDrive folders to a workspace, one-way or two-way, on a schedule or on demand. Teams can centralize assets from existing corporate repositories into an indexed workspace with zero local input/output overhead.
* Ownership Transfer: Enables AI agents or contractors to provision organizations, build workspaces, configure shares, and transfer ownership to human clients while retaining administrative access.

Connecting a Lovable application or an external coding agent to Fast.io storage requires minimal setup. The TypeScript snippet below demonstrates how a web application can query Fast.io workspace files using the unified storage search endpoint:

```typescript
interface SearchResult {
  file_id: string;
  name: string;
  size: number;
  snippet?: string;
  download_url: string;
}
export async function searchWorkspaceAssets(
  workspaceId: string,
  query: string,
  apiKey: string
): Promise<SearchResult[]> {
  const url = `https://api.fast.io/current/workspace/${workspaceId}/storage/search/?search=${encodeURIComponent(query)}`;
  const response = await fetch(url, {
    method: 'GET',
    headers: {
      'Authorization': `Bearer ${apiKey}`,
      'Accept': 'application/json',
    },
  });
  if (!response.ok) {
    throw new Error(`Failed to query Fast.io workspace: ${response.statusText}`);
  }
  const data = await response.json();
  return data.results || [];
}
```

Fast.io leaves Lovable's upload limits intact while adding a secure, searchable home for the files that do not fit into code commits or context prompts.

Monthly subscriptions on Fast.io start with a 14-day free trial that requires a credit card. Plans include Starter at `$9.99/mo` (3 seats, `250 GB` storage, 5 workspaces, `100,000` credits a month), Business at `$49.99/mo` (10 seats, `5 TB` storage, 50 workspaces, `600,000` credits a month), and Enterprise at `$199.99/mo` (30 seats included, `25 TB` storage, 200 workspaces, `3,000,000` credits a month). Annual plans are also available and start paid, with no trial. Additional credits cost `$10` per 100,000 credits, storage beyond the plan is 1.5 cents per GB a month, and extra bandwidth is 4 cents per GB. Teams can review full platform capabilities on [Fast.io pricing](/pricing/) and explore integration guides through [Fast.io storage for agents](/storage-for-agents/).

## Frequently asked questions

### What is the file upload limit in Lovable?

Lovable enforces three distinct upload boundaries: a `10 MB` per-file commit limit for codebase assets, chat context attachment limits scaling from `20 MB` on the Free plan to `256 MB` on paid plans and `1 GB` on Enterprise, and a `2 GB` default limit (configurable up to `5 GB`) for built-in application storage.

### Can I upload large datasets to Lovable?

You can attach datasets up to `256 MB` on paid plans (or `1 GB` on Enterprise) in project chat for data analysis and file generation. However, committing large CSV or JSON datasets directly into code repositories triggers the `10 MB` commit limit and degrades build speeds. Large datasets should be stored in an external intelligent cloud workspace.

### How do I host large media files for my Lovable application?

For end-user uploads up to `2 GB` (or `5 GB` configured), use Lovable's built-in storage buckets under More → Storage. For high-resolution video streaming, raw audio archives, or cross-project asset libraries, host assets in an external cloud workspace like Fast.io or a dedicated CDN, referencing files through external URLs.

### Why did my Lovable git commit fail with an asset size error?

Lovable prevents single files exceeding `10 MB` from being committed into repository code to keep Vite client bundles fast and lightweight. This error occurs when uncompressed images, video clips, or binary data are added to `/public` or `/src/assets`. Compress the assets or host them externally.

### How do I change the upload size limit in Lovable application storage?

Open your project dashboard, navigate to More → Storage, locate the Upload size limit field at the top, enter a value up to `5 GB`, choose MB or GB, and click Save. The new size limit applies immediately.

### Do storage files get deleted if I remove my Lovable database?

Yes. Built-in storage runs on the same backend infrastructure as the database and user authentication. Selecting Remove storage permanently deletes the database, user accounts, and all stored bucket files simultaneously. Always export bucket files before removing backend services.

### What happens when a file exceeds Lovable's chat preview limit?

Text-based files larger than `1 MB` cannot be previewed in the Lovable chat interface, though the AI agent can still parse and use their content as conversational context. PDF and ZIP files have no preview size limit, and code files open with syntax highlighting.

## Sources

- [Lovable Documentation: Work with Lovable in the project chat](https://docs.lovable.dev/features/projects/chat): Single files larger than 10 MB cannot be saved into your project's code, usually after adding large images, videos, or other media.
- [Lovable Documentation: Storage](https://docs.lovable.dev/features/storage): Your app's storage accepts files up to 2 GB by default, which can be configured up to 5 GB.

## About Fast.io

Fast.io provides shared workspaces where people and AI agents work on the same files, with built-in semantic search and citation-backed chat over what they hold. Agents reach it through a remote MCP server, a REST API at https://api.fast.io/current/, and a command line client published on npm as @vividengine/fastio-cli. MCP setup is at https://mcp.fast.io/docs: Claude and most MCP clients connect to https://mcp.fast.io/mcp/tools, ChatGPT to https://mcp.fast.io/mcp/operations, and coding agents to https://mcp.fast.io/mcp/code.