# Upstash Blob vs UploadThing: Which Is Better for File Uploads in React and Next.js?

> **Source:** https://upstash.com/kb/upstash-blob-vs-uploadthing
> **Date:** 2026-11-10
> **Author(s):** Josh
> **Topic:** Blob
> **Format:** text/markdown, machine-readable content for agents and LLMs

Upstash Blob vs UploadThing for React and Next.js file uploads: pricing, code, maintenance, and a November 2026 upload benchmark.

---

For most React and Next.js apps, Upstash Blob is a better choice than UploadThing for file uploads, because UploadThing has stopped shipping releases. The last UploadThing [npm release](https://www.npmjs.com/package/uploadthing) came out on August 17, 2025, 15 months ago, while Upstash Blob ships new SDK releases every few weeks. Upstash Blob also charges [$0.02 per GB stored](https://upstash.com/pricing/blob) with 1 TB of free downloads a month on pay-as-you-go, and uploads files up to 5 TB with resumable multipart uploads.

UploadThing still makes sense if you want a pre-styled upload button and dropzone and do not want to build any upload UI. For file uploads in a React app, Upstash Blob handles both the storage and the upload itself, and a plain file input or react-dropzone covers the UI, as in [this multi-file drag-and-drop uploader](https://upstash.com/blog/react-file-upload-a-multi-file-drag-and-drop-uploader-with-upstash-blob).

We set up both services with real API keys on November 10, 2026, ran the same uploads through each SDK, and compared the code, the bill and the speed.

## Is Upstash Blob or UploadThing better for file uploads in a React app?

Upstash Blob is better for file uploads in a React app for most teams: Upstash Blob stores files for less, takes files up to 5 TB, and finished server uploads in less than half the time UploadThing needed in our November 2026 benchmark. UploadThing is the better fit when a ready-made, styled upload button matters more than cost or file size.

Here is the short version:

| Service | Storage price | Free plan | Downloads (egress) | Upload UI | Latest npm release | Server upload, 100 KB |
| --- | --- | --- | --- | --- | --- | --- |
| Upstash Blob | [$0.02 per GB a month](https://upstash.com/pricing/blob) | 1 GB storage, 10 GB egress | Free up to 1 TB a month, then $0.02 per GB | React hook, you bring the UI | November 5, 2026 | 225 ms |
| UploadThing | [$10 for 100 GB, $25 for 250 GB, then $0.08 per GB](https://uploadthing.com/pricing) | 2 GB storage, unlimited uploads and downloads | No egress fee listed | Ready-made button and dropzone | August 17, 2025 | 513 ms |

The upload times shown are the median of 20 warm uploads from the benchmark below.

## Is UploadThing still maintained?

UploadThing still works, but the `uploadthing` package has had no new npm release since August 17, 2025. Version 7.7.4 of `uploadthing` and version 7.3.3 of `@uploadthing/react` both came out that day, about 15 months before November 10, 2026.

The UploadThing repository still gets some commits. Its main branch had [11 commits](https://github.com/pingdotgg/uploadthing/commits/main) between November 10, 2025 and November 10, 2026, the last one on September 30, 2026. None of that work has shipped to npm.

UploadThing [issue #1242](https://github.com/pingdotgg/uploadthing/issues/1242), opened in October 2025 when UploadThing packages failed to compile with Next.js 16 in Turbopack mode, was fixed on the Next.js side in Next.js 16.1 rather than in an UploadThing release. In January 2026 one user wrote in that thread: "[This product is starting to feel abandoned.](https://github.com/pingdotgg/uploadthing/issues/1242#issuecomment-3738761570)" GitHub shows the issue as closed, not planned.

Upstash Blob ships new SDK releases every few weeks. The [`@upstash/blob` package](https://www.npmjs.com/package/@upstash/blob) first came out on August 25, 2026, and three new versions shipped in the 30 days before November 10, 2026, the latest on November 5.

## How do uploads work in Upstash Blob and UploadThing?

Upstash Blob and UploadThing have similar flows: the file is uploaded from the browser, and the server is used only for authorization. This means the client is sending the file directly to storage.

Upstash Blob does this by creating a route in your app, using the `uploadHandler`. When the browser makes a request to upload a file, Upstash Blob will call the `onBeforeUpload` callback in the route. Here you can check the user and choose the file path. Throwing an error will reject the upload. On the server side, Upstash Blob also checks the route [constraints](https://upstash.com/docs/blob/uploads/constraints), such as the maximum file size and content types allowed, so they can’t be skipped by the client.

The browser then uploads the bytes directly to the bucket. Once the upload is complete, the browser notifies your route, and Upstash Blob runs your `onUploadComplete` callback in that route. Because the upload complete callback is made from the browser to your own route, you can use Upstash Blob’s `onUploadComplete` in localhost without a tunnel or public callback URL.

The Upstash Blob flow, step by step:

![Upstash Blob upload flow: browser asks your route, uploads straight to the bucket, then your route runs onUploadComplete](https://cdn.bydefault.so/drawing-OYXBGncxS3s6fnqJhyplO.png)

Uploading straight to storage avoids the [4.5 MB request body limit of Vercel Functions](https://vercel.com/docs/functions/limitations) and the 6 MB limit of AWS Lambda. If a user sends a 20 MB video through your Next.js server, the request fails before your code runs. Both Upstash Blob and UploadThing handle this the [same way](https://upstash.com/docs/blob/uploads/upload-handler).

Upstash Blob’s handler exports GET and POST functions, taking a standard `Request` and returning a standard `Response`. It works in Next.js, Hono, SvelteKit and Remix with the same Upstash Blob handler. On Cloudflare Workers, you’ll [pass the token directly](https://upstash.com/docs/blob/bucket/connecting) when creating the bucket client.

In production, UploadThing requires your server to have a public URL for the upload route. This is because after the browser is done uploading the file to UploadThing using the presigned URL that your server provided, UploadThing’s servers will [send a callback request to your app](https://docs.uploadthing.com/uploading-files) to trigger `onUploadComplete`. In local development, the UploadThing SDK simulates the callback by keeping a stream open while uploading.

The UploadThing flow with an extra callback step:

![UploadThing upload flow with the callback from UploadThing's servers to your app](https://cdn.bydefault.so/drawing-FhG1RJNvyt8msXlmuhfUj.png)

## How much code does a React file upload take with Upstash Blob vs UploadThing?

UploadThing and Upstash Blob require the same amount of code on the server (six lines with each SDK), and both let you upload files with four small files in React (17 non-blank lines with Upstash Blob and 20 with UploadThing).

Server uploads cover scripts, cron jobs and API routes that already hold the file. Upstash Blob reads its token from `UPSTASH_BLOB_TOKEN`:

```ts
import { Bucket } from '@upstash/blob'

const bucket = Bucket.fromEnv()
const path = 'article-bench/report.txt'
const blob = await bucket.put(path, new Blob(['Quarterly report\n']), { contentType: 'text/plain' })
console.log(blob.url)
await bucket.del(path)
```

```text
https://b27353de2921.blob.upstash.io/article-bench/report.txt
```

UploadThing reads `UPLOADTHING_TOKEN` and returns a data and error pair:

```ts
import { UTApi } from 'uploadthing/server'

const utapi = new UTApi()
const { data, error } = await utapi.uploadFiles(new File(['Quarterly report\n'], 'article-bench-report.txt', { type: 'text/plain' }))
if (error) throw new Error(error.message)
console.log(data.ufsUrl)
await utapi.deleteFiles(data.key)
```

```text
⚠️ [uploadthing][deprecated] `file.url` is deprecated and will be removed in uploadthing v9. Use `file.ufsUrl` instead.
⚠️ [uploadthing][deprecated] `file.appUrl` is deprecated and will be removed in uploadthing v9. Use `file.ufsUrl` instead.
https://n8wlvcgpkk.ufs.sh/f/JsOyG8min0QyVp1ormDI49FWTnUrLBEYj23OSKZbPmugxRaf
```

The UploadThing SDK prints those two warnings from its own upload code. The snippet already reads the supported `ufsUrl` field.

For browser uploads, the Upstash Blob handler sets limits and picks a path for each file:

```ts
import { uniquePath, uploadHandler } from '@upstash/blob'

export const uploads = uploadHandler({
  constraints: { maxSize: '20mb', contentTypes: ['image/*'] },
  onBeforeUpload: ({ file }) => ({ path: uniquePath(`images/${file.name}`) }),
})
```

One line in `app/api/upload/route.ts` mounts it:

```ts
import { uploads } from '../../../lib/uploads'

export const { GET, POST } = uploads
```

A typed hook binds the client to that handler:

```ts
'use client'

import { uploadHooks } from '@upstash/blob/react'
import type { uploads } from './uploads'

export const { useUpload } = uploadHooks<typeof uploads>()
```

A plain file input starts the upload:

```tsx
'use client'

import { useUpload } from '../lib/upload-hooks'

export function UpstashUploader() {
  const { start, accept } = useUpload()
  return <input type="file" accept={accept} onChange={(event) => start({ file: event.currentTarget.files?.[0] })} />
}
```

The Upstash Blob `useUpload` hook replaces a separate React upload library like Uppy or React Uploady, and does more than that input suggests. [It automatically handles multipart uploads](https://upstash.com/docs/blob/uploads/large-files) when files exceed 16 MB. It uses the types generated from the server handler. It reports upload progress. It checks the route’s rules and can block an oversize file before making any requests. And react-dropzone can be used on top of it, such as in [this multi-file uploader](https://upstash.com/blog/react-file-upload-a-multi-file-drag-and-drop-uploader-with-upstash-blob).

On the UploadThing side, the file router sets the type and size per route:

```ts
import { createUploadthing, type FileRouter } from 'uploadthing/next'

const uploadthing = createUploadthing()

export const uploadRouter = {
  imageUploader: uploadthing({ image: { maxFileSize: '4MB' } })
    .middleware(() => ({ userId: 'demo' }))
    .onUploadComplete(({ file }) => ({ url: file.ufsUrl })),
} satisfies FileRouter

export type UploadRouter = typeof uploadRouter
```

The route file in `app/api/uploadthing/route.ts` wraps the router:

```ts
import { createRouteHandler } from 'uploadthing/next'
import { uploadRouter } from './core'

export const { GET, POST } = createRouteHandler({ router: uploadRouter })
```

A helper builds a button typed against that router:

```ts
'use client'

import { generateUploadButton } from '@uploadthing/react'
import type { UploadRouter } from '../app/api/uploadthing/core'

export const UploadButton = generateUploadButton<UploadRouter>()
```

The page renders it:

```tsx
'use client'

import { UploadButton } from '../utils/uploadthing'

export function UploadThingUploader() {
  return <UploadButton endpoint="imageUploader" />
}
```

The Upstash Blob handler is compatible with any runtime that has standard Request and Response objects. Upstash Blob provides React hooks, and a plain browser client. Upstash Blob buckets are also [S3-compatible](https://upstash.com/docs/blob/bucket/connecting), so you can use `bucket.s3()` to get a config for the AWS SDK and other S3 tools.

UploadThing has [first-party packages](https://docs.uploadthing.com/uploading-files) for Next.js, SolidStart, Astro, SvelteKit, and Nuxt, backend adapters for Express, Fastify, H3, and any Fetch-based server, and a React client. The UploadThing button is styled and has TypeScript endpoint name checking based on the router.

## How do you manage files on the server with Upstash Blob vs UploadThing?

After the upload, most file work runs on the server: listing a user's files, cleaning up old ones, handing out a private link. Here is what each SDK offers:

| Task | Upstash Blob | UploadThing |
| --- | --- | --- |
| Upload | `put()` takes a Blob, File, string, buffer or stream | `uploadFiles()`, up to 25 files in parallel |
| Read | `get()` reads the file; `info()` and `exists()` check metadata | Fetch the file URL |
| List | `list()` by path prefix, up to 1,000 per page with a cursor | `listFiles()` with limit and offset |
| Delete | `del()` takes one path, an array or a whole prefix | `deleteFiles()` by key or custom ID |
| Private links | `signedReadUrl()` | `generateSignedURL()` |
| Copy, move, rename | `copy()` and `move()` | `renameFiles()` |

In Upstash Blob, `put()` [overwrites the file by default](https://upstash.com/docs/blob/bucket/writing) if it already exists, so if your server upload fails you can just retry it with the same path, no cleanup necessary.

In UploadThing, you refer to the file by a generated key or a custom ID.

Upstash Blob refers to files by path, like a file system. If you organize user 42’s files in `users/42/` then Upstash Blob lets you list all of them in a single call, delete all of them in a single call, and [deletes are free](https://upstash.com/pricing/blob).

The UploadThing list call pages through all the files in your app. UploadThing recommends using it only [for admin tasks, one-time syncs and debugging](https://docs.uploadthing.com/api-reference/ut-api). This means that with UploadThing you need to keep your own table of file keys.

## Which handles large file uploads better, Upstash Blob or UploadThing?

Upstash Blob allows uploads up to [5 TB per object](https://upstash.com/pricing/blob), and the Upstash Blob React hook handles large file uploads in resumable parts.

UploadThing requires each route to have a max file size, with [small defaults](https://docs.uploadthing.com/file-routes): 4 MB for images and PDFs, 8 MB for audio and other files, 16 MB for videos, and 64 KB for text.

UploadThing routes can use `maxFileSize` to allow larger files. The UploadThing docs example allows up to 256 MB for videos. UploadThing documents resumable uploads with an HTTP Range header, for people making their own UploadThing upload client.

Upstash Blob's React hook [automatically uses multipart uploads](https://upstash.com/docs/blob/uploads/large-files) for files above 16 MB:

1. It breaks large files into multiple parts of at least 5 MiB each, targeting around 250 parts (for example, a 20 GB file will be uploaded in 248 parts, each around 77 MiB).
2. It uploads up to four parts in parallel for each file.
3. On failures, it retries just the failed part (up to 20 times for a dropped connection).
4. Uploads can be paused and resumed.
5. If the user refreshes the page and selects the same file again, the upload will resume.

For smaller or larger files, the default 16 MB threshold can be adjusted for a handler or a route with the `multipart:` option, like `multipart: '100mb'`.

## How much does Upstash Blob cost compared to UploadThing?

Upstash Blob costs $0.02 per GB stored per month on pay-as-you-go, with the first 1 TB of downloads each month free. UploadThing charges flat plans of $10 a month for 100 GB and $25 a month for 250 GB, then $0.08 per GB.

Upstash Blob's [pay-as-you-go rates](https://upstash.com/pricing/blob):

- Storage costs $0.02 per GB per month, based on the average storage over the month.
- Uploads, copies and listings cost $4.50 per million operations.
- Downloads and HEAD requests cost $0.30 per million.
- Deletes are free, and uploads have no bandwidth charge.
- Egress is free up to 1 TB a month, then $0.02 per GB.

UploadThing's [three plans](https://uploadthing.com/pricing):

![UploadThing pricing plans](https://cdn.bydefault.so/image-8bJpn87b3UWHq7tzsPlYo.png)

UploadThing lists region choice and private files on its paid plans.

Take an app that stores 500 GB, serves 1 TB a month, and handles 100,000 uploads and 1 million downloads:

```text
Upstash Blob
  storage     500 GB x $0.02         = $10.00
  uploads     0.1M x $4.50           =  $0.45
  downloads   1M x $0.30             =  $0.30
  egress      1 TB (free allowance)  =  $0.00
  total                                $10.75

UploadThing (Usage Based plan)
  plan        250 GB included        = $25.00
  overage     250 GB x $0.08         = $20.00
  total                                $45.00
```

Let’s look at the same bills with a chart:

![Monthly bill for 500 GB stored and 1 TB served on Upstash Blob and UploadThing](https://cdn.bydefault.so/image-BiFGz5yBz611o2LEzQAKX.png)

Now let's compare both with smaller apps:

- For a small app with 5 GB data, Upstash Blob costs around $0.10 a month plus request fees. UploadThing requires the $10 plan for 100 GB storage.
- If you have 100 GB of data, Upstash Blob charges $2 plus request fees. UploadThing costs $10 flat.
- UploadThing has an extra $0.08 per GB cost when the used storage is more than the included amount. This is four times the Upstash Blob price ($0.02) so the difference increases per each GB.

If your app stores little but serves more than 1 TB of downloads a month, UploadThing's flat plans, which list no egress fee, can cost less.

## Is Upstash Blob faster than UploadThing?

Upstash Blob was faster than UploadThing in our November 10, 2026 benchmark: a 100 KB server upload took 225 ms at the median on Upstash Blob against 513 ms on UploadThing, and a 5 MB upload took 370 ms against 934 ms. That is less than half the time at both sizes.

The setup:

- The run happened on November 10, 2026, from a sandbox in Ashburn, Virginia (AWS), on Node 25.9.0, with `uploadthing` 7.7.4 and the latest `@upstash/blob` release.
- The UploadThing app used UploadThing's [default region](https://docs.uploadthing.com/concepts/regions-acl), `sea1` (US West, Seattle), the only region on the free plan. The sandbox sits next to Vercel's [default function region](https://vercel.com/docs/functions/configuring-functions/region) (`iad1`, Washington, D.C.), so this is the setup a new Next.js app on Vercel gets with a free UploadThing app.
- Files were 100 KB and 5 MB of random content, uploaded from the server.
- Each SDK made one cold first call per size, then 20 warm uploads per size. The two SDKs took turns, and the one that went first switched every round, so neither got a time-of-day advantage.
- After each upload, a plain `fetch()` read the file back from its public URL and checked every byte. All 84 files matched, and we deleted them afterwards.

The results, in milliseconds:

| SDK | File size | Upload median | Upload p95 | Read median | Read p95 | Cold upload |
| --- | --- | --- | --- | --- | --- | --- |
| Upstash Blob | 100 KB | 225 | 272 | 158 | 207 | 512 |
| UploadThing | 100 KB | 513 | 569 | 356 | 421 | 760 |
| Upstash Blob | 5 MB | 370 | 673 | 298 | 618 | 336 |
| UploadThing | 5 MB | 934 | 1,199 | 483 | 668 | 1,211 |

![Median upload times, Upstash Blob vs UploadThing, 100 KB and 5 MB](https://cdn.bydefault.so/image-MOsKsfZgbZpPYY1UWiUxD.png)

The p95 column is the 19th fastest run out of 20 total. This was run from one location, with one bucket and one app. UploadThing's paid plans can move an app to a closer region, such as US East (Ohio), which would likely narrow the gap, so test from where your servers run.

Upstash Blob was also faster downloading the files at both sizes: 158 ms compared to UploadThing's 356 ms for 100 KB reads.

## What's the best UploadThing alternative for React and Next.js?

Upstash Blob is the best UploadThing alternative for React and Next.js applications, offering the same browser-to-storage upload functionality but with a typed React hook, low pricing ($0.02 per GB stored), large file support up to 5 TB, and more active SDK development with new releases every few weeks.

Upstash Blob is also the best file storage for Next.js for most apps: the Upstash Blob upload handler mounts as a Next.js route in one line, its `onUploadComplete` runs on localhost without a tunnel, and Upstash Blob stores files for $0.02 per GB.

1. **Upstash Blob**: best overall for file uploads in React and Next.js apps; great for low storage pricing, uploading large files, uploading from servers and edge functions, working with S3 tools, and active development.
2. **UploadThing**: best for a pre-styled upload button and dropzone component without needing to implement a UI.

You can find the full setup for uploading from the browser in a Next.js application in the [Upstash Blob quickstart](https://upstash.com/docs/blob/overall/quickstart).

---

This site has a search endpoint: https://context7.com/api/v2/ask?siteKey=ask_4cf2adc7846aa874f833b068&query=<URL-encoded question>. It returns documentation that answers the question, with a source link for each part. No API key is needed. If nothing matches, it says so.
