diff --git a/docs/content/docs/2.storage/3.blob.md b/docs/content/docs/2.storage/3.blob.md
index 8b226610..7f234fcf 100644
--- a/docs/content/docs/2.storage/3.blob.md
+++ b/docs/content/docs/2.storage/3.blob.md
@@ -131,6 +131,32 @@ export default eventHandler(async (event) => {
 })
 ```
 
+See an example on the Vue side:
+
+```vue [pages/upload.vue]
+<script setup lang="ts">
+async function uploadImage (e: Event) {
+  const form = e.target as HTMLFormElement
+
+  await $fetch('/api/files', {
+    method: 'POST',
+    body: new FormData(form)
+  }).catch((err) => alert('Failed to upload image:\n'+ err.data?.message))
+
+  form.reset()
+}
+</script>
+
+<template>
+  <form @submit.prevent="uploadImage">
+    <label>Upload an image: <input type="file" name="image"></label>
+    <button type="submit">
+      Upload
+    </button>
+  </form>
+</template>
+```
+
 #### Params
 
 ::field-group
@@ -248,6 +274,212 @@ Returns a [`BlobObject`](#blobobject) or an array of [`BlobObject`](#blobobject)
 
 Throws an error if `file` doesn't meet the requirements.
 
+### `handleMultipartUpload()`
+
+Handle the request to support multipart upload.
+
+```ts [server/api/files/multipart/[action\\]/[...pathname\\].ts]
+export default eventHandler(async (event) => {
+  return await hubBlob().handleMultipartUpload(event)
+})
+```
+
+::important
+Make sure your route includes `[action]` and `[...pathname]` params.
+::
+
+On the client side, you can use the `useMultipartUpload()` composable to upload a file in parts.
+
+```vue
+<script setup lang="ts">
+async function uploadFile(file: File) {
+  const upload = useMultipartUpload('/api/files/multipart')
+
+  const { progress, completed, abort } = upload(file)
+}
+</script>
+```
+
+::note{to="#usemultipartupload"}
+See [`useMultipartUpload()`](#usemultipartupload) on usage details.
+::
+
+#### Params
+
+::field-group
+  ::field{name="contentType" type="string"}
+    The content type of the blob.
+  ::
+  ::field{name="contentLength" type="string"}
+    The content length of the blob.
+  ::
+  ::field{name="addRandomSuffix" type="boolean"}
+    If `true`, a random suffix will be added to the blob's name. Defaults to `false`.
+  ::
+::
+
+### `createMultipartUpload()`
+
+::note
+We suggest to use [`handleMultipartUpload()`](#handlemultipartupload) method to handle the multipart upload request.
+::
+
+Start a new multipart upload.
+
+```ts [server/api/files/multipart/[...pathname\\].post.ts]
+export default eventHandler(async (event) => {
+  const { pathname } = getRouterParams(event)
+
+  const mpu = await hubBlob().createMultipartUpload(pathname)
+
+  return {
+    uploadId: mpu.uploadId,
+    pathname: mpu.pathname,
+  }
+})
+```
+
+#### Params
+
+::field-group
+  ::field{name="pathname" type="String"}
+    The name of the blob to serve.
+  ::
+  ::field{name="options" type="Object"}
+    The put options. Any other provided field will be stored in the blob's metadata.
+    ::field{name="contentType" type="String"}
+      The content type of the blob. If not given, it will be inferred from the Blob or the file extension.
+    ::
+    ::field{name="contentLength" type="String"}
+      The content length of the blob.
+    ::
+    ::field{name="addRandomSuffix" type="Boolean"}
+      If `true`, a random suffix will be added to the blob's name. Defaults to `true`.
+    ::
+  ::
+::
+
+#### Return
+
+Returns a `BlobMultipartUpload`
+
+### `resumeMultipartUpload()`
+
+::note
+We suggest to use [`handleMultipartUpload()`](#handlemultipartupload) method to handle the multipart upload request.
+::
+
+Continue processing of unfinished multipart upload.
+
+To upload a part of the multipart upload, you can use the `uploadPart()` method:
+
+```ts [server/api/files/multipart/[...pathname\\].put.ts]
+export default eventHandler(async (event) => {
+  const { pathname } = getRouterParams(event)
+  const { uploadId, partNumber } = getQuery(event)
+
+  const stream = getRequestWebStream(event)!
+  const body = await streamToArrayBuffer(stream, contentLength)
+
+  const mpu = hubBlob().resumeMultipartUpload(pathname, uploadId)
+  return await mpu.uploadPart(partNumber, body)
+})
+```
+
+Complete the upload by calling `complete()` method:
+
+```ts [server/api/files/multipart/complete.post.ts]
+export default eventHandler(async (event) => {
+  const { pathname, uploadId } = getQuery(event)
+  const parts = await readBody(event)
+
+  const mpu = hubBlob().resumeMultipartUpload(pathname, uploadId)
+  return await mpu.complete(parts)
+})
+```
+
+If you want to cancel the upload, you need to call `abort()` method: 
+
+```ts [server/api/files/multipart/[...pathname\\].delete.ts]
+export default eventHandler(async (event) => {
+  const { pathname } = getRouterParams(event)
+  const { uploadId } = getQuery(event)
+
+  const mpu = hubBlob().resumeMultipartUpload(pathname, uploadId)
+  await mpu.abort()
+
+  return sendNoContent(event)
+})
+```
+
+A simple example of multipart upload in client with above routes:
+
+```ts [utils/multipart-upload.ts]
+async function uploadLargeFile(file: File) {
+  const chunkSize = 10 * 1024 * 1024 // 10MB
+
+  const count = Math.ceil(file.size / chunkSize)
+  const { pathname, uploadId } = await $fetch(
+    `/api/files/multipart/${file.name}`,
+    { method: 'POST' },
+  )
+
+  const uploaded = []
+
+  for (let i = 0; i < count; i++) {
+    const start = i * chunkSize
+    const end = Math.min(start + chunkSize, file.size)
+    const partNumber = i + 1
+    const chunk = file.slice(start, end)
+
+    const part = await $fetch(
+      `/api/files/multipart/${pathname}`,
+      {
+        method: 'PUT',
+        query: { uploadId, partNumber },
+        body: chunk,
+      },
+    )
+
+    uploaded.push(part)
+  }
+
+  return await $fetch(
+    '/api/files/multipart/complete',
+    {
+      method: 'POST',
+      query: { pathname, uploadId },
+      body: { parts: uploaded },
+    },
+  )
+}
+```
+
+#### Params
+
+::field-group
+  ::field{name="pathname" type="String"}
+    The name of the blob to serve.
+  ::
+  ::field{name="uploadId" type="String"}
+    The upload ID of the multipart upload.
+  ::
+::
+
+#### Return
+
+Returns a `BlobMultipartUpload`
+
+
+#### Params
+
+::field-group
+  ::field{name="event" type="H3Event" required}
+    The event to handle.
+  ::
+::
+
+
 ## `ensureBlob()`
 
 `ensureBlob()` is a handy util to validate a `Blob` by checking its size and type:
@@ -284,6 +516,10 @@ Throws an error if `file` doesn't meet the requirements.
 
 ## Composables
 
+::note
+The following composables are meant to be used in the Vue side of your application (not the `server/` directory).
+::
+
 ### `useUpload()`
 
 `useUpload` is to handle file uploads in your Nuxt application.
@@ -327,6 +563,59 @@ async function onFileSelect({ target }: Event) {
   ::
 ::
 
+#### Return
+
+Return a `MultipartUpload` function that can be used to upload a file in parts.
+
+```ts
+const { completed, progress, abort } = upload(file)
+const data = await completed
+```
+
+### `useMultipartUpload()`
+
+Application composable that creates a multipart upload helper.
+
+```ts [utils/multipart-upload.ts]
+export const mpu = useMultipartUpload('/api/files/multipart')
+```
+
+#### Params
+
+::field-group
+  ::field{name="baseURL" type="string"}
+    The base URL of the multipart upload API handled by [`handleMultipartUpload()`](#handlemultipartupload).
+  ::
+  ::field{name="options"}
+    The options for the multipart upload helper.
+    ::field{name="partSize" type="number"}
+      The size of each part of the file to be uploaded. Defaults to `10MB`.
+    ::
+    ::field{name="concurrent" type="number"}
+      The maximum number of concurrent uploads. Defaults to `1`.
+    ::
+    ::field{name="maxRetry" type="number"}
+      The maximum number of retry attempts for the whole upload. Defaults to `3`.
+    ::
+    ::field{name="prefix" type="string"}
+      The prefix to use for the blob pathname.
+    ::
+    ::field{name="fetchOptions" type="Omit<FetchOptions, 'method' | 'baseURL' | 'body' | 'parseResponse' | 'responseType'>"}
+      Override the ofetch options.
+      The `query` and `headers` will be merged with the options provided by the uploader.
+    ::
+  ::
+::
+
+#### Return
+
+Return a `MultipartUpload` function that can be used to upload a file in parts.
+
+```ts
+const { completed, progress, abort } = mpu(file)
+const data = await completed
+```
+
 ## Types
 
 ### `BlobObject`
@@ -340,6 +629,40 @@ interface BlobObject {
 }
 ```
 
+### `BlobMultipartUpload`
+
+```ts
+export interface BlobMultipartUpload {
+  pathname: string
+  uploadId: string
+  uploadPart(
+    partNumber: number,
+    value: string | ReadableStream<any> | ArrayBuffer | ArrayBufferView | Blob
+  ): Promise<BlobUploadedPart>
+  abort(): Promise<void>
+  complete(uploadedParts: BlobUploadedPart[]): Promise<BlobObject>
+}
+```
+
+### `BlobUploadedPart`
+
+```ts
+export interface BlobUploadedPart {
+  partNumber: number;
+  etag: string;
+}
+```
+
+### `MultipartUploader`
+
+```ts
+export type MultipartUploader = (file: File) => {
+  completed: Promise<SerializeObject<BlobObject> | undefined>
+  progress: Readonly<Ref<number>>
+  abort: () => Promise<void>
+}
+```
+
 ### `BlobListResult`
 
 ```ts
@@ -351,7 +674,6 @@ interface BlobListResult {
 }
 ```
 
-
 ## Examples
 
 ### List blobs with pagination
diff --git a/playground/pages/blob.vue b/playground/pages/blob.vue
index 5e284146..840425f6 100644
--- a/playground/pages/blob.vue
+++ b/playground/pages/blob.vue
@@ -1,5 +1,6 @@
 <script setup lang="ts">
 const loading = ref(false)
+const loadingProgress = ref<number | undefined>(undefined)
 const newFilesValue = ref<File[]>([])
 const uploadRef = ref<HTMLInputElement>()
 const folded = ref(false)
@@ -41,14 +42,14 @@ async function addFile() {
     toast.add({ title: 'Missing files.', color: 'red' })
     return
   }
-
   loading.value = true
 
   try {
-    const uploadedFiles = await useUpload('/api/blob', { method: 'PUT', prefix: String(prefix.value || '') })(newFilesValue.value)
-
+    const uploadedFiles = await uploadFiles(newFilesValue.value)
     files.value!.push(...uploadedFiles)
-    toast.add({ title: `File${uploadedFiles.length > 1 ? 's' : ''} uploaded.` })
+    if (uploadedFiles.length > 0) {
+      toast.add({ title: `File${uploadedFiles.length > 1 ? 's' : ''} uploaded.` })
+    }
     newFilesValue.value = []
   } catch (err: any) {
     const title = err.data?.data?.issues?.map((issue: any) => issue.message).join('\n') || err.message
@@ -57,6 +58,69 @@ async function addFile() {
   loading.value = false
 }
 
+async function uploadFiles(files: File[]) {
+  const bigFileLimit = 10 * 1024 * 1024 // 10MB
+
+  const bigFiles = files.filter(file => file.size > bigFileLimit)
+  const smallFiles = files.filter(file => file.size <= bigFileLimit)
+
+  let uploadedFiles: any[] = []
+  // upload small files
+  console.log('upload small files', smallFiles.length)
+  if (smallFiles.length) {
+    uploadedFiles = await useUpload('/api/blob', {
+      method: 'PUT',
+      query: {
+        prefix: String(prefix.value || '')
+      }
+    })(smallFiles)
+  }
+
+  // upload big files
+  const uploadLarge = useMultipartUpload('/api/blob/multipart', {
+    concurrent: 2,
+    prefix: String(prefix.value || '')
+  })
+
+  for (const file of bigFiles) {
+    const { completed, progress, abort } = uploadLarge(file)
+
+    const uploadingToast = toast.add({
+      title: `Uploading ${file.name}...`,
+      description: file.name,
+      color: 'sky',
+      timeout: 0,
+      closeButton: {
+        color: 'red',
+        variant: 'solid'
+      },
+      callback: () => {
+        if (progress.value !== 100) {
+          abort()
+        }
+      }
+    })
+    const stopWatch = watch(progress, v => loadingProgress.value = v / 100)
+
+    const complete = await completed
+
+    stopWatch()
+    loadingProgress.value = undefined
+    toast.remove(uploadingToast.id)
+
+    if (complete) {
+      uploadedFiles.push(complete)
+    } else {
+      toast.add({
+        title: `Failed to upload ${file.name}.`,
+        color: 'red'
+      })
+    }
+  }
+
+  return uploadedFiles
+}
+
 function onFileSelect(e: any) {
   const target = e.target
 
@@ -71,6 +135,7 @@ function onFileSelect(e: any) {
 
 async function deleteFile(pathname: string) {
   try {
+    // @ts-expect-error method DELETE is not typed
     await $fetch(`/api/blob/${pathname}`, { method: 'DELETE' })
 
     blobData.value!.blobs = blobData.value!.blobs!.filter(t => t.pathname !== pathname)
@@ -116,7 +181,7 @@ async function deleteFile(pathname: string) {
 
     <UCheckbox v-model="folded" class="mt-2" label="View prefixes as directory" />
 
-    <UProgress v-if="loading" class="mt-2" />
+    <UProgress v-if="loading" :value="loadingProgress" :max="1" class="mt-2" />
 
     <div v-if="folders?.length || prefixes?.length" class="grid grid-cols-1 md:grid-cols-3 gap-2 mt-4">
       <UButton
diff --git a/playground/server/api/blob/multipart/[action]/[...pathname].ts b/playground/server/api/blob/multipart/[action]/[...pathname].ts
new file mode 100644
index 00000000..94be14e6
--- /dev/null
+++ b/playground/server/api/blob/multipart/[action]/[...pathname].ts
@@ -0,0 +1,5 @@
+export default eventHandler(async (event) => {
+  return await hubBlob().handleMultipartUpload(event, {
+    addRandomSuffix: true
+  })
+})
diff --git a/src/module.ts b/src/module.ts
index 9686416e..d06958ca 100644
--- a/src/module.ts
+++ b/src/module.ts
@@ -162,6 +162,7 @@ export default defineNuxtModule<ModuleOptions>({
 
     // Register server utils
     addServerImportsDir(resolve('./runtime/server/utils'))
+    addImportsDir(resolve('./runtime/composables'))
 
     // Register client composables
     addImportsDir(resolve('./runtime/compsables'))
diff --git a/src/runtime/composables/multipart.ts b/src/runtime/composables/multipart.ts
new file mode 100644
index 00000000..4849c809
--- /dev/null
+++ b/src/runtime/composables/multipart.ts
@@ -0,0 +1,200 @@
+import defu from 'defu'
+import { randomUUID } from 'uncrypto'
+import { joinURL } from 'ufo'
+import { readonly, type Ref } from 'vue'
+import type { FetchOptions } from 'ofetch'
+import type { SerializeObject } from 'nitropack'
+import type { BlobUploadedPart } from '../server/utils/blob'
+import { useState } from '#imports'
+
+/**
+ * Create a multipart uploader.
+ */
+export function useMultipartUpload(
+  baseURL: string,
+  options?: UseMultipartUploadOptions
+): MultipartUploader {
+  const {
+    partSize,
+    concurrent,
+    maxRetry,
+    fetchOptions,
+    prefix
+  } = defu(options, {
+    partSize: 10 * 1024 * 1024, // 10MB
+    concurrent: 1, // no concurrent upload by default
+    maxRetry: 3
+  })
+  const ofetch = $fetch.create({ baseURL, ...fetchOptions })
+  const queryOptions = options?.fetchOptions?.query || {}
+
+  const create = (file: File) => ofetch<{
+    pathname: string
+    uploadId: string
+  }>(prefix ? joinURL('/create', prefix, file.name) : joinURL('/create', file.name), {
+    method: 'POST'
+  })
+
+  const upload = (
+    { partNumber, chunkBody }: MultipartUploadChunk,
+    { pathname, uploadId }: Awaited<ReturnType<typeof create>>
+  ) => ofetch<BlobUploadedPart>(`/upload/${pathname}`, {
+    method: 'PUT',
+    query: {
+      ...queryOptions,
+      uploadId,
+      partNumber
+    },
+    body: chunkBody
+  })
+
+  const complete = (
+    parts: Awaited<ReturnType<typeof upload>>[],
+    { pathname, uploadId }: Awaited<ReturnType<typeof create>>
+  ) => ofetch<SerializeObject<BlobObject>>(`/complete/${pathname}`,
+    {
+      method: 'POST',
+      query: {
+        ...queryOptions,
+        uploadId
+      },
+      body: { parts }
+    }
+  )
+
+  const abort = async (
+    { pathname, uploadId }: Awaited<ReturnType<typeof create>>
+  ) => {
+    await ofetch(`/abort/${pathname}`, {
+      method: 'DELETE',
+      query: {
+        ...queryOptions,
+        uploadId
+      }
+    })
+  }
+
+  return (file) => {
+    const data = create(file)
+    const chunks = Math.ceil(file.size / partSize)
+
+    const queue = Array.from({ length: chunks }, (_, i) => i + 1)
+    const parts: Awaited<ReturnType<typeof upload>>[] = []
+    const progress = useState(randomUUID(), () => 0)
+    const errors: Error[] = []
+    let canceled = false
+
+    const cancel = async () => {
+      if (canceled) {
+        return
+      }
+      canceled = true
+      queue.splice(0, queue.length)
+      if (abort) {
+        await abort(await data)
+      }
+    }
+
+    const prepare = (partNumber: number) => {
+      const start = (partNumber - 1) * partSize
+      const end = Math.min(start + partSize, file.size)
+      const chunkBody = file.slice(start, end)
+      return { partNumber, chunkBody }
+    }
+
+    const process = async (partNumber: number) => {
+      const prepared = prepare(partNumber)
+      try {
+        const part = await upload(prepared, await data)
+
+        progress.value = parts.length / chunks * 100
+        parts.push(part)
+      } catch (e) {
+        errors.push(e as Error)
+        queue.push(partNumber)
+
+        if (errors.length >= maxRetry) {
+          cancel()
+          throw new Error('Upload failed')
+        }
+      }
+
+      // process next chunk
+      const next = queue.shift()
+      if (next) {
+        await process(next)
+      }
+    }
+
+    const start = async () => {
+      try {
+        await Promise.all(Array.from({ length: concurrent }).map(() => {
+          const partNumber = queue.shift()
+          if (partNumber) {
+            return process(partNumber)
+          }
+        }))
+      } catch (error) {
+        return
+      }
+      if (canceled || parts.length < chunks) {
+        return
+      }
+
+      return complete(parts, await data)
+    }
+
+    return {
+      completed: start(),
+      progress: readonly(progress),
+      abort: cancel
+    }
+  }
+}
+
+interface MultipartUploadChunk {
+  partNumber: number
+  chunkBody: Blob
+}
+
+export interface UseMultipartUploadOptions {
+  /**
+   * The size of each part of the file to be uploaded.
+   * @default 10 * 1024 * 1024
+   */
+  partSize?: number
+  /**
+   * The maximum number of concurrent uploads.
+   * @default 1
+   */
+  concurrent?: number
+  /**
+   * The maximum number of retry attempts for the whole upload.
+   * @default 3
+   */
+  maxRetry?: number
+  /**
+   * The prefix to use for the blob pathname.
+   */
+  prefix?: string
+  /**
+   * Override the ofetch options.
+   * The query and headers will be merged with the options provided by the uploader.
+   */
+  fetchOptions?: Omit<FetchOptions, 'method' | 'baseURL' | 'body' | 'parseResponse' | 'responseType'>
+}
+
+export type MultipartUploader = (file: File) => {
+  /**
+   * The promise that resolves to the complete response or undefined if the upload is canceled or failed.
+   */
+  completed: Promise<SerializeObject<BlobObject> | undefined>
+  /**
+   * The progress of the upload as a number between 0 and 100.
+   */
+  progress: Readonly<Ref<number>>
+  /**
+   * Abort the upload.
+   */
+  abort: () => Promise<void>
+}
diff --git a/src/runtime/compsables/useUpload.ts b/src/runtime/compsables/useUpload.ts
index 456d15d2..ea541eef 100644
--- a/src/runtime/compsables/useUpload.ts
+++ b/src/runtime/compsables/useUpload.ts
@@ -12,7 +12,6 @@ interface UploadOptions extends FetchOptions {
    * @default true
    */
   multiple?: boolean
-
 }
 
 export function useUpload(apiBase: string, options: UploadOptions & { multiple: false }): (data: FileList | HTMLInputElement | File[] | File) => Promise<BlobObject>
diff --git a/src/runtime/server/api/_hub/blob/[...pathname].put.ts b/src/runtime/server/api/_hub/blob/[...pathname].put.ts
index 53aa6fcd..42eadb7b 100644
--- a/src/runtime/server/api/_hub/blob/[...pathname].put.ts
+++ b/src/runtime/server/api/_hub/blob/[...pathname].put.ts
@@ -3,22 +3,7 @@ import { z } from 'zod'
 import { hubBlob } from '../../../utils/blob'
 import { requireNuxtHubAuthorization } from '../../../utils/auth'
 import { requireNuxtHubFeature } from '../../../utils/features'
-
-async function streamToArrayBuffer(stream: ReadableStream, streamSize: number) {
-  const result = new Uint8Array(streamSize)
-  let bytesRead = 0
-  const reader = stream.getReader()
-
-  while (true) {
-    const { done, value } = await reader.read()
-    if (done) {
-      break
-    }
-    result.set(value, bytesRead)
-    bytesRead += value.length
-  }
-  return result
-}
+import { streamToArrayBuffer } from '../../../internal/utils/stream'
 
 export default eventHandler(async (event) => {
   await requireNuxtHubAuthorization(event)
diff --git a/src/runtime/server/api/_hub/blob/multipart/[...pathname].delete.ts b/src/runtime/server/api/_hub/blob/multipart/[...pathname].delete.ts
new file mode 100644
index 00000000..0bec451c
--- /dev/null
+++ b/src/runtime/server/api/_hub/blob/multipart/[...pathname].delete.ts
@@ -0,0 +1,32 @@
+import { createError, eventHandler, sendNoContent } from 'h3'
+import { z } from 'zod'
+import { hubBlob } from '../../../../utils/blob'
+import { requireNuxtHubAuthorization } from '../../../../utils/auth'
+import { requireNuxtHubFeature } from '../../../../utils/features'
+
+export default eventHandler(async (event) => {
+  await requireNuxtHubAuthorization(event)
+  requireNuxtHubFeature('blob')
+
+  const { pathname } = await getValidatedRouterParams(event, z.object({
+    pathname: z.string().min(1)
+  }).parse)
+
+  const { uploadId } = await getValidatedQuery(event, z.object({
+    uploadId: z.string()
+  }).parse)
+
+  const { resumeMultipartUpload } = hubBlob()
+  const { abort } = resumeMultipartUpload(pathname, uploadId)
+
+  try {
+    await abort()
+  } catch (e: any) {
+    throw createError({
+      statusCode: 500,
+      message: `Storage error: ${e.message}`
+    })
+  }
+
+  return sendNoContent(event)
+})
diff --git a/src/runtime/server/api/_hub/blob/multipart/[...pathname].post.ts b/src/runtime/server/api/_hub/blob/multipart/[...pathname].post.ts
new file mode 100644
index 00000000..401ac226
--- /dev/null
+++ b/src/runtime/server/api/_hub/blob/multipart/[...pathname].post.ts
@@ -0,0 +1,30 @@
+import { createError, eventHandler } from 'h3'
+import { z } from 'zod'
+import { hubBlob } from '../../../../utils/blob'
+import { requireNuxtHubAuthorization } from '../../../../utils/auth'
+import { requireNuxtHubFeature } from '../../../../utils/features'
+
+export default eventHandler(async (event) => {
+  await requireNuxtHubAuthorization(event)
+  requireNuxtHubFeature('blob')
+
+  const { pathname } = await getValidatedRouterParams(event, z.object({
+    pathname: z.string().min(1)
+  }).parse)
+
+  const options = await readValidatedBody(event, z.record(z.string(), z.any()).optional().parse)
+
+  const { createMultipartUpload } = hubBlob()
+  try {
+    const object = await createMultipartUpload(pathname, options)
+    return {
+      uploadId: object.uploadId,
+      pathname: object.pathname
+    }
+  } catch (e: any) {
+    throw createError({
+      statusCode: 500,
+      message: `Storage error: ${e.message}`
+    })
+  }
+})
diff --git a/src/runtime/server/api/_hub/blob/multipart/[...pathname].put.ts b/src/runtime/server/api/_hub/blob/multipart/[...pathname].put.ts
new file mode 100644
index 00000000..6bc4e8ed
--- /dev/null
+++ b/src/runtime/server/api/_hub/blob/multipart/[...pathname].put.ts
@@ -0,0 +1,37 @@
+import { eventHandler, getValidatedRouterParams, getHeader, getRequestWebStream, getValidatedQuery } from 'h3'
+import { z } from 'zod'
+import { hubBlob } from '../../../../utils/blob'
+import { requireNuxtHubAuthorization } from '../../../../utils/auth'
+import { requireNuxtHubFeature } from '../../../../utils/features'
+import { streamToArrayBuffer } from '../../../../internal/utils/stream'
+
+export default eventHandler(async (event) => {
+  await requireNuxtHubAuthorization(event)
+  requireNuxtHubFeature('blob')
+
+  const { pathname } = await getValidatedRouterParams(event, z.object({
+    pathname: z.string().min(1)
+  }).parse)
+
+  const { uploadId, partNumber } = await getValidatedQuery(event, z.object({
+    uploadId: z.string(),
+    partNumber: z.coerce.number()
+  }).parse)
+
+  const contentLength = Number(getHeader(event, 'content-length') || '0')
+
+  const stream = getRequestWebStream(event)!
+  const body = await streamToArrayBuffer(stream, contentLength)
+
+  const { resumeMultipartUpload } = hubBlob()
+  const { uploadPart } = resumeMultipartUpload(pathname, uploadId)
+
+  try {
+    return await uploadPart(partNumber, body)
+  } catch (e: any) {
+    throw createError({
+      statusCode: 500,
+      message: `Storage error: ${e.message}`
+    })
+  }
+})
diff --git a/src/runtime/server/api/_hub/blob/multipart/complete.post.ts b/src/runtime/server/api/_hub/blob/multipart/complete.post.ts
new file mode 100644
index 00000000..a73f99f3
--- /dev/null
+++ b/src/runtime/server/api/_hub/blob/multipart/complete.post.ts
@@ -0,0 +1,34 @@
+import { createError, eventHandler, getValidatedQuery } from 'h3'
+import { z } from 'zod'
+import { hubBlob } from '../../../../utils/blob'
+import { requireNuxtHubAuthorization } from '../../../../utils/auth'
+import { requireNuxtHubFeature } from '../../../../utils/features'
+
+export default eventHandler(async (event) => {
+  await requireNuxtHubAuthorization(event)
+  requireNuxtHubFeature('blob')
+
+  const { pathname, uploadId } = await getValidatedQuery(event, z.object({
+    pathname: z.string().min(1),
+    uploadId: z.string().min(1)
+  }).parse)
+
+  const { parts } = await readValidatedBody(event, z.object({
+    parts: z.array(z.object({
+      partNumber: z.number(),
+      etag: z.string()
+    }))
+  }).parse)
+
+  const { resumeMultipartUpload } = hubBlob()
+  const { complete } = resumeMultipartUpload(pathname, uploadId)
+  try {
+    const object = await complete(parts)
+    return object
+  } catch (e: any) {
+    throw createError({
+      statusCode: 500,
+      message: `Storage error: ${e.message}`
+    })
+  }
+})
diff --git a/src/runtime/server/internal/utils/stream.ts b/src/runtime/server/internal/utils/stream.ts
new file mode 100644
index 00000000..799077bf
--- /dev/null
+++ b/src/runtime/server/internal/utils/stream.ts
@@ -0,0 +1,15 @@
+export async function streamToArrayBuffer(stream: ReadableStream, streamSize: number) {
+  const result = new Uint8Array(streamSize)
+  let bytesRead = 0
+  const reader = stream.getReader()
+
+  while (true) {
+    const { done, value } = await reader.read()
+    if (done) {
+      break
+    }
+    result.set(value, bytesRead)
+    bytesRead += value.length
+  }
+  return result
+}
diff --git a/src/runtime/server/utils/blob.ts b/src/runtime/server/utils/blob.ts
index 8d28811f..69f39a1e 100644
--- a/src/runtime/server/utils/blob.ts
+++ b/src/runtime/server/utils/blob.ts
@@ -1,6 +1,6 @@
 import type { extensions } from '@uploadthing/mime-types'
 import slugify from '@sindresorhus/slugify'
-import type { R2Bucket, ReadableStream } from '@cloudflare/workers-types/experimental'
+import type { R2Bucket, ReadableStream, R2MultipartUpload } from '@cloudflare/workers-types/experimental'
 import { ofetch } from 'ofetch'
 import mime from 'mime'
 import type { H3Event } from 'h3'
@@ -9,6 +9,7 @@ import { defu } from 'defu'
 import { randomUUID } from 'uncrypto'
 import { parse } from 'pathe'
 import { joinURL } from 'ufo'
+import { streamToArrayBuffer } from '../internal/utils/stream'
 import { requireNuxtHubFeature } from './features'
 import { useRuntimeConfig } from '#imports'
 
@@ -31,6 +32,40 @@ export interface BlobObject {
   uploadedAt: Date
 }
 
+export interface BlobUploadedPart {
+  /**
+   * The number of the part.
+   */
+  partNumber: number
+  /**
+   * The etag of the part.
+   */
+  etag: string
+}
+
+export interface BlobMultipartUpload {
+  /**
+   * The pathname of the multipart upload.
+   */
+  readonly pathname: string
+  /**
+   * The upload id of the multipart upload.
+   */
+  readonly uploadId: string
+  /**
+   * Upload a single part to this multipart upload.
+   */
+  uploadPart(partNumber: number, value: string | ReadableStream<any> | ArrayBuffer | ArrayBufferView | Blob): Promise<BlobUploadedPart>
+  /**
+   * Abort the multipart upload.
+   */
+  abort(): Promise<void>
+  /**
+   * Completes the multipart upload.
+   */
+  complete(uploadedParts: BlobUploadedPart[]): Promise<BlobObject>
+}
+
 export interface BlobListOptions {
   /**
    * The maximum number of blobs to return per request.
@@ -73,6 +108,44 @@ export interface BlobPutOptions {
   [key: string]: any
 }
 
+export interface BlobMultipartOptions {
+  /**
+   * The content type of the blob.
+   */
+  contentType?: string
+  /**
+   * The content length of the blob.
+   */
+  contentLength?: string
+  /**
+   * If a random suffix is added to the blob pathname.
+   * @default false
+   */
+  addRandomSuffix?: boolean
+  /**
+   * The prefix to use for the blob pathname.
+   */
+  prefix?: string
+  [key: string]: any
+}
+
+export type HandleMPUResponse =
+  | {
+    action: 'create'
+    data: Pick<BlobMultipartUpload, 'pathname' | 'uploadId'>
+  }
+  | {
+    action: 'upload'
+    data: BlobUploadedPart
+  }
+  | {
+    action: 'complete'
+    data: BlobObject
+  }
+  | {
+    action: 'abort'
+  }
+
 export interface BlobUploadOptions extends BlobPutOptions, BlobValidateOptions {
   /**
    * The key to get the file/files from the request form.
@@ -175,7 +248,19 @@ interface HubBlob {
    * @param pathnames The pathname of the blob
    */
   delete(pathnames: string | string[]): Promise<void>
-
+  /**
+   * Create a multipart upload.
+   */
+  createMultipartUpload(pathname: string, options?: BlobMultipartOptions): Promise<BlobMultipartUpload>
+  /**
+   * Get the specified multipart upload.
+   */
+  resumeMultipartUpload(pathname: string, uploadId: string): BlobMultipartUpload
+  /**
+   * Handle the multipart upload request.
+   * Make sure your route includes `[action]` and `[...pathname]` params.
+   */
+  handleMultipartUpload(event: H3Event, options?: BlobMultipartOptions): Promise<HandleMPUResponse>
   /**
    * Handle a file upload.
    *
@@ -278,6 +363,35 @@ export function hubBlob(): HubBlob {
         return await bucket.delete(decodeURI(pathnames))
       }
     },
+    async createMultipartUpload(pathname: string, options: BlobMultipartOptions = {}): Promise<BlobMultipartUpload> {
+      pathname = decodeURI(pathname)
+      const { contentType: optionsContentType, contentLength, addRandomSuffix, prefix, ...customMetadata } = options
+      const contentType = optionsContentType || getContentType(pathname)
+
+      const { dir, ext, name: filename } = parse(pathname)
+      if (addRandomSuffix) {
+        pathname = joinURL(dir === '.' ? '' : dir, `${slugify(filename)}-${randomUUID().split('-')[0]}${ext}`)
+      } else {
+        pathname = joinURL(dir === '.' ? '' : dir, `${slugify(filename)}${ext}`)
+      }
+      if (prefix) {
+        pathname = joinURL(prefix, pathname)
+      }
+
+      const httpMetadata: Record<string, string> = { contentType }
+      if (contentLength) {
+        httpMetadata.contentLength = contentLength
+      }
+
+      const mpu = await bucket.createMultipartUpload(pathname, { httpMetadata, customMetadata })
+
+      return mapR2MpuToBlobMpu(mpu)
+    },
+    resumeMultipartUpload(pathname: string, uploadId: string) {
+      const mpu = bucket.resumeMultipartUpload(pathname, uploadId)
+
+      return mapR2MpuToBlobMpu(mpu)
+    },
     async handleUpload(event: H3Event, options: BlobUploadOptions = {}) {
       const opts = { formKey: 'file', multiple: true, ...options } as BlobUploadOptions
 
@@ -314,7 +428,8 @@ export function hubBlob(): HubBlob {
   }
   return {
     ...blob,
-    delete: blob.del
+    delete: blob.del,
+    handleMultipartUpload: createMultipartUploadHandler(blob)
   }
 }
 
@@ -331,7 +446,7 @@ export function hubBlob(): HubBlob {
  *
  * @see https://hub.nuxt.com/docs/storage/blob
  */
-export function proxyHubBlob(projectUrl: string, secretKey?: string) {
+export function proxyHubBlob(projectUrl: string, secretKey?: string): HubBlob {
   requireNuxtHubFeature('blob')
 
   const blobAPI = ofetch.create({
@@ -389,6 +504,48 @@ export function proxyHubBlob(projectUrl: string, secretKey?: string) {
       }
       return
     },
+    async createMultipartUpload(pathname: string, options: BlobMultipartOptions = {}) {
+      return await blobAPI<BlobMultipartUpload>(`/multipart/${decodeURI(pathname)}`, {
+        method: 'POST',
+        body: options
+      })
+    },
+    resumeMultipartUpload(pathname: string, uploadId: string): BlobMultipartUpload {
+      return {
+        pathname,
+        uploadId,
+        async uploadPart(partNumber: number, body: string | ReadableStream<any> | ArrayBuffer | ArrayBufferView | Blob): Promise<BlobUploadedPart> {
+          return await blobAPI<BlobUploadedPart>(`/multipart/${decodeURI(pathname)}`, {
+            method: 'PUT',
+            query: {
+              uploadId,
+              partNumber
+            },
+            body
+          })
+        },
+        async abort(): Promise<void> {
+          await blobAPI(`/multipart/${decodeURI(pathname)}`, {
+            method: 'DELETE',
+            query: {
+              uploadId
+            }
+          })
+        },
+        async complete(parts: BlobUploadedPart[]): Promise<BlobObject> {
+          return await blobAPI<BlobObject>('/multipart/complete', {
+            method: 'POST',
+            query: {
+              pathname,
+              uploadId
+            },
+            body: {
+              parts
+            }
+          })
+        }
+      }
+    },
     async handleUpload(event: H3Event, options: BlobUploadOptions = {}) {
       return await blobAPI('/', {
         method: 'POST',
@@ -400,7 +557,148 @@ export function proxyHubBlob(projectUrl: string, secretKey?: string) {
 
   return {
     ...blob,
-    delete: blob.del
+    delete: blob.del,
+    handleMultipartUpload: createMultipartUploadHandler(blob)
+  }
+}
+
+function createMultipartUploadHandler(
+  hub: Pick<HubBlob, 'createMultipartUpload' | 'resumeMultipartUpload'>
+): HubBlob['handleMultipartUpload'] {
+  const { createMultipartUpload, resumeMultipartUpload } = hub
+
+  const createHandler = async (event: H3Event, options?: BlobMultipartOptions) => {
+    const { pathname } = await getValidatedRouterParams(event, z.object({
+      pathname: z.string().min(1)
+    }).parse)
+
+    try {
+      const object = await createMultipartUpload(pathname, options)
+      return {
+        uploadId: object.uploadId,
+        pathname: object.pathname
+      }
+    } catch (e: any) {
+      throw createError({
+        statusCode: 400,
+        message: e.message
+      })
+    }
+  }
+
+  const uploadHandler = async (event: H3Event) => {
+    const { pathname } = await getValidatedRouterParams(event, z.object({
+      pathname: z.string().min(1)
+    }).parse)
+
+    const { uploadId, partNumber } = await getValidatedQuery(event, z.object({
+      uploadId: z.string(),
+      partNumber: z.coerce.number()
+    }).parse)
+
+    const contentLength = Number(getHeader(event, 'content-length') || '0')
+
+    const stream = getRequestWebStream(event)!
+    const body = await streamToArrayBuffer(stream, contentLength)
+
+    const mpu = resumeMultipartUpload(pathname, uploadId)
+
+    try {
+      return await mpu.uploadPart(partNumber, body)
+    } catch (e: any) {
+      throw createError({ status: 400, message: e.message })
+    }
+  }
+
+  const completeHandler = async (event: H3Event) => {
+    const { pathname } = await getValidatedRouterParams(event, z.object({
+      pathname: z.string().min(1)
+    }).parse)
+
+    const { uploadId } = await getValidatedQuery(event, z.object({
+      uploadId: z.string().min(1)
+    }).parse)
+
+    const { parts } = await readValidatedBody(event, z.object({
+      parts: z.array(z.object({
+        partNumber: z.number(),
+        etag: z.string()
+      }))
+    }).parse)
+
+    const mpu = resumeMultipartUpload(pathname, uploadId)
+    try {
+      const object = await mpu.complete(parts)
+      return object
+    } catch (e: any) {
+      throw createError({ status: 400, message: e.message })
+    }
+  }
+
+  const abortHandler = async (event: H3Event) => {
+    const { pathname } = await getValidatedRouterParams(event, z.object({
+      pathname: z.string().min(1)
+    }).parse)
+
+    const { uploadId } = await getValidatedQuery(event, z.object({
+      uploadId: z.string().min(1)
+    }).parse)
+
+    const mpu = resumeMultipartUpload(pathname, uploadId)
+
+    try {
+      await mpu.abort()
+    } catch (e: any) {
+      throw createError({ status: 400, message: e.message })
+    }
+  }
+
+  const handler = async (event: H3Event, options?: BlobMultipartOptions) => {
+    const method = event.method
+    const { action } = await getValidatedRouterParams(event, z.object({
+      action: z.enum(['create', 'upload', 'complete', 'abort'])
+    }).parse)
+
+    if (action === 'create' && method === 'POST') {
+      return {
+        action,
+        data: await createHandler(event, options)
+      }
+    }
+
+    if (action === 'upload' && method === 'PUT') {
+      return {
+        action,
+        data: await uploadHandler(event)
+      }
+    }
+
+    if (action === 'complete' && method === 'POST') {
+      return {
+        action,
+        data: await completeHandler(event)
+      }
+    }
+
+    if (action === 'abort' && method === 'DELETE') {
+      return {
+        action,
+        data: await abortHandler(event)
+      }
+    }
+
+    throw createError({ status: 405 })
+  }
+
+  return async (event: H3Event, options?: BlobMultipartOptions) => {
+    const result = await handler(event, options)
+
+    if (result.data) {
+      event.respondWith(Response.json(result.data))
+    } else {
+      sendNoContent(event)
+    }
+    return result
   }
 }
 
@@ -417,6 +715,21 @@ function mapR2ObjectToBlob(object: R2Object): BlobObject {
   }
 }
 
+function mapR2MpuToBlobMpu(mpu: R2MultipartUpload): BlobMultipartUpload {
+  return {
+    pathname: mpu.key,
+    uploadId: mpu.uploadId,
+    async uploadPart(partNumber: number, value: string | ReadableStream<any> | ArrayBuffer | ArrayBufferView | Blob) {
+      return await mpu.uploadPart(partNumber, value as any)
+    },
+    abort: mpu.abort,
+    async complete(uploadedParts: BlobUploadedPart[]) {
+      const object = await mpu.complete(uploadedParts)
+      return mapR2ObjectToBlob(object)
+    }
+  }
+}
+
 // Credits from shared utils of https://github.com/pingdotgg/uploadthing
 type PowOf2 = 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128 | 256 | 512 | 1024
 type SizeUnit = 'B' | 'KB' | 'MB' | 'GB'