Netlify Blobs vs Vercel Blob

Both products store unstructured data next to your app, and both drop the setup work of running your own bucket. They make different bets. Netlify Blobs is a key-value store with metadata and configurable consistency, provisioned the moment you deploy. Vercel Blob is S3-backed object storage addressed by URL, built for large public files served from a CDN. That split in design intent runs through the whole comparison: reach for a key-value database and Netlify Blobs fits; reach for public file hosting and Vercel Blob fits.

Which one fits depends on what you are storing and how you read it back. This guide compares them dimension by dimension, with the tradeoffs stated in both directions.

How each storage model works

Netlify Blobs is a key-value store. A key maps to a value (a string, JSON, an ArrayBuffer, or a Blob) plus optional metadata. Data lives in named “stores” that act as namespaces scoped to your site. Reads go through your functions, edge functions, or build; there are no public URLs (Netlify Blobs docs).

Vercel Blob is object storage addressed by pathname, backed by Amazon S3. Each object gets a URL. In public mode, anyone with that URL reads the file straight from the CDN; in private mode, reads go through your functions with a token (Vercel Blob docs).

Vercel’s model gives quick, direct access to blob data through a URL with no extra code. Netlify Blobs gives more control inside your own code: attach metadata, tie data to specific deploys, and get read-after-write correctness.

How uploads and reads work

Netlify Blobs:

import { getStore } from '@netlify/blobs';

const store = getStore('uploads');
await store.set('invoice-42', value, {
  metadata: { customer: 'acme', region: 'eu' },
  onlyIfNew: true,
});

const text = await store.get('invoice-42');
const session = await store.get('user-123', { type: 'json' }); // parsed to an object inline
const { data, metadata, etag } = await store.getWithMetadata('invoice-42');

You address data by a key you choose. The type option reads a value back in the shape you want, so get(key, { type: "json" }) returns a parsed object with no extra step. getMetadata reads an object’s metadata without downloading its value, which is handy for listing or filtering; getWithMetadata returns the value and its metadata together.

Vercel Blob:

import { put } from '@vercel/blob';

const blob = await put('invoice-42.pdf', file, { access: 'public' });
// blob.url -> https://<id>.public.blob.vercel-storage.com/invoice-42-<suffix>.pdf

You get a URL back that you can hand directly to an <img> tag, a download link, or another service. To read that data back inside your code, you fetch the URL (or a token-gated private fetch), then call .json() on the response yourself.

File size

Vercel Blob holds files up to 5 TB, using multipart uploads for anything over 100 MB. Netlify Blobs caps a single object at 5 GB. If you store multi-gigabyte video or large archives, Vercel’s ceiling is the practical one. For JSON, images, documents, and typical app data, 5 GB per object is rarely the constraint.

One caveat on Vercel’s side: its CDN caches blobs only up to 512 MB per file. Files larger than that miss the cache on every access.

Consistency

Netlify Blobs lets you pick consistency per store or per operation. The default is eventual: a single-region, edge-cached store where updates and deletes propagate within 60 seconds. Set a store or a read to strong consistency and a write is visible globally the moment it returns, at the cost of slower reads.

Vercel Blob is CDN-cache-based. Overwrites and deletes take up to 60 seconds to propagate. For a private read that must reflect the latest write, you pass useCache: false to bypass the cache.

Most applications using a key-value store expect the most recent value when a key is read. Netlify’s default is eventual, but you turn on strong consistency per store or per read, and then a write is visible the moment it returns. On Vercel Blob you attach useCache: false to get a fresh value, a manual flag per read rather than a store-level setting. For a config value or a session that changes and gets read again in the same request, that difference decides whether your code sees stale data.

Metadata and conditional writes

Netlify Blobs attaches up to 2 KB of arbitrary JSON metadata to each object, readable without fetching the value. It supports conditional atomic writes with onlyIfNew (write only if the key does not exist) and onlyIfMatch (write only if the ETag matches), which return { modified, etag }. Together these make the store usable as a lightweight key-value database, not just a file bucket.

Vercel Blob supports custom metadata too. Pass an addMetadata object (up to 2 KB) on put() or a client upload, and it comes back in head() and list(). Vercel also exposes system metadata and ETags through head(), and supports conditional writes with ifMatch. The difference is integration depth: Netlify wires metadata into its key-value retrieval methods, so getWithMetadata returns the value and its metadata in one call, keyed the way you already read the store.

Browser uploads

Vercel Blob supports signed client uploads: the browser uploads directly to storage, bypassing your server’s request-body limits. This is built in.

Netlify Blobs has no native client-upload flow. You accept the upload in a function and call set() from there. For large direct-from-browser uploads, Vercel’s built-in path is less code.

Setup friction

Netlify Blobs is zero-config. There is no store to create, no token to manage, no region to pick before you start. It is available the moment you deploy, and Netlify handles provisioning and access control (Netlify Blobs docs).

Vercel Blob asks you to create a store in the dashboard or CLI and connect it to your project. Code running on Vercel authenticates with an automatic OIDC token, so you manage a static read-write token only for access from outside Vercel or for signing client uploads. That is more surface to set up, in exchange for explicit control over region (20 to choose from) and access mode.

Deploy-scoped storage

Netlify offers getDeployStore(), which ties data to a single deploy. The data syncs when you roll back and cleans up automatically. This fits per-deploy assets and preview data. Vercel Blob has no native equivalent.

Pricing

Vercel Blob prices each dimension separately: roughly $0.023 per GB-month of storage, $0.40 per million simple operations, $5.00 per million advanced operations, and per-GB data transfer, with rates varying by region (Vercel Blob pricing). The Hobby plan includes a starting allowance (for example 5 GB storage and 100 GB transfer) shared across Vercel services.

Netlify Blobs is included on every plan and draws from your account’s monthly credit pool: 300 credits on Free, 1,000 on Personal, 3,000 on Pro (Netlify pricing). Netlify does not publish a standalone per-GB or per-operation rate for Blobs; usage consumes shared credits rather than an itemized bill. If you need to forecast an exact per-gigabyte cost, Vercel’s itemized model is easier to model; if you want storage bundled into one plan, Netlify’s is simpler.

Side by side

As a key-value store, Netlify Blobs is the stronger fit

Both products can write text or JSON and read it back, but Netlify Blobs was designed around the key-value model, and it shows up in four places when you use it as a database:

• Read-after-write correctness. Strong consistency is a per-store or per-operation setting, so a write is visible the moment it returns. Vercel’s cache-based model needs the useCache: false flag on each read to match that.
• Data types built for code. get(key, { type: "json" }) hands you a parsed object. Vercel returns a file you fetch over HTTP and parse yourself.
• Atomic conditional writes. onlyIfNew and onlyIfMatch let you create or update a key without a race, which is what makes it safe to hold feature flags, counters, or session tokens. Vercel’s API centers on object overwrites.
• Scoped data lifecycle. getDeployStore() ties data to a specific deploy, so preview and staging state reverts when you roll back. Vercel stores are global to the environment, so you separate staging data with prefix naming instead.

Which to choose

Pick Netlify Blobs when you address data by key from your own code, want metadata and read-after-write correctness, and value having storage available with no setup. It works as a lightweight key-value database for session data, feature flags, cached API responses, and per-user records.

Pick Vercel Blob when you serve large public files through a CDN URL, need direct browser uploads, or store objects measured in hundreds of gigabytes to terabytes.

Resources

• Netlify Blobs overview and API
• Netlify CLI blobs commands
• Netlify pricing
• Vercel Blob docs
• Vercel Blob usage and pricing