S3 "NoSuchUpload: The Specified Upload Does Not Exist": Why It Often Means Your Upload Succeeded, the Lifecycle Rule That Aborts Live Uploads, and the Retry-Safe Fix
S3's "NoSuchUpload: The specified upload does not exist. The upload ID may be invalid, or the upload may have been aborted or completed" (HTTP 404) means S3 no longer knows the multipart upload ID you sent. There are three ways that happens: the ID is wrong, something aborted the upload, or it already completed. That last one is the surprise, because it often means your upload worked. Finishing a multipart upload can take several minutes, and S3 can send "200 OK" first and the result later. If your code or SDK timed out and retried, the retry asks to finish an upload that's already finished, and gets NoSuchUpload. Before re-uploading anything, check whether the object is there: a finished multipart object's ETag ends with a dash and the number of parts, such as -2. The other common cause is a lifecycle rule that aborts unfinished uploads after a few days, which also cuts off slow uploads that are still running. This page shows how to tell which cause you have, a retry-safe way to complete uploads in Python, and how to keep cleanup rules from killing live uploads.
Ethan backs up the database for his friend Jake's phone repair shop to S3 every night, a few gigabytes sent as a multipart upload. Twice in one week, the job ended with NoSuchUpload, and Ethan assumed the backup had failed. The first time, he re-ran the whole upload. The second time, he looked in the bucket first. The backup was there, complete and correct. The error had come from the job's own retry.
New to S3 uploads? A multipart upload sends a big file to S3 in pieces. You start it, which gives you an upload ID, send the parts, and then ask S3 to stitch them into one object. The AWS CLI and SDKs do this for you automatically for large files, which is why many people meet NoSuchUpload without ever having typed "multipart." Our guide to S3 covers the basics.
What NoSuchUpload means
Every multipart upload goes through three steps, and the upload ID ties them together:
- CreateMultipartUpload starts the upload and returns an upload ID.
- UploadPart sends each piece, 5 MiB to 5 GiB each (the last part can be smaller), up to 10,000 parts.
- CompleteMultipartUpload tells S3 to join the parts into one object. After that, the upload ID is gone.
NoSuchUpload, HTTP status 404, means S3 has no live upload with the ID you sent. The message lists the three reasons in one sentence:
An error occurred (NoSuchUpload) when calling the ListParts operation: The specified upload does not exist. The upload ID may be invalid, or the upload may have been aborted or completed.
The operation in your message is the first clue. It tells you where in the three steps you were:
| Operation in the message | When it fails | Most likely cause |
|---|---|---|
CompleteMultipartUpload | At the very end, often after a retry | The upload already completed |
UploadPart, partway through | In the middle of a long upload | Something aborted it: a lifecycle rule, a cleanup job, or another process |
UploadPart or ListParts, immediately | On the first call that uses the ID | The ID, bucket or key doesn't match the upload that was started |
AbortMultipartUpload | During cleanup | It was already aborted or completed; nothing to do |
Jake: "So 'does not exist' can mean it's finished?"
Ethan: "That's the bit that fooled me. Once the upload's done, its ID stops existing. Ask about it again, and S3 says it's never heard of it."
First check: did the upload actually finish?
Finishing a multipart upload isn't instant. For a large object, CompleteMultipartUpload can take several minutes. S3 sends "200 OK" as soon as it starts working, then keeps the connection alive with spaces until it's done, and the real result, success or an error, arrives at the end. Two things follow from that:
- A client with a short timeout can give up while S3 is still finishing, and report a failure for an upload that then succeeds.
- Applications are expected to retry a failed Complete. But if the first attempt did succeed, the retry asks S3 to finish an upload ID that no longer exists, and gets NoSuchUpload.
So before you treat NoSuchUpload as a failure, look for the object:
aws s3api head-object --bucket jake-shop-backups --key backups/repairs.db --query "{ETag:ETag,Size:ContentLength,Modified:LastModified}"
{
"ETag": "\"f436196df570a2b3ced1354ba6f61eca-2\"",
"Size": 7340032,
"Modified": "2026-10-13T17:58:59+00:00"
}
Read three things. The ETag ends with -2: S3 builds a multipart object's ETag from the parts and adds a dash with the number of parts, so an ending of -2 means two parts were joined, which matches this upload. The size matches the file. And Modified is just after the upload started. All three match, so the upload finished, and the NoSuchUpload was only the retry. A 404 from head-object means there's really no object, and you have one of the other causes.
If the same key is overwritten often, check the time and size carefully, so you don't mistake yesterday's backup for today's.
Retry-safe completion in Python
Build the check into your code, so a successful upload is never reported as a failure. This function completes an upload, and if S3 answers NoSuchUpload, looks for the finished object before giving up:
import boto3
from botocore.exceptions import ClientError
s3 = boto3.client("s3")
def complete_upload(bucket, key, upload_id, parts):
"""Complete a multipart upload. If S3 says NoSuchUpload, check whether an earlier attempt already finished it."""
try:
resp = s3.complete_multipart_upload(
Bucket=bucket, Key=key, UploadId=upload_id, MultipartUpload={"Parts": parts}
)
return resp["ETag"]
except ClientError as e:
if e.response["Error"]["Code"] != "NoSuchUpload":
raise
head = s3.head_object(Bucket=bucket, Key=key) # 404 here means it really never completed
if head["ETag"].strip('"').endswith(f"-{len(parts)}"):
print(f"{key}: upload had already completed, ETag {head['ETag']}")
return head["ETag"]
raise
When the earlier attempt had finished, it reports that and returns the ETag:
backups/repairs.db: upload had already completed, ETag "f436196df570a2b3ced1354ba6f61eca-2"
When the upload never finished, head_object raises a 404, and your code knows it must upload again. For an even tighter check, compare the object's LastModified with the time you started the upload. If you use boto3's upload_file or the AWS CLI's aws s3 cp, the multipart steps happen inside the library, but the same check, does the object exist with the right size, still tells you whether a failed run actually failed. Our boto3 error handling guide explains reading error codes from ClientError.
Something aborted the upload
If the error comes from UploadPart in the middle of a long upload, something ended the upload while you were still sending parts. Once an upload is aborted, S3 deletes its parts, and every later call with that ID gets NoSuchUpload. Three things usually do it.
1. A lifecycle rule for incomplete uploads
Many buckets have a lifecycle rule with the AbortIncompleteMultipartUpload action, and it's a sensible rule to have, because unfinished uploads cost money: until you complete or abort an upload, you pay for the storage and requests of every part already sent. The rule stops any upload that isn't completed within a set number of days of starting, and it applies to uploads already in progress, not just new ones. See whether your bucket has one:
aws s3api get-bucket-lifecycle-configuration --bucket jake-shop-backups
{
"TransitionDefaultMinimumObjectSize": "all_storage_classes_128K",
"Rules": [
{
"ID": "abort-incomplete-uploads",
"Filter": {
"Prefix": ""
},
"Status": "Enabled",
"AbortIncompleteMultipartUpload": {
"DaysAfterInitiation": 7
}
}
]
}
A seven-day rule never touches a normal nightly backup. It does cut off an upload that runs for more than seven days, such as a huge file over a slow line, or a job that pauses and resumes days later with the same upload ID. The fix isn't to delete the rule. Give long-running uploads a separate prefix that the rule doesn't cover, or set the days above your longest upload. This rule only covers backups/, so a slow upload under archive/ is never cut off:
aws s3api put-bucket-lifecycle-configuration --bucket jake-shop-backups --lifecycle-configuration '{"Rules":[{"ID":"abort-incomplete-uploads","Status":"Enabled","Filter":{"Prefix":"backups/"},"AbortIncompleteMultipartUpload":{"DaysAfterInitiation":7}}]}'
This command replaces the bucket's entire lifecycle configuration, so include every other rule the bucket has in the same JSON. Our lifecycle rule guide covers prefixes, filters and timing.
2. A cleanup script or another tool
A scheduled job that aborts "stale" uploads, or a teammate tidying the bucket, ends uploads the same way. Your own code can do it too: error handling that calls AbortMultipartUpload after a failed part ends the upload for every other process still holding that ID.
3. Two workers finishing the same upload
If two processes share an upload ID, for example a browser and a server that both call Complete, or two retries running at once, the first to complete wins and the second gets NoSuchUpload. Give exactly one place in your code the job of completing each upload.
Jake: "So the cleaning rule threw away a job that wasn't finished yet."
Ethan: "Right. It can't tell slow from abandoned. You tell it, with the number of days and where it applies."
Wrong upload ID, bucket or key
If NoSuchUpload comes straight away, on the first UploadPart or ListParts, the ID doesn't belong to an upload S3 knows about. Every call in an upload must use the same bucket, the same key and the same upload ID that CreateMultipartUpload returned. The usual mistakes:
- A different key. The parts are sent with a slightly different object name than the one used to start the upload, such as a missing folder prefix or a changed file extension.
- A stale ID. The ID was saved from an earlier run, a cache or a browser session, and that upload has since completed or been aborted.
- A damaged ID. An ID that was cut short or altered on its way through a database, a URL or a log no longer matches.
List the uploads S3 really has in progress, with their keys and start times, and compare them with what your code is sending:
aws s3api list-multipart-uploads --bucket jake-shop-backups --query "Uploads[].{Key:Key,UploadId:UploadId,Started:Initiated}"
If your upload isn't in the list, it's finished or aborted, or it was never started in this bucket.
Running a multipart upload by hand
To see every step, or to rebuild a broken upload, here's the whole flow with the AWS CLI. Each command uses the upload ID from the first:
UPLOAD_ID=$(aws s3api create-multipart-upload --bucket jake-shop-backups --key backups/repairs.db --query UploadId --output text)
E1=$(aws s3api upload-part --bucket jake-shop-backups --key backups/repairs.db --part-number 1 --body part1.bin --upload-id "$UPLOAD_ID" --query ETag --output text)
E2=$(aws s3api upload-part --bucket jake-shop-backups --key backups/repairs.db --part-number 2 --body part2.bin --upload-id "$UPLOAD_ID" --query ETag --output text)
printf '{"Parts":[{"PartNumber":1,"ETag":%s},{"PartNumber":2,"ETag":%s}]}' "$E1" "$E2" > parts.json
aws s3api complete-multipart-upload --bucket jake-shop-backups --key backups/repairs.db --upload-id "$UPLOAD_ID" --multipart-upload file://parts.json --query ETag --output text
"f436196df570a2b3ced1354ba6f61eca-2"
The limits that decide how you split a file:
| Limit | Value |
|---|---|
| Part size | 5 MiB to 5 GiB; the last part has no minimum |
| Parts per upload | Up to 10,000, numbered 1 to 10,000 |
| Largest object | 48.8 TiB |
| Parts returned by one ListParts request | 1,000 |
| Uploads returned by one ListMultipartUploads request | 1,000 |
Part 1 here is 6 MiB and part 2 is 1 MiB: every part except the last must be at least 5 MiB. After the complete, aws s3api list-parts with the same upload ID returns NoSuchUpload, which is exactly the "completed" case from the top of this page. For the CLI's automatic multipart uploads, part sizes and big-file limits, our EntityTooLarge guide goes step by step.
Clean up abandoned uploads, carefully
Unfinished uploads keep costing money until they're completed or aborted, so a cleanup is worth doing, just not one that catches live uploads. This script aborts uploads older than the number of days you give it and leaves newer ones alone. Run it as python3 abort_stale.py jake-shop-backups 7:
import sys
from datetime import datetime, timedelta, timezone
import boto3
s3 = boto3.client("s3")
bucket, days = sys.argv[1], int(sys.argv[2])
cutoff = datetime.now(timezone.utc) - timedelta(days=days)
for page in s3.get_paginator("list_multipart_uploads").paginate(Bucket=bucket):
for up in page.get("Uploads", []):
started = up["Initiated"]
if started < cutoff:
s3.abort_multipart_upload(Bucket=bucket, Key=up["Key"], UploadId=up["UploadId"])
print(f"aborted {up['Key']} (started {started:%Y-%m-%d})")
else:
print(f"kept {up['Key']} (started {started:%Y-%m-%d})")
Pick the number of days the same way as for a lifecycle rule: longer than your slowest legitimate upload. For a bucket you don't want to babysit, the lifecycle rule above does this job on its own schedule.
Prevent it: four habits for multipart uploads
- Check before you report. When Complete fails, look for the object with head-object before calling the upload a failure or starting again.
- Give Complete time. Use a timeout of several minutes for CompleteMultipartUpload on large files, so your client doesn't give up while S3 is still joining the parts.
- Keep one owner per upload. Exactly one process starts, completes or aborts each upload ID.
- Match cleanup to your slowest upload. Set lifecycle rules and cleanup scripts to more days than your longest legitimate upload, or keep long uploads under their own prefix.
Jake: "So most of this is just patience and checking."
Ethan: "And one rule about who's in charge of each upload. That's all it took to stop the night-time alarms."
Troubleshooting by symptom
NoSuchUpload on CompleteMultipartUpload after a timeout or retry
The first attempt probably succeeded. Run head-object: an ETag ending in -N, where N is your part count, plus the right size, means the upload is done.
NoSuchUpload on UploadPart after the upload ran for days
A lifecycle rule with AbortIncompleteMultipartUpload likely stopped it. Raise its days or exclude that prefix, then start a new upload.
NoSuchUpload on the very first UploadPart
The bucket, key or upload ID doesn't match the CreateMultipartUpload call. Compare them with list-multipart-uploads.
Two processes, one of them always fails
Both are completing or aborting the same upload. Let exactly one place in your code finish each upload.
AbortMultipartUpload returns NoSuchUpload
The upload was already aborted or completed. There's nothing left to clean up.
The backup job failed but the file is in S3
The job's retry hit an upload that had already finished. Make the job check for the object before reporting failure.
S3 NoSuchUpload: frequently asked questions
What does NoSuchUpload mean in S3?
S3 has no live multipart upload with the upload ID you sent. The ID is wrong, the upload was aborted, or it already completed. It's an HTTP 404.
What does "The specified upload does not exist" mean?
It's the NoSuchUpload message. The upload ID no longer refers to an upload in progress, because it was invalid, aborted or completed.
Can NoSuchUpload mean my upload succeeded?
Yes. If CompleteMultipartUpload succeeded but your client timed out and retried, the retry gets NoSuchUpload. Check with head-object before uploading again.
How do I check if an S3 multipart upload completed?
Run aws s3api head-object on the key. A multipart object's ETag ends with a dash and the number of parts, such as -2, and the size and LastModified should match your upload.
Why does S3 abort my multipart upload?
Usually a lifecycle rule with AbortIncompleteMultipartUpload, which stops uploads not completed within a set number of days, including ones in progress. A cleanup script or your own tool aborting after an error can do it too.
How long does an S3 multipart upload stay open?
Until you complete or abort it, unless a lifecycle rule's AbortIncompleteMultipartUpload ends it after the number of days you set. Parts are billed the whole time.
How long does CompleteMultipartUpload take?
It can take several minutes for large objects. S3 sends 200 OK early and the final result at the end, so give it a generous timeout.
How do I list incomplete multipart uploads in S3?
Run aws s3api list-multipart-uploads --bucket NAME. It shows each upload's key, upload ID and start time, up to 1,000 per request.
How do I abort a multipart upload?
Run aws s3api abort-multipart-upload with the bucket, key and upload ID. S3 deletes the uploaded parts, and you stop paying for them.
Do incomplete multipart uploads cost money?
Yes. You're billed for the storage, bandwidth and requests of every uploaded part until the upload is completed or aborted.
What is the minimum part size for S3 multipart upload?
5 MiB for every part except the last, which can be any size. The maximum part size is 5 GiB, and an upload can have up to 10,000 parts.
Why does ListParts return NoSuchUpload?
The upload is no longer in progress: it completed or was aborted, or the ID, bucket or key is wrong. ListParts only works while the upload is open.
What is the difference between NoSuchUpload and NoSuchKey?
NoSuchUpload is about a multipart upload ID that doesn't exist. NoSuchKey means the object you asked for isn't in the bucket.
Should I delete my AbortIncompleteMultipartUpload lifecycle rule?
No. It saves money on abandoned uploads. Set its days above your longest real upload, or exclude the prefix that long uploads use.
Does aws s3 cp use multipart upload?
Yes, for large files the CLI switches to multipart automatically, which is why NoSuchUpload can appear even though you never started an upload by hand.
How do I avoid NoSuchUpload with parallel uploads?
Give each upload exactly one owner that completes or aborts it, and never share one upload ID between processes that might both try to finish it.
For readers preparing for an AWS certification
We have been covering AWS certifications alongside our fixes, so here is a short extra for readers studying for one. If you only came for the fix, you already have it; feel free to skip this part.
Exams that test this topic: Developer – Associate (DVA-C03 from December 1, 2026) • CloudOps Engineer – Associate (SOA-C03).
Here are the exam-style questions this topic tends to raise, with the reasoning you need to answer them:
1. CompleteMultipartUpload returns NoSuchUpload. What happened?
The upload ID was already completed or aborted, often by a retry, a parallel worker or a lifecycle rule that aborts incomplete uploads.
2. How do you list multipart uploads that were never finished?
aws s3api list-multipart-uploads, then abort them with abort-multipart-upload.
3. Do incomplete multipart uploads cost money?
Yes. Uploaded parts are stored and billed until the upload is completed or aborted.
4. Which lifecycle action removes abandoned uploads?
AbortIncompleteMultipartUpload with a number of days after initiation.
5. What must CompleteMultipartUpload include?
The upload ID and the list of part numbers with their ETags, in ascending order.
6. How can a client resume a failed large upload instead of restarting?
Keep the upload ID, call ListParts to see which parts arrived, and upload only the missing parts.
Exam codes and dates change often. Our AWS certification changes page keeps track of what is current.
Ethan changed the backup job in two small ways. When CompleteMultipartUpload fails, the job now checks the object's ETag and size before deciding anything, and the "failed" backups turned out to be fine. He also moved the yearly archive, a slow upload that runs for over a week, to its own prefix outside the seven-day cleanup rule. Jake hasn't seen a backup alarm since, and neither has Ethan's phone at two in the morning.
📌 If you keep one line from this page
NoSuchUpload means the upload ID is gone, and "gone" includes "finished"; check the object with head-object before you call it a failure, and keep cleanup rules longer than your slowest upload.
On Complete → check head-object · mid-upload → lifecycle or cleanup · at once → wrong ID, bucket or key.
Revision note. Written October 13, 2026, for every backup that "failed" and was fine all along. "Don't count your chickens before they hatch," the proverb warns; with S3 uploads, don't count your losses before you check head-object.