Standard Uploads

Learn how to upload files to Supabase Storage.

Uploading

The standard file upload method is ideal for small files that are not larger than 6MB.

You implement file uploads with the supabase-js SDK using the traditional multipart/form-data format. Here's an example of how to upload a file using the standard upload method:

Though you can upload up to 5GB files using the standard upload method, we recommend using TUS Resumable Upload for uploading files greater than 6MB in size for better reliability.

1
import {  } from '@supabase/supabase-js'
2
3
// Create Supabase client
4
const  = ('your_project_url', 'your_supabase_api_key')
5
6
// Upload file using standard upload
7
async function () {
8
  const { ,  } = await ..('bucket_name').('file_path', )
9
  if () {
10
    // Handle error
11
  } else {
12
    // Handle success
13
  }
14
}

1
// Upload file using standard upload
2
Future<void> uploadFile(File file) async {
3
  await supabase.storage.from('bucket_name').upload('file_path', file);
4
}

1
import Supabase
2
3
// Create Supabase client
4
let supabase = SupabaseClient(supabaseURL: URL(string: "your_project_url")!, supabaseKey: "your_supabase_api_key")
5
6
try await supabase.storage.from("bucket_name").upload(path: "file_path", file: file)

1
supabase.storage.from("bucket_name").upload("file_path", bytes)
2
3
//Or on JVM/Android: (This will stream the data from the file to supabase)
4
supabase.storage.from("bucket_name").upload("file_path", file)

1
response = supabase.storage.from_('bucket_name').upload('file_path', file)

1
await supabase.Storage.From("bucket_name").Upload("local_file_path", "file_path");

1
curl -X POST "https://{your_project_ref}.supabase.co/storage/v1/object/{bucket_name}/{file_path}" \
2
  -H "apikey: {your_anon_key}" \
3
  -H "Authorization: Bearer {your_jwt_token}" \
4
  --data-binary "@/local/path/to/your/file.ext"

Overwriting files

When uploading a file to a path that already exists, the default behavior is to return a 400 Asset Already Exists error. If you want to overwrite a file on a specific path you can set the upsert options to true or using the x-upsert header.

1
// Create Supabase client
2
const  = ('your_project_url', 'your_supabase_api_key')
3
4
await ..('bucket_name').('file_path', , {
5
  : true,
6
})

1
await supabase.storage.from('bucket_name').upload(
2
      'file_path',
3
      file,
4
      fileOptions: const FileOptions(upsert: true),
5
    );

1
import Supabase
2
3
// Create Supabase client
4
let supabase = SupabaseClient(supabaseURL: URL(string: "your_project_url")!, supabaseKey: "your_supabase_api_key")
5
6
try await supabase.storage.from("bucket_name")
7
  .upload(
8
    path: "file_path",
9
    file: file,
10
    options: FileOptions(
11
      upsert: true
12
    )
13
  )

1
supabase.storage.from("bucket_name").upload("file_path", bytes) {
2
    upsert = true
3
}

1
response = supabase.storage.from_('bucket_name').upload('file_path', file, {
2
  'upsert': 'true',
3
})

1
await supabase.Storage
2
  .From("bucket_name")
3
  .Upload("local_file_path", "file_path", new FileOptions { Upsert = true });

1
curl -X POST "https://{your_project_ref}.supabase.co/storage/v1/object/{bucket_name}/{file_path}" \
2
  -H "apikey: {your_anon_key}" \
3
  -H "Authorization: Bearer {your_jwt_token}" \
4
  -H "x-upsert: true" \
5
  --data-binary "@/local/path/to/your/file.ext"

We do advise against overwriting files when possible, as our Content Delivery Network will take sometime to propagate the changes to all the edge nodes leading to stale content. Uploading a file to a new path is the recommended way to avoid propagation delays and stale content.

Content type

By default, Storage will assume the content type of an asset from the file extension. If you want to specify the content type for your asset, pass the contentType option during upload.

1
// Create Supabase client
2
const  = ('your_project_url', 'your_supabase_api_key')
3
4
await ..('bucket_name').('file_path', , {
5
  : 'image/jpeg',
6
})

1
await supabase.storage.from('bucket_name').upload(
2
      'file_path',
3
      file,
4
      fileOptions: const FileOptions(contentType: 'image/jpeg'),
5
    );

1
import Supabase
2
3
// Create Supabase client
4
let supabase = SupabaseClient(supabaseURL: URL(string: "your_project_url")!, supabaseKey: "your_supabase_api_key")
5
6
try await supabase.storage.from("bucket_name")
7
  .upload(
8
    path: "file_path",
9
    file: file,
10
    options: FileOptions(
11
      contentType: "image/jpeg"
12
    )
13
  )

1
supabase.storage.from("bucket_name").upload("file_path", bytes) {
2
    contentType = ContentType.Image.JPEG
3
}

1
response = supabase.storage.from_('bucket_name').upload('file_path', file, {
2
  'content-type': 'image/jpeg',
3
})

1
await supabase.Storage
2
  .From("bucket_name")
3
  .Upload(
4
    "local_file_path",
5
    "file_path",
6
    new FileOptions { ContentType = "image/jpeg" },
7
    inferContentType: false);

1
curl -X POST "https://{your_project_ref}.supabase.co/storage/v1/object/{bucket_name}/{file_path}" \
2
  -H "apikey: {your_anon_key}" \
3
  -H "Authorization: Bearer {your_jwt_token}" \
4
  -H "Content-Type: {Content-Type}" \
5
  --data-binary "@/local/path/to/your/file.ext"

Concurrency

When two or more clients upload a file to the same path, the first client to complete the upload will succeed and the other clients will receive a 400 Asset Already Exists error. If you provide the x-upsert header the last client to complete the upload will succeed instead.

Presigned uploads

Standard uploads also support using signed upload tokens to create time-limited URLs that you can share with your users. Create the signed URL by invoking the createSignedUploadUrl method on the SDK, then pass the returned token to uploadToSignedUrl to complete the upload.

1
// Create a signed upload URL
2
const { data } = await supabase.storage.from('bucket_name').createSignedUploadUrl('file_path')
3
4
// Upload to the signed URL
5
const { error } = await supabase.storage
6
  .from('bucket_name')
7
  .uploadToSignedUrl('file_path', data.token, file)

1
// Create a signed upload URL
2
final response = await supabase.storage.from('bucket_name').createSignedUploadUrl('file_path');
3
4
// Upload to the signed URL
5
await supabase.storage.from('bucket_name').uploadToSignedUrl('file_path', response.token, file);

1
// Create a signed upload URL
2
let signedUrl = try await supabase.storage.from("bucket_name").createSignedUploadURL(path: "file_path")
3
4
// Upload to the signed URL
5
try await supabase.storage.from("bucket_name")
6
  .uploadToSignedURL(path: "file_path", token: signedUrl.token, data: file)

1
// Create a signed upload URL
2
val signedUrl = supabase.storage.from("bucket_name").createSignedUploadUrl("file_path")
3
4
// Upload to the signed URL
5
supabase.storage.from("bucket_name").uploadToSignedUrl("file_path", signedUrl.token, bytes)

1
# Create a signed upload URL
2
response = supabase.storage.from_('bucket_name').create_signed_upload_url('file_path')
3
4
# Upload to the signed URL
5
with open('local_file_path', 'rb') as f:
6
    supabase.storage.from_('bucket_name').upload_to_signed_url(
7
        path='file_path',
8
        token=response.token,
9
        file=f,
10
    )

1
// Create a signed upload URL
2
var signedUrl = await supabase.Storage.From("bucket_name").CreateUploadSignedUrl("file_path");
3
4
// Upload to the signed URL
5
await supabase.Storage.From("bucket_name").UploadToSignedUrl("local_file_path", signedUrl);

1
# Create a signed upload URL
2
curl -X POST "https://{your_project_ref}.supabase.co/storage/v1/object/upload/sign/{bucket_name}/{file_path}" \
3
  -H "apikey: {your_anon_key}" \
4
  -H "Authorization: Bearer {your_jwt_token}"
5
6
# Upload to the signed URL, using the token returned above
7
curl -X PUT "https://{your_project_ref}.supabase.co/storage/v1/object/upload/sign/{bucket_name}/{file_path}?token={token}" \
8
  --data-binary "@/local/path/to/your/file.ext"

Revoke signed URLs

You can't revoke individual signed URLs. To revoke all signed URLs, rotate your project's URL signing key, and then revoke the previous key. For more information, see URL Signing Keys.