APK Downloaded but the File Is Nowhere: Scoped Storage, Download Directories, and adb Lookup
The download says complete, but the APK is nowhere in your file manager. Usually the file is fine - it landed in a directory you did not check, has not been indexed by MediaStore yet, or was saved as .bin. Here is how scoped storage changed this, plus executable curl and adb commands to locate it layer by layer.
The progress bar finished, the notification says download complete, and yet Download is empty. The usual reaction is to assume the file vanished, download it again, clear caches, and start wondering whether the storage chip is failing. In most cases nothing vanished at all: the file is simply not in the directory you assumed, or it was never registered in an index your file manager can query.
APKs are unusually prone to this. They are large, they are frequently renamed by browsers and download managers, and they land squarely in the Download collection - the part of Android storage that changed most between Android 9 and Android 14. From Android 10 onward, "the bytes exist" and "other apps can see those bytes" became two different facts. Once you internalise that, the hunt turns into four or five commands in a fixed order.
One boundary before we start: this guide covers "the file is there, you just cannot find it". If a full filesystem search confirms it is genuinely gone, or a cleaner app removed it, that is a different problem - go straight to Recover a Deleted APK File: What Actually Works and What Doesn't.
Four different kinds of "I cannot find it"
The same complaint has four different causes, each with a different fix. Classify first; it saves a lot of pointless re-downloading.
| What you see | Most likely cause | First command to run |
|---|---|---|
| Download finished, Download folder is empty | File went to an app-private directory, or into the MediaStore Downloads collection without a physical path under /sdcard/Download | adb shell content query --uri content://media/external/downloads --projection _id:_display_name:size:relative_path |
A global *.apk search returns nothing | Extension was changed to .bin, .download, or .1, or the case simply differs | adb shell find /sdcard -iname "*apk*" -o -iname "*.bin" |
| The file manager sees it but adb paths disagree | Under scoped storage _data is no longer authoritative; what you see may be a mapped sandbox path | adb shell content query --uri content://media/external/downloads --projection _data:relative_path |
| The file exists but is 0 bytes or far too small | The transfer was truncated, the write failed, or it is only a placeholder | adb shell ls -l /sdcard/Download/ against the Content-Length from curl -I |
The first three are index, path, or naming problems and the file is usually intact. The fourth is a content problem and the file is broken. These two branches diverge at step two, so resist the urge to reinstall anything before you know which one you are on.
The mechanism: where Android actually puts downloaded files
The folk wisdom that "downloads go into the Download folder" is only approximately true after Android 10. This table is the basis for every command below.
| Android version | Storage model | Practical effect on an APK | What to check |
|---|---|---|---|
| 9 and below | Classic external storage; any app can read and write public /sdcard directories | Downloaders write to /sdcard/Download, and file managers see it directly | ls -la /sdcard/Download is usually enough |
| 10 | Scoped Storage introduced, but requestLegacyExternalStorage=true allowed opting out | On one device, an older downloader still writes to the public directory while a newer one uses the Downloads collection | Check both the directory and MediaStore |
| 11 and above | Scoped Storage mandatory, opt-out removed; writing to public downloads must go through MediaStore or the system DownloadManager | _data may be empty or only a logical path; opening it directly can fail | Trust content query, not the path string |
| 12 to 13 | Download collection owned by the system downloads provider; relative_path and is_pending appear | While is_pending=1, the file is invisible to third-party apps | Check is_pending and the task status too |
| 14 and above | Tighter media permissions; READ_MEDIA_* covers images, video and audio only | APKs live in the downloads collection, unaffected by photo permissions, but a type-filtered file manager may still hide them | Turn off the file manager type filter |
Two things get conflated constantly, so keep them separate:
content://media/external/downloadsis the MediaStore Downloads collection, i.e. the media index. Useful columns:_id,_display_name,size,relative_path,_data,date_added,is_pending.content://downloads/public_downloadsis the system DownloadManager task ledger, withtitle,status,total_size,current_bytesanduri.
The first answers "what download files does the system believe exist". The second answers "did that download task actually succeed". When a downloader crashes, you can end up with a task marked successful but no media entry, or the reverse - an entry stuck forever at is_pending=1. That is the single most common mechanical explanation for "it finished, but I cannot find it". Also note that _display_name is the string worth searching for, while relative_path is only a relative directory such as Download/. On many ROMs an empty _data is perfectly normal and is not evidence of a missing file.
Layer 1: pin down a known-good sample with curl
Do not start on the phone. Start on a machine with a network connection and establish exactly how large the file is supposed to be.
curl -sI -L "https://example.com/app.apk" | grep -iE "^(HTTP/|content-length|content-disposition|content-type|accept-ranges)"Each header has a job: the HTTP status confirms the URL is live; Content-Length is the expected byte count; Content-Disposition decides what filename the downloader assigns (its absence is the main reason you get .bin); Content-Type affects type detection; and Accept-Ranges tells you whether a resume is even possible.
Then take a local copy:
curl -L --fail \
-o "$HOME/Desktop/app.apk" \
--write-out "http=%{http_code} size=%{size_download} time=%{time_total}\n" \
"https://example.com/app.apk"
shasum -a 256 "$HOME/Desktop/app.apk"
unzip -l "$HOME/Desktop/app.apk" | head -20Record the size and the SHA-256. That is your only trustworthy baseline for deciding whether the file on the phone is complete. sha256sum is not present on every Android build; when it is missing, just adb pull the file and hash it on the computer.
If things go wrong at this layer, the problem is not "missing file" at all. A 403/404 or an expired link belongs to APK Download 403 and 404: Expired Links and a Retry Checklist. A transfer that dies halfway belongs to Resuming an Interrupted APK Download. And a crawl of a few dozen KB/s belongs to Fast Connection, Slow APK Download: Diagnosing the Three Kinds of Throttling.
Layer 2: locate the real path with adb
First establish the OS version, because it decides which storage model applies:
adb devices
adb shell getprop ro.build.version.release
adb shell idThen work through these four steps.
1) Look at the public directory directly
adb shell ls -la /sdcard/Download/
adb shell ls -la /storage/emulated/0/Download/These usually point at the same place, though mount names vary between ROMs. A hit here means you can skip to the closing step.
2) Search without trusting the extension
adb shell find /sdcard -type f \( -iname "*.apk" -o -iname "*.bin" -o -iname "*.download" -o -iname "*.1" \) 2>/dev/null-iname ignores case and 2>/dev/null suppresses the wall of Permission denied lines. A few stripped-down ROMs ship a find without -o support; in that case run several single-pattern searches instead. Restricting the search to /sdcard rather than / makes an enormous difference in speed.
3) Query the MediaStore index (the decisive step)
adb shell content query --uri content://media/external/downloads \
--projection _id:_display_name:size:relative_path:_data:date_added:is_pending \
--sort "date_added DESC"A typical row looks like Row: 0 _id=1234, _display_name=app.apk, size=84231712, relative_path=Download/, _data=/storage/emulated/0/Download/app.apk, date_added=1763340000, is_pending=0. Read it field by field: compare size with Content-Length; use _display_name as your search string; relative_path tells you the logical subdirectory; is_pending=1 means the entry is still marked "in progress" and is hidden from other apps.
4) Check the DownloadManager task ledger
adb shell content query --uri content://downloads/public_downloads \
--projection _id:title:status:total_size:current_bytes:_data:uriDownloadManager.COLUMN_STATUS is a set of bit flags: STATUS_PENDING=1, STATUS_RUNNING=2, STATUS_PAUSED=4, STATUS_SUCCESSFUL=8, STATUS_FAILED=16. Some vendor providers return raw HTTP status codes instead, so the more robust test is whether current_bytes equals total_size and whether the corresponding file actually exists. Be aware that many ROMs restrict reads on public_downloads; an ordinary adb shell returning No result found. does not prove there were no download tasks, so fall back to the media index from step 3.
Do not forget multiple users and the work profile
adb shell pm list users
adb shell ls -la /storage/emulated/10/Download/User 10 is typically a work profile or secondary user, and the primary file manager cannot see it. This is the same class of space isolation covered in Installed an APK but There's No App Icon.
Layer 3: app-private directories and where each downloader writes
"Download" does not mean one destination. This table explains most cases of an empty Download folder.
| Source | Common package | Typical destination | Visible to other file managers |
|---|---|---|---|
| Chrome | com.android.chrome | /sdcard/Download/, via the system DownloadManager | Usually yes |
| System DownloadManager | com.android.providers.downloads | MediaStore Downloads collection | Yes, but via the index |
| Firefox | org.mozilla.firefox | /sdcard/Download/ | Yes |
| Third-party downloaders (ADM, 1DM and similar) | varies | /sdcard/<appname>/ or a custom folder | Yes, but not under Download |
| Messaging and cloud-drive apps | varies | /sdcard/Android/data/<package>/files/... | Usually no on Android 11+ |
| In-app "save locally" | varies | /data/user/0/<package>/files/... | Only via root or run-as |
adb shell ls -la /sdcard/Android/data/<package>/files/
adb shell dumpsys package <package> | grep -iE "download|external"
adb shell run-as <package> ls -la files/Download/run-as works only for debuggable apps, and /data/data/... requires root. Rooting a phone to find one APK is a bad trade. It is far easier to have the downloader share or export the file into a public directory, or to push the known-good sample from Layer 1 straight to the device with adb push.
Layer 4: extensions, MIME types, and fake APKs
If the server omits Content-Disposition: attachment; filename="app.apk" or returns nothing but Content-Type: application/octet-stream, the downloader cannot infer a type and appends .bin, .download, or .1. Some CDNs use .download for in-progress partial files and only rename them on success - kill the process mid-transfer and that intermediate name sticks.
Confirm on the server first:
curl -sI -L "https://example.com/app.apk" | grep -iE "content-disposition|content-type|content-length"Then rename:
adb shell mv /sdcard/Download/app.bin /sdcard/Download/app.apkA rename does not make the file valid. Run three checks:
# 1) An APK is a ZIP, so the first two bytes should be PK
adb shell "head -c 4 /sdcard/Download/app.apk | xxd"
# 2) Structure: AndroidManifest.xml, classes.dex and META-INF/ should be present
adb pull /sdcard/Download/app.apk /tmp/phone.apk
unzip -l /tmp/phone.apk | head -20
# 3) Compare against the server-side sample
shasum -a 256 /tmp/phone.apk "$HOME/Desktop/app.apk"If all three line up, the file is intact and the only problem was visibility or naming. If size disagrees with Content-Length or the ZIP structure is truncated, treat it as an interrupted transfer and re-download using Resuming an Interrupted APK Download or the 403/404 retry checklist. And even with a matching hash, if the file came from a third-party mirror rather than the official source, do a signature verification check to rule out a repackaged build.
Layer 5: stale indexes, cleaner apps, and hidden filters
A stale index. The old trick was a media scan broadcast:
adb shell am broadcast \
-a android.intent.action.MEDIA_SCANNER_SCAN_FILE \
-d file:///sdcard/Download/app.apkSince Android 10 that broadcast is deprecated for third-party callers and may simply do nothing. The reliable options are letting the downloader re-insert the record through MediaStore, or rebooting so the system rescans. Do not reinstall apps just to refresh an index.
A stuck `is_pending`.
adb shell content query --uri content://media/external/downloads \
--projection _id:_display_name:is_pending:relative_pathA row that stays at 1 almost always means the downloader crashed mid-task. Clearing that downloader's cache or re-downloading rebuilds a clean record.
Cleaner and security apps. A lot of "junk cleaners" classify .apk as disposable and delete it minutes after download. The tell-tale signs: a very recent date_added, no results from a full find, and a completed entry still sitting in the downloader's history. Once you have confirmed this, switch to Recover a Deleted APK File instead of continuing to search.
File manager filters. Some managers show only images, video and documents by default, or hide dotfiles. Switch to one that can show all files, or simply trust the adb output above.
MTP shows nothing on a computer. MTP exposes the MediaStore index, not the real directory tree, so a stale index produces "visible on the phone, invisible on the PC". Reconnect, reboot, or bypass MTP entirely with adb pull.
An order you can actually follow
- Run
curl -sI -LforContent-Length,Content-DispositionandContent-Type, download a local sample, and record its SHA-256 as the correct baseline. - Run
adb shell getprop ro.build.version.releaseto pick the right storage model - 10 is the transition, 11 is where scoped storage becomes mandatory. - Run
adb shell ls -la /sdcard/Download/. A hit means skip to step 7. - Query
content://media/external/downloads. A hit means the file is indexed; note_display_name,size,relative_pathandis_pending. - Run
adb shell find /sdcard -iname "*apk*" -o -iname "*.bin". Found with a strange name, go to step 6; nothing anywhere, go to step 8. - Verify the ZIP magic, internal structure and SHA-256. Matching means rename to
.apk; a mismatch means re-download as a truncated transfer. - Install directly with
adb install -roradb pushpluspm install, bypassing the file manager entirely. - If the whole filesystem genuinely has no copy and a cleaner app is the likely culprit, move to the recovery flow.
- If installation succeeds but no icon appears, that is unrelated to a missing file - see No App Icon After Install.
Close the loop by installing directly
adb push "$HOME/Desktop/app.apk" /data/local/tmp/app.apk
adb shell pm install -r /data/local/tmp/app.apk
adb shell pm path com.example.appThe point of this step is proving the package itself is fine, which cleanly separates "I cannot find the file" from "the install fails". If pm install succeeds but no launcher icon appears, the problem is a launcher entry or the user space. If it returns an INSTALL_FAILED_* code, you are in install territory - see Safely Download APK Files: Five Gates and APK Compatibility Check: SDK, ABI and Density.
Frequently asked questions
Q1: The notification says the download completed, but Download is empty. Was it deleted?
Probably not. Since Android 11 a downloader may write into the MediaStore Downloads collection without a physical path under /sdcard/Download, or into an app-private directory, or into another user space. Query the index with content query before concluding anything was removed.
Q2: content query returns No result found. - what does that mean?
It means there is no such row in the media index for the current user; it does not mean the file does not exist. It could be a pending row, a secondary user, or a private directory. Continue with find and pm list users. Some ROMs restrict reads on content://downloads/public_downloads, so an empty result there is normal.
Q3: I found the file, but opening it says "There was a problem parsing the package". Is that caused by the missing file?
No - that is a content problem. Check the ZIP magic, the internal structure and the SHA-256; a truncated download is the usual culprit. See Resuming an Interrupted APK Download and the 403/404 guide.
Q4: I can see it on the phone, but not over MTP on a PC?
MTP exposes the MediaStore index rather than the real directory tree; a stale index produces exactly this mismatch. Use adb pull to fetch the file, or reboot so the system rescans.
Q5: The file is .bin or .download. Can I just rename it?
That is only step one. Confirm it is a complete ZIP (PK magic, with AndroidManifest.xml listed) and that it matches the server's Content-Length and SHA-256. Otherwise the renamed file still will not install.
Q6: On Android 11+, can I still make a downloader write to any folder I choose?
Not to arbitrary public paths. Apps must go through MediaStore with a relative_path such as Download/MyApps/, or get user authorisation via the system file picker (SAF). This is precisely why "I set a custom folder, and now I cannot find it" became common on newer Android versions.
Q7: Can the primary user see files downloaded inside a work profile?
No. Use adb shell pm list users to get the user id, then inspect /storage/emulated/<id>/Download/. It is the same space-isolation issue that hides app icons.
Q8: adb shell find is slow and keeps printing Permission denied. What should I do?
Restrict the scope to /sdcard, add 2>/dev/null to suppress the noise, or match a keyword directly with -iname. /data and /sdcard/Android/data require elevated privileges and are not needed for ordinary diagnosis.
One-line summary
"Download complete" only means the byte stream finished; it does not mean the file was registered anywhere your file manager looks. Pin down a known-good sample with curl, then use adb to check the public directory, the media index, the task ledger and private spaces in order, and close the loop with adb install. Only when there is genuinely no copy left does the deleted-APK recovery path apply.