# Lost Dataset - Urgent Need

**URL:** </static-proxy?url=https%3A%2F%2Fdiscuss.huggingface.co%2Ft%2Flost-dataset-urgent-need%2F192243%3E%5C
**Category:** 🤗Datasets\
**Created:** [November 20, 2026, 11:49pm UTC](/static-proxy?url=https%3A%2F%2Fdiscuss.huggingface.co%2Ft%2Flost-dataset-urgent-need%2F192243 "2026-11-20T23:49:36Z")\
**Posts on this page:** 2\
**Page:** 1

<div class="post-metadata">

**Author:** ![thealidev](https://sea2.discourse-cdn.com/hellohellohello/user_avatar/discuss.huggingface.co/thealidev/32/65329_2.png) [@thealidev](/static-proxy?url=https%3A%2F%2Fdiscuss.huggingface.co%2Fu%2Fthealidev)%5C
**Post date:** [November 20, 2026, 11:49pm UTC](/static-proxy?url=https%3A%2F%2Fdiscuss.huggingface.co%2Ft%2Flost-dataset-urgent-need%2F192243%2F1 "2026-11-20T23:49:36Z")

</div>

Can anyone help me , i needed files from dataset , but i deleted it last time

---

<div class="post-metadata">

**Author:** ![John6666](https://sea2.discourse-cdn.com/hellohellohello/user_avatar/discuss.huggingface.co/john6666/32/27664_2.png) [@John6666](/static-proxy?url=https%3A%2F%2Fdiscuss.huggingface.co%2Fu%2FJohn6666)%5C
**Post date:** [November 21, 2026, 2:12am UTC](/static-proxy?url=https%3A%2F%2Fdiscuss.huggingface.co%2Ft%2Flost-dataset-urgent-need%2F192243%2F2 "2026-11-21T02:12:55Z")

</div>

Hmm… this is a difficult one, but in any case, I’d suggest **emailing Hugging Face Support first ([website@huggingface.co](mailto:website@huggingface.co))**:

* * *

**There may still be a way to recover the files, but I wouldn’t count on the deleted dataset repository being restorable through a normal user-facing feature.** The answer depends a lot on what was deleted, and whether a copy of the actual files still exists anywhere.

For an **entire deleted Hub dataset repository** , Hugging Face’s [repository management documentation](https://huggingface.co/docs/huggingface_hub/guides/repository) calls repository deletion _irreversible_. That is the documented behavior of the normal delete operation; I couldn’t find a documented self-service “undo” for it. However, there is at least [one public case in which HF staff restored deleted repositories](/static-proxy?url=https%3A%2F%2Fdiscuss.huggingface.co%2Ft%2Fall-of-my-datasets-disappeared-why%2F81035). It involved repositories deleted after an access-token compromise in April 2024, so it is an **exceptional precedent, not a guarantee** for an ordinary accidental deletion.

**What I would do first:**

1. **Email `website@huggingface.co` now.** That address is listed in [HF’s own support documentation](https://huggingface.co/docs/hub/security-2fa). Include the **old dataset URL or `owner/dataset-name`** , approximately **when it was deleted** , and the **specific files or paths you need**. Explain whether the entire dataset repository is gone or whether you deleted individual files. Ask whether the repository can be recovered; **if not, ask whether the particular files could be retrieved instead**. That’s a question for support, not a documented service I can promise is available.
2. **At the same time, look for existing copies.** Check the folder from which the files were originally uploaded, other computers or drives, a local Git clone, downloads, cloud backups, a mirror, or copies held by collaborators who are allowed to share them. If you previously downloaded or loaded the dataset with HF tools, check the local caches too.
3. **Preserve whatever is still there.** In particular, don’t clear your HF caches, overwrite the only local working copy, or start experimenting with Git history rewrites while looking for the data. If you’re considering recreating a repository with the _same_ name, I’d ask support first, just to avoid making the situation harder to disentangle.

The quickest distinction is: **did you delete the entire dataset repository, or did you delete files _inside_ a repository that still exists?** If the repo still exists, ordinary file-deletion commits may be recoverable from an older Git revision. If the entire repo was deleted, contacting HF and finding independent copies become the main paths.

A short decision guide, followed by details if useful:

| What happened? | Most useful next step |
| --- | --- |
| **The whole dataset repository was deleted** | Contact HF Support with the original repository identity and desired file paths; search any independent copies in parallel. |
| **Only files inside an existing repository were removed** | Check its commit history and earlier revisions before making further changes. |
| **Only the files on your own computer were deleted** | If the hosted dataset is still accessible to you, download the needed files from it. |
| **You downloaded or loaded the dataset on another machine before** | Inspect that machine’s saved files and HF caches. |
| **The repository seems missing, but deletion is not certain** | Check while signed in to the correct account; private repositories can look like 404s to outsiders, and moves/renames have different behavior. |

> **1. If you deleted the entire dataset repository**
>
> This is the hardest branch. The [official repository guide](https://huggingface.co/docs/huggingface_hub/guides/repository) calls `delete_repo` irreversible, and I found no documented trash folder or self-service undo. I would not expect an old commit hash to restore a deleted repository on its own.
> 
> A Git commit history belongs to a repository. If the **repository itself** no longer exists on the Hub, a history URL or an old commit hash is not, by itself, a way to make that repository reappear. Similarly, knowing the old file’s SHA-256 or an LFS pointer is not the same as having access to the file’s bytes. It is useful identifying information, but not proof that the object is still retrievable.
> 
> That said, “irreversible as an ordinary user operation” and “never recoverable by HF staff under any circumstances” are **not equivalent claims**. HF staff have publicly reported restoring deleted repositories in one exceptional incident; see [the April 2024 thread](/static-proxy?url=https%3A%2F%2Fdiscuss.huggingface.co%2Ft%2Fall-of-my-datasets-disappeared-why%2F81035). The underlying circumstances, age of the deleted files, available infrastructure and staff options in your case are not publicly established. I would not assume a retention window, a recovery probability, or a response deadline.
> 
> For the support request, the most helpful information is likely:
> 
> - The original **dataset repository URL** , ideally in the form `https://huggingface.co/datasets/OWNER/REPO`, or the exact `OWNER/REPO` ID if the URL is no longer available.
> - Approximately **when** the deletion occurred, preferably with a date, timezone and rough time if remembered. An estimate is still useful; you needn’t postpone the email to obtain an exact timestamp.
> - Whether this was a **full repository deletion** , file-level deletion, history rewrite, or something else, if you know. It’s fine to say you’re unsure.
> - The **file names or paths** most urgently needed, and whether you need the original uploaded files, the dataset’s processed contents, the Git history, or simply usable data in any format.
> - Whether you owned the dataset personally or it belonged to an organization, and which account can verify ownership. Use your account-associated address when practical.
> - Any other relevant facts that you already have, such as a local clone, public mirror, backup, or a previously downloaded snapshot. No need to gather elaborate logs before asking.
> 
> It may be worth asking two separate questions: **(a) Can the original repository be restored?** and **(b) Even if the original repository and its history cannot be restored, is there any possibility of retrieving the specific files?** The second request matches your actual goal if you primarily need a few files, but I have not found a public HF policy promising file-only recovery after repository deletion. Support would have to determine what, if anything, remains possible.
> 
> There are a few things I would _not_ assume:
> 
> - I would **not** assume that the Hub has a public 30-day, 60-day, or 90-day deleted-repository recycle bin. The corresponding features of other hosting services are not HF policy.
> - I would **not** assume that an old Git commit link, a dataset viewer page, a dataset card in a search index, or a visible LFS pointer guarantees that the data object still exists.
> - I would **not** assume that a new repository created with the same ID will resurrect the old one or its previous commits. A newly created repository is not automatically the old repository.
> - I would **not** assume that staff can recover a specific version of an object from an internal backup or tell you how long backups are retained. I haven’t found public documentation establishing those details.
> 
> One small precaution: in the [2024 recovery discussion](/static-proxy?url=https%3A%2F%2Fdiscuss.huggingface.co%2Ft%2Fall-of-my-datasets-disappeared-why%2F81035)%2C the affected user reported that they had recreated two repositories before restoration and initially still needed help with those. HF staff subsequently restored the remaining repositories. That does **not** establish a general technical rule about name collisions, but it is enough reason to avoid unnecessary changes to the same repository ID while an exceptional restore is being investigated. If you’ve already recreated it, just tell support; it is not a reason to give up.
> 
> If the file is very urgent, I would start the independent-copy search immediately rather than wait for a reply. A file recovered from the original upload folder or a collaborator’s authorized copy is useful even if the Hub repository itself cannot be reconstructed.

> **2. If the repository still exists, but some files were deleted**
>
> This is a meaningfully different situation, and potentially a much simpler one.
> 
> Hugging Face dataset repositories are Git-backed. If a file was **removed in a normal new commit** , earlier revisions can still contain it. HF’s [documentation on removing sensitive data](https://huggingface.co/docs/hub/security-removing-sensitive-data) explicitly explains why deleting a file in a new commit does not normally remove it from earlier commits. That security warning works in your favor when you’re trying to recover an accidentally removed file.
> 
> The safe first move is **inspection** , not a push or a history modification:
> 
> 1. Open the existing dataset’s **Files and versions** page and look for its **commit history**. If you know approximately when the file was present, find a commit from before its removal.
> 2. Inspect the files at that older revision. An earlier revision can often be viewed with a URL or via the Hub interface. Don’t assume the current `main` branch still contains the file.
> 3. If the file’s original bytes are available there, **download or copy them somewhere separate** before deciding how to put them back into the current dataset.
> 4. If the file is important, verify that the recovered object is complete and usable, not just a pointer file or a partial cached record.
> 
> If you already have a local Git clone, the following are **read-only inspection commands** , not recovery commands that rewrite anything:
> 
> ```bash
> # Run from inside an existing local clone.
> # Check the history of a file; replace the example path.
> git log --all --oneline -- path/to/file.csv
> 
> # See which local branches and tags exist.
> git branch -a
> git tag --list
> 
> # Inspect a file as recorded in a particular local commit.
> # Replace COMMIT_SHA and the path with real values.
> git show COMMIT_SHA:path/to/file.csv
> 
> ```
> 
> These only inspect information already present in that clone. `git log` can reveal when the file changed, and `git show` can inspect the file entry at a selected commit. There are some important limitations:
> 
> - A **partial or shallow clone** may not contain the older commits needed. A clone can also contain Git metadata without all large-file content.
> - For a file stored via **Git LFS** , the Git object may be a small pointer identifying a large file rather than the large file’s actual contents. Seeing its path, filename, hash, or pointer is not proof that the data bytes are locally available.
> - Repositories may use **Xet-backed** storage for large files. The user-facing result is similar: confirm you have the actual content, rather than relying on metadata alone.
> - Git history may have been **rewritten or squashed** , or large files may have been removed using an operation designed to remove content from older revisions too. In those cases an earlier visible-looking commit is not a reliable recovery route.
> 
> The same [HF sensitive-data removal guide](https://huggingface.co/docs/hub/security-removing-sensitive-data) distinguishes an ordinary deletion commit from history-rewriting or permanent large-file deletion. It also explains that some destructive operations remove file contents rather than merely hiding a file from the latest branch. So I would not promise that **every** file deleted from a dataset can be restored with Git.
> 
> If an old revision does contain the complete file, you can usually recover the **file itself** without trying to roll the entire repository backward. That’s preferable if other contributors have added newer data since the deletion. Restoring the whole old tree or force-pushing a previous state could lose newer work; downloading the specific old file first is much safer.
> 
> If the repo still exists but an old revision no longer provides the file contents, that is where the other branches of this advice become relevant: look for a full local checkout, downloaded snapshot, backup, or contact HF with the specific repo ID, revision, file path and observed error. An absent file from an old revision and an entirely deleted repository are different symptoms, and support will need that distinction.
> 
> This branch does **not** require you to install complicated tools if the Files and versions page already lets you inspect the older revision. I would try the web UI first and only use Git commands if you’re comfortable with them or already have the clone.

> **3. If you previously downloaded the dataset: local copies and HF caches**
>
> Even after a hosted repository disappears, a machine that previously used the files may hold something valuable. The main question is **whether the bytes are actually on that machine** , not whether its software still knows the repository’s name.
> 
> I’d search the simpler places first: the source folder used during upload, Downloads, a copied `.zip` or `.tar` archive, a Git checkout, a project work directory, a notebook output directory, mounted drives, cloud-sync history, and another machine that processed the data. If this was an organization or group dataset, a teammate might have an authorized copy. A published mirror, fork, archive, or downstream project may also contain part of the data, although you would want to check that its contents and version are genuinely the ones you need.
> 
> There are then **two Hugging Face caches worth distinguishing** :
> 
> **A. The Hub file cache.** This is used by `huggingface_hub` and other software downloading from the Hub. The normal default location is under `~/.cache/huggingface/hub/`, although `HF_HOME`, `HF_HUB_CACHE`, or a caller’s `cache_dir` can change it. A dataset repository may appear in a directory with a name resembling:
> 
> ```plaintext
> ~/.cache/huggingface/hub/
> datasets--OWNER--REPO/
> refs/
> snapshots/
> blobs/
> 
> ```
> 
> The actual layout can vary with library version, OS and storage backend, so this is an **illustration** , not a guaranteed path in your environment. HF’s [local cache documentation](https://huggingface.co/docs/hub/local-cache) and [Hub cache guide](https://huggingface.co/docs/huggingface_hub/guides/manage-cache) explain the roles of `refs`, `snapshots` and `blobs`.
> 
> In a typical snapshot layout, `snapshots/REVISION/` provides paths corresponding to files that have been downloaded for that particular revision. Those paths may be **symbolic links** into the blob store rather than independent copies. If you find the needed file, copy its **resolved contents** to a separate safe folder and confirm that the copy opens. Don’t delete the blob store after merely copying or moving the symlink itself; a broken symlink would not give you the data.
> 
> The cache may be **partial**. A program that downloaded just `README.md`, one CSV, or one split did not necessarily download the entire dataset. The presence of a dataset cache directory therefore does not mean all original files are recoverable. An old snapshot can be useful, but only for files actually cached.
> 
> Recent HF CLI documentation includes commands to **list** , rather than delete, cached repositories and revisions:
> 
> ```bash
> # If a recent 'hf' CLI is installed, these inspect the local cache.
> hf cache ls
> hf cache ls --revisions
> 
> ```
> 
> See [the official `hf` CLI guide](https://huggingface.co/docs/huggingface_hub/guides/cli). On an older `huggingface_hub` installation, the available commands and syntax can differ; `hf cache --help` or the version-matched docs are safer than assuming every machine has the latest CLI.
> 
> Please **do not** use cache-cleaning commands (`hf cache rm`, `hf cache prune`, older equivalent delete commands, or manual removal of cache folders) during recovery. The [same CLI guide](https://huggingface.co/docs/huggingface_hub/guides/cli) documents those commands as destructive. A cache cleaner may remove an old, unreferenced revision that was your last copy. Even if space is tight, I would make a safe copy of anything relevant before trying to reclaim it.
> 
> **B. The `datasets` processing cache.** The Python `datasets` library can cache data in a processed format, commonly Apache Arrow. This is **not the same thing** as a complete copy of every originally uploaded CSV, JSON, Parquet file, image, or other asset. HF’s [Datasets cache documentation](https://huggingface.co/docs/datasets/cache) discusses the downloaded-file and prepared-dataset cache layers. Their default paths and exact behavior depend on version, configuration, and the way the data was loaded.
> 
> This distinction matters because your goal may be one of two things:
> 
> - **You need the exact original file** (its original bytes, format, schema, ordering, archive members, or perhaps an attached binary file). Then an actual saved copy or a complete Hub cached file is the ideal recovery target. Processed data is not a promise of byte-for-byte restoration.
> - **You mostly need the records or usable dataset content.** Then a prepared `Dataset` or `DatasetDict` already saved on disk, or cache files retained from an earlier job, could still be useful. You might be able to load data that survives locally and export it to a new CSV, JSON or Parquet file. But transformations may have changed the columns, order, encodings, or contents, so the result must be compared with the original requirements.
> 
> For example, **only if you previously used `save_to_disk` and still have the saved directory** , HF documents `load_from_disk` and export methods such as `to_csv`, `to_json`, and `to_parquet` in [the Datasets processing guide](https://huggingface.co/docs/datasets/process). A small illustrative example would be:
> 
> ```python
> from datasets import load_from_disk
> 
> # This only works if this directory was actually saved and still exists.
> restored = load_from_disk("/path/to/previously_saved_dataset")
> 
> print(restored)
> 
> # If 'restored' is a Dataset with the records you need:
> # restored.to_parquet("recovered_data.parquet")
> 
> # If it is a DatasetDict, select an existing split first, for example:
> # restored["train"].to_parquet("recovered_train.parquet")
> 
> ```
> 
> This example is **not** a way to recreate an absent dataset from its old name. It assumes a real local saved directory with usable files. If the saved dataset is in a different format or needs external image/audio files, recovery may be incomplete. If the data was previously read in streaming mode or a temporary cloud environment, there may be no persisted local cache to inspect at all.
> 
> A few more practical distinctions:
> 
> - A script calling `load_dataset("OWNER/REPO")` in the past does **not by itself** prove that the entire repo is in the cache. Inspect what was actually written to disk.
> - A Colab, Space or short-lived remote notebook may have used temporary storage. Unless files were saved to a persistent volume or external location, those files may no longer be there.
> - A **Git checkout** may contain real small files while only pointer files for large LFS objects; a separate downloaded snapshot may contain complete large files; a processed Arrow dataset may preserve records but not original packaging. They are distinct possible assets.
> - A cache entry for a _missing_ file, or an old index entry with metadata, should not be mistaken for the file itself. Test by actually reading a recovered copy.
> - Avoid copying private dataset contents into a public forum message to demonstrate that a cache was found. You can describe filenames, sizes and errors without disclosing sensitive material.
> 
> If only a few files are urgent, search for their **specific filenames** first. Preserve any recovered bytes before considering how to reconstruct a Hub repository.

> **4. If the dataset URL returns 404 but you are not certain it was deleted**
>
> I wouldn’t put this explanation ahead of the support email because you specifically said you deleted the dataset. However, it is worth distinguishing **“I deleted it”** from **“I cannot access the old URL”** , because a missing-looking page does not always identify the cause.
> 
> For a Git-backed dataset repository, possible explanations include a genuine deletion, an incorrect owner or repository name, an access or authentication mismatch, a repository that is now private, or a repository that was renamed or transferred. These have different next steps.
> 
> HF’s [repository settings documentation](https://huggingface.co/docs/hub/repositories-settings) says that a private repository returns `404 - Repo not found` to other users. It also explains that a rename or transfer normally redirects the previous URL to the new location. This does **not** mean that a repo with a 404 is probably private. It simply means 404 alone is not enough to conclude irreversible data loss.
> 
> A quick, low-effort check is to sign in with the account that owned the dataset, inspect the dataset list or relevant organization, and check whether the repository appears under a different location or private visibility. If you still have the exact former URL, keep it for support. If the dataset was truly deleted by your account, the support-and-local-copy route remains the right one.
> 
> If it was an organization-owned dataset, account membership and permissions may matter. Someone with the correct access can verify whether the repository still exists; that is not the same as asking them to make private data public. There is no reason to publish passwords, tokens, organization secrets, or restricted data in this thread.
> 
> If the repository is actually still present and accessible, **don’t reconstruct it from scratch** merely because an old link looks wrong. Download the needed files and investigate the URL or access issue separately.

> **5. What the public recovery precedent does (and does not) establish**
>
> There is a genuine reason to ask HF rather than immediately assume there is no hope. In the April 2024 HF Forum thread [“All of my datasets disappeared, Why?”](/static-proxy?url=https%3A%2F%2Fdiscuss.huggingface.co%2Ft%2Fall-of-my-datasets-disappeared-why%2F81035)%2C an affected user reported that numerous datasets and models had vanished. HF staff said they were restoring repositories deleted through an access token. The user then explained that the token had leaked and reported that most data had been restored. On April 12, a staff member confirmed that the final two repositories were also successfully restored.
> 
> That is **a documented example of staff-assisted restoration** , not merely a theoretical possibility. But the context is crucial: it was a token-compromise incident, not an ordinary self-deletion, and the thread does not disclose a general retention period, recovery tool, eligibility policy, or guarantee for other accounts. Your short post does not suggest a compromised token, so I wouldn’t infer that cause.
> 
> There is no real contradiction between the official [irreversible deletion warning](https://huggingface.co/docs/huggingface_hub/guides/repository) and that incident. The documentation sets expectations for the normal operation available to users; the 2024 thread documents an exceptional staff action. It is reasonable to ask whether something similar is possible in _your_ circumstances, while planning for the answer to be no.
> 
> If you suspect unauthorized access, secure your account and revoke affected tokens using HF’s official account-security guidance; otherwise, the practical recovery request remains the priority. In either case, pursuing support and independent copies in parallel avoids depending on a recovery mechanism no one here can verify.

> **6. A practical checklist for contacting HF without delaying the request**
>
> The official site identifies `website@huggingface.co` as a contact for account-support questions in its [2FA guide](https://huggingface.co/docs/hub/security-2fa). The [repository settings documentation](https://huggingface.co/docs/hub/repositories-settings) also refers to this email for certain exceptional transfer requests. Neither document promises a deletion-recovery service. This is simply a reasonable route for asking HF to investigate a case that cannot be resolved by a documented self-service undelete action.
> 
> You can send the essentials immediately:
> 
> - **Old URL or exact repository ID:** `https://huggingface.co/datasets/OWNER/REPO`, or `OWNER/REPO` if the URL is lost. Clarify whether it was under your personal account or an organization.
> - **Approximate deletion date:** include a timezone or rough time if known, but don’t delay the message because you cannot remember the precise timestamp.
> - **Scope:** was the entire dataset repository removed, or were individual files deleted from an otherwise existing repository? If uncertain, say so.
> - **Files needed:** a few important names/paths, and whether you need the exact originals or would accept the underlying records in another format.
> - **Request:** ask whether HF can restore the old repository and, **if that is impossible** , whether the particular named files could still be retrieved. The second option is a question, not an advertised capability.
> 
> If readily known, add whether you deleted via the website, API, automation, or Git history rewrite; whether the repo was private; whether you had a local clone; and whether you suspect an unauthorized deletion. These are **optional details** , not prerequisites for the first email.
> 
> Please do not put passwords, access tokens, session cookies, SSH private keys, backup codes, private dataset contents, or other secrets in a forum reply. The old repository ID and non-sensitive file paths are usually enough for a public technical discussion. Use a suitable private channel with support for sensitive ownership or content details. No recovery attempt should require posting your credentials.
> 
> While waiting for any response, preserve local files and continue the independent-copy search. Avoid deleting caches, rewriting Git history, force-pushing, or replacing a repository with the same identifier just to experiment. And don’t assume HF has published a particular response time or a guaranteed backup window; I haven’t seen documentation that establishes either for ordinary deleted dataset repositories.

> **7. How to recognize whether a recovered copy is actually enough**
>
> A recovery doesn’t always have to reconstruct the entire original Hub repository to solve the problem. If you only need certain files, the success criterion could be much smaller. I would decide what “recovered” means before doing any risky repair:
> 
> **If you need exact originals:** Check that the reconstructed or downloaded files are of the expected type and size, open correctly, and contain the information you need. If you already know a trusted checksum from before deletion, compare it. An LFS pointer file that only records an object hash and size does not count as the original file.
> 
> **If you need dataset records:** A working local Arrow cache or previously saved `Dataset` may be enough to export useful records to another format. It may not reproduce the original raw data packaging, column ordering, formatting, binary attachments, or preprocessing history. Check a few representative rows, splits and media references before calling it complete.
> 
> **If you need a specific revision:** Check which commit or saved dataset version the copy represents. A copy from a mirror or another machine could be older than the deleted version. A copy of `main` does not necessarily contain every branch, tag or history item.
> 
> **If you need dependent assets:** A CSV, JSON or Parquet table might refer to image files, audio files, documents or external URLs. Recovering the table without those assets could be only a partial success. Conversely, if all you need is a data table, it may be unnecessary to reconstruct unrelated assets.
> 
> **If you have a mixture of partial sources:** Keep track of where each one came from. For example, perhaps one machine has a complete older download and another has a few newly added files. Combining these may restore the files you actually need, but avoid silently treating a stitched-together dataset as a byte-identical original release.
> 
> I would make a separate folder for recovered material and avoid editing the only source copy. If you later re-upload anything, do it only after checking which files are correct and whether publishing or sharing them is authorized. The immediate goal is the files; recreating the original online repository name, commit graph or visibility can be a separate decision.

> **8. Official references for the different recovery paths**
>
> These links serve different purposes; none is a universal undelete method. For **repository deletion** , see the [Hub repository guide](https://huggingface.co/docs/huggingface_hub/guides/repository) and the exceptional [April 2024 staff recovery thread](/static-proxy?url=https%3A%2F%2Fdiscuss.huggingface.co%2Ft%2Fall-of-my-datasets-disappeared-why%2F81035). For **ordinary file deletion versus permanent removal** , see [removing sensitive data](https://huggingface.co/docs/hub/security-removing-sensitive-data) and [storage limits](https://huggingface.co/docs/hub/storage-limits). For **local recovery** , see [the Hub cache](https://huggingface.co/docs/huggingface_hub/guides/manage-cache), [Datasets caches](https://huggingface.co/docs/datasets/cache), [CLI inspection](https://huggingface.co/docs/huggingface_hub/guides/cli), and [local dataset processing/export](https://huggingface.co/docs/datasets/process). For a **404 or changed URL** , see [repository settings](https://huggingface.co/docs/hub/repositories-settings).
> 
> The important distinction is whether the **complete original bytes** exist anywhere that you can still access. Repository identity, historical links, conversion metadata, LFS pointers, and cached indices may be clues, but they are not by themselves a copy of a file.

**Bottom line:** For a truly deleted dataset repository, **contact HF Support first** and give them the old repository ID, rough deletion date and the files you need. **Search existing copies in parallel**. If you only deleted individual files from a repository that still exists, checking its **older revisions** may be the faster route.

If you can clarify just one thing here, the most useful distinction would be whether the **whole dataset repository was deleted** or only **files inside it**. An old URL and approximate deletion date may help too, but you can send those directly to HF if they aren’t suitable for a public thread. I can’t tell from the current post whether a recovery is technically possible in your particular case, and I wouldn’t want to promise something HF alone can confirm.
