Decentralised · confidential · verifiable

Inside it runs Paperless-ngx, on confidential nodes of several operators and with backups at several independent storage providers: no single data centre. The VM is confidential (AMD SEV-SNP); at every start the processor confirms firmware, kernel and initrd, and the app checks that before it hands over a key. You choose how it runs: always on, around the clock, or on demand when you need it, for the bookkeeping, say.

Open the app →With a passkey, no account.

Paperless-ngx is an independent open source project (GPL-3.0). Paperless anywhere is offered by Le Space, is not affiliated with the project and is neither endorsed nor sponsored by it.

  • Resilient

    No single data centre: it computes on nodes of several operators and backs up to several independent storage providers. If a node fails, you start on another.

  • Confidential and checkable

    The VM’s memory and disk are encrypted; the node’s operator cannot read them. What the processor confirms you need not take from us: you can check it. What it does not check is listed beside it, under “Verify”.

  • Around the clock or pay as you use

    A monthly package that fits how you work: always on, around the clock, or a package of hours to start, work and stop.

Don’t trust, verify: who holds which key, what the hardware confirms and what it does not →

Who is it for?

For everyone who does not want to entrust their document archive to a single data centre:

  • If you do not want to depend on one host or one storage provider staying up: the computing runs on nodes of several operators, the backups lie with several independent storage providers. If one fails, you start on another node and restore your backup.
  • If the confidentiality of your documents matters to you: the processor encrypts the VM’s memory, and its disk and the backups are encrypted. The node’s operator and its staff see encrypted data only, and so does whoever breaks into a data centre. What the hardware does not check here is listed under “Verify”.
  • Companies that need their archive around the clock: Paperless anywhere runs always on.
  • Freelancers and small businesses that need it only now and then: your own VM is ready in about a quarter of an hour, say once a week or at the month’s end for the bookkeeping, and uses no compute time in between.

How it works

  1. 01

    Create your vault

    A passkey on your device opens your vault. You also get 24 words to write down: they get you back in without the device. The vault needs no account and no e-mail address. Only when you buy a package does the payment service Stripe ask for an e-mail address, for the receipt and the subscription.

  2. 02

    Start

    The app finds a free TEE node, checks its hardware attestation and only then hands over the disk key. The backup is restored.

  3. 03

    Work

    Paperless-ngx in your browser as usual: upload, tag, search.

  4. 04

    Back up and shut down

    One click: the VM encrypts a backup, stores it decentrally and shuts down. From then on no compute time runs.

What is a TEE?

TEE stands for Trusted Execution Environment: a shielded area that the processor itself protects.

  • Encrypted by the processor

    With AMD SEV-SNP the CPU encrypts the VM’s memory with a key only it knows. The machine the VM runs on sees encrypted data only.

  • The operator cannot read along

    Whoever runs the node cannot read the VM’s memory or disk. What your VM writes also goes into an area it seals at every start with a key of its own. That key exists only in the VM’s memory.

  • Check first, then unlock

    Before the app hands over a key, it has the hardware confirm what was started: firmware, kernel and initrd. If the attestation does not match, the disk stays locked.

Resilient: no single data centre

Your Paperless anywhere depends on no particular machine: it can start on any of these confidential nodes. If one fails, you start on another and restore your backup. The list is live.

Loading the node list … has room full right now

The backups, in turn, lie with several independent storage providers, in the countries you choose.

What still depends on Le Space: balance and billing, the relay through which the app checks the VM’s attestation, the builder for your own image (currently on one node), and the delivery of the app.

Backups where you want them

The backup is encrypted inside the VM before it leaves, and stored with independent storage providers. They regularly prove that they still hold the data.

You choose: regions or countries (for example EU only) and 1 to 3 copies with different providers.

Loading providers …

How do I know my backup is still there?

  • Every storage provider has to prove at least once a day that it still has your backup – at places it does not know beforehand.
  • The proofs are checked by a contract on the Filecoin chain, not by Le Space and not by the provider itself.
  • A provider that does not prove in time shows up in public and is not paid for that time.

The method is called Proof of Data Possession (PDP), part of Filecoin Warm Storage.

See for yourself: in the app you read from the chain yourself, for each copy, whether it is still there – under “What the chain says” with your backup, with “Check now”. You see whether the data set is active, the last proof, the next challenge, missed proofs over the last 30 proving periods, and until when it is paid. Green means: read from the chain by the app itself. The proofs are checked by the contract, not by the app.

How it works, mathematically
  1. Cut up. Your encrypted backup is cut into leaves of 32 bytes each, padded first so that every leaf fits into the number field of the proof system.
  2. Record. The leaves form a Merkle tree with SHA-256 (cut to 254 bits). Its root is the piece’s content address, the piece CID. It is recorded on the chain when the backup is uploaded.
  3. Draw samples. In every proving period the contract draws 5 leaf numbers from the chain’s randomness (the drand beacon). Nobody knows them beforehand, not even the provider.
  4. Prove. The provider hands over exactly these leaves with their Merkle path to the recorded root, and the contract recomputes the path. Without the data it cannot succeed.
  5. Pay. Payment is made only for periods with a valid proof. A missed proof is recorded as a fault on the chain.

The values, as read from the contract (Filecoin mainnet): a proving period lasts at most 24 hours (2880 epochs of 30 seconds), the proof must come within a window of 30 minutes, with 5 samples.

How fast a loss shows: if a share f of the data is missing, each sample hits a missing place with probability f. With k samples per period the loss shows with probability 1 − (1 − f)ᵏ, and within n periods with 1 − (1 − f)ᵏⁿ.

Missingwithin 1 daywithin 7 dayswithin 30 days
100 % (copy gone)100 %100 %100 %
10 %41 %97.5 %> 99.99 %
1 %4.9 %30 %78 %
0.1 %0.5 %3.4 %14 %

A lost copy shows at the next proof. Small damage takes longer – one more reason your backups are kept in several copies with different providers.

What PDP does not prove

  • That the provider hands the data out: PDP proves possession, not retrieval. That is why there are several copies with different providers, and why you can fetch a backup yourself at any time.
  • What happens between two proofs: a loss shows only with one of the following samples, as the calculation shows.
  • What is inside: provider and contract see only encrypted data and checksums. Your backup is encrypted in the VM with the key from your vault before it is uploaded.

With sources and the contracts: How do I know my backup is still there?

Don’t trust. Verify.

Checkable: who holds which key · What the hardware does not check ↓

Where the image is built, how its disk is encrypted, who knows which secret and what the hardware confirms. With what the hardware does not check and how that is covered instead, and where you can check each claim yourself.

Diagram: a GitHub runner builds the image and encrypts it with LUKS; it is stored on Aleph. It runs in a confidential VM (AMD SEV-SNP): firmware, kernel, initrd and owner are measured, the image is not; what the VM writes goes into a data area with a random key only the VM has. Backups are encrypted with age inside the VM and stored on Filecoin. Your browser checks the VM’s attestation and only then sends the passphrase and secrets.1 · BuiltGitHub runnerrootfs.yml builds Debian,Docker, Caddy, scriptsand encrypts (LUKS)2 · StoredAleph storagethe image, encrypted,named by itsSTORE hash3 · RunsConfidential VMAMD SEV-SNP, on an Aleph nodeMeasured ✓firmware · kernel · initrd · ownerImage (LUKS): not measuredopens only withthe image passphraseData area (dm-crypt)random key at every start,in the VM’s memory only4 · Backed upFilecoinencrypted with ageinside the VM,to your keyYouYour browser, your vault① checks the VM’s AMD attestation② only then: passphrase, secretsvia a relay that only forwardsKeysImage passphrase: per image, or yours onlyData area: per start, in the VM onlyVault: with you only Diagram: a GitHub runner builds the image and encrypts it with LUKS; it is stored on Aleph. It runs in a confidential VM (AMD SEV-SNP): firmware, kernel, initrd and owner are measured, the image is not; what the VM writes goes into a data area with a random key only the VM has. Backups are encrypted with age inside the VM and stored on Filecoin. Your browser checks the VM’s attestation and only then sends the passphrase and secrets.1 · BuiltGitHub runnerrootfs.yml builds Debian,Docker, Caddy, scriptsand encrypts (LUKS)2 · StoredAleph storagethe image, encrypted,named by itsSTORE hash3 · RunsConfidential VMAMD SEV-SNP, on an Aleph nodeMeasured ✓firmware · kernel · initrd · ownerImage (LUKS): not measuredopens only withthe image passphraseData area (dm-crypt)random key at every start,in the VM’s memory only4 · Backed upFilecoinencrypted with ageinside the VM,to your keyYouYour browser, your vault① checks the VM’s AMD attestation② only then: passphrase, secretsvia a relay that only forwardsKeysImage passphrase: per image, or yours onlyData area: per start, in the VM onlyVault: with you only

What the hardware confirms

  • Your app checks a report from the AMD processor in the browser: signed by AMD (with certificates from AMD’s key service), not revoked, with a firmware level high enough.
  • The measurement in the report matches the firmware, kernel and initrd of the runtime fixed in the app, and a boot line naming your app key as the owner. The app computes it itself.
  • The report carries a fresh random value and the VM’s TLS key: the connection ends in exactly this VM. Only then do the passphrase and secrets go out, signed by your app key; the VM accepts them only with that signature.
  • The relay in between carries encrypted bytes only. The checking happens in your browser, not there.

What the hardware does not check

  • The image’s content is not measured. That the VM runs the published image rests on its disk opening only with the image passphrase, not on a measurement by the hardware. With your own image only your vault knows that passphrase: Neither Le Space nor Aleph Cloud holds a key that opens your disk – and they cannot slip you a different one either.
  • The public image for trying out has one passphrase per version, shared by everyone using that version. That is why a VM on it gets no backup keys and no fixed address, and starts empty. For real use the app always builds your own image.
  • The build cannot be repeated bit for bit, because Debian packages are fetched while it runs. What goes in can be read.
  • The relay through which the app reaches the VM runs in an ordinary VM and is not attested. It can read nothing and change nothing unnoticed; it can delay or refuse connections, though, and it sees from which IP address which VM is called and when.
  • Besides the hardware, the code is under a security audit; not all of its points are closed yet.

Who knows which secret

5 secrets
SecretWho knows itWho does not
Image passphraseopens your image’s LUKS disk; the image holds nothing personal. Who knows itonly your vault, the attested builder during the build and your VM at its start. (The public image for trying out has one shared passphrase per version.) Who does notLe Space, Aleph Cloud, the node’s operator
Data area keyseals everything the VM writes: documents, database, certificate. Who knows itthe VM only, in memory only, new and random at every start. After the stop it no longer exists. Who does notyou, the app, Le Space, the node
Vault master secret32 random bytes; every key below is derived from it. Who knows ityou: sealed by your passkey (PRF) and by the 24 words, open only in your browser’s memory. Who does notLe Space, Aleph (it holds it sealed only), the VM
Paperless passwords, session keysderived from the vault. Who knows ityour browser; the VM gets them after the check, for this start. Who does notLe Space, the node
Backup key (age)opens your backups; derived from the vault, or pasted in by you. Who knows ityour browser. The VM encrypts to its public part only; it gets the key itself only for a restore and deletes it afterwards. Who does notLe Space, the storage providers: they hold ciphertext only.

What the evidence looks like in the app

Sample, not a real VM

While your VM runs, the app shows for every claim its value, how it knows it and where you can check it. Here with made-up values, since there are no real ones without a booked VM; only the runtime is the real one, it is the same for everyone. In the app, the links lead to your own messages on Aleph.

Evidence of this VM Sample, not a real VM 4 checked by the app · 3 reported · 2 outside the hardware check
  1. Runtimechecked by the app

    Firmware, kernel and initrd. Fixed in the app; if Aleph delivers anything else, the app starts nothing.

    Name
    snp-1.2
    Aleph message
    5cd480a138c5969b18d1f6850a5fe0176e6f22e65a323ad9593e71165fb687bc
    Bundle (SHA-256)
    083630b3b5e22a95ab8f48fdf8a67d80d03420a075ccef97a25d73f8a46378bf
    Boot line
    console=ttyS0 luks=1 owner={owner}
  2. Measurementchecked by the app

    Computed by the app from the runtime and a boot line naming your app key as the owner, and written into the INSTANCE message.

    computed
    example-measurement-0000000000000000
  3. Instancechecked by the app

    The INSTANCE message on Aleph, signed by your app.

    Message
    example-instance-0000000000000000
    paid by
    0xExample-0000000000000000
  4. Nodereported, not confirmed by the hardware

    The Aleph node the VM runs on, and its address.

    Node
    example-node-0000000000000000
    Address
    paperless.example
  5. Attestationchecked by the app

    The AMD processor’s report, checked in your browser: signed by AMD, its measurement one of those computed, bound by a fresh random value to the VM’s TLS key.

    Measurement in the report
    example-measurement-0000000000000000
    Policy
    0x30000
    Firmware levels
    bootloader 0 · tee 0 · snp 0 · microcode 0
    Time
    2026-01-01T12:00:00.000Z
  6. Relayoutside the hardware check, protected another way

    The server through which your browser reached the VM for the check.

    One of Le Space’s relays, not attested: an ordinary server on Aleph. The app accepts it only if Aleph holds it as a running instance of a Le Space account. It forwards encrypted bytes only; it cannot read them or change them unnoticed, the checking happens in your browser. It can drop connections, and it sees connection data: your IP address, which VM on which node, when and how much.

    Relay
    relay.example
  7. Imageoutside the hardware check, protected another way

    The encrypted disk the VM boots from, named by its STORE hash.

    The image’s content is not measured. That the VM boots the published image rests on its disk opening only with the image passphrase.

    STORE hash
    example-image-0000000000000000
  8. Data areareported, not confirmed by the hardware

    Where the VM writes.

    The VM reports: a data area of its own, encrypted with a key of this start that only it has.

  9. Backupsreported, not confirmed by the hardware

    The last backup that reached storage providers.

    Encrypted with age inside the VM, to your key; the providers hold ciphertext only.

    Time
    2026-01-01T14:00:00.000Z
    Copies
    2
    Piece (piece CID)
    example-piece-0000000000000000

Check it yourself

9 places with links
  • The VM’s runtime

    Firmware, kernel and initrd: the Aleph message whose hash is fixed in the app. If Aleph delivers anything else, the app starts nothing.

  • Your VM and its measurements

    The INSTANCE message of your app address names the measurements the app put in. For a running VM the app shows instance, node, measurements and the result of the check under “Evidence of this VM”, with links to exactly your messages.

  • AMD SEV-SNP

    How the report is built and which certificates it is checked against.

  • The image

    The app shows the STORE hash in the setup. The workflow rootfs.yml builds it from rootfs/build-image.sh; every run’s summary names the hash and the source commit.

  • The data area

    The app shows whether a running VM sealed its data area. If that fails, Paperless-ngx does not start.

  • The backups

    Data sets and pieces are public on Filecoin, their content encrypted. At a restore the VM checks every piece against its content address (piece CID).

  • The relay

    It forwards between your browser and the VM without being able to read anything, and is not attested itself. Its source is open: the relay, and the bridge through which it is reached over libp2p. The app uses only relays that Aleph lists as a running instance of one of Le Space’s two relay accounts, or one you enter yourself.

  • This web app

    It is served from IPFS. Which version the domain serves, its DNSLink record shows (dig TXT _dnslink.paperless.le-space.de); every release names its CID.

  • In detail

    The description this page is written from.

The source code is public on GitHub: github.com/Le-Space/paperless-anywhere.

An image just for you

Every Paperless can have an image of its own – encrypted for your vault alone. The app builds it for you, at the first start or with one click. The passphrase is derived from your vault, and nobody else knows it: not Le Space, not the node, not GitHub.

In the app

  • A key just for you

    Your Paperless runs on your own encrypted image. Its passphrase comes from your vault and goes only to the attested builder and your VM; Le Space does not know it. With a package or a voucher, the build is included.

  • Checked, not trusted

    Before the passphrase leaves your device, the AMD processor (SEV-SNP) confirms that exactly the published builder is running. The check runs in your browser – you do not have to take Le Space’s word for it.

  • Ready in about 15 minutes

    With a package or a voucher the build is included until it succeeds (up to 3 tries), and again for every new image version. Storing the image is included too.

  • Tried and tested

    A whole round ran on Aleph from a browser: building the image, starting a VM, backing up, restoring on a second VM. And in real use: a backup made with the public image came back in full in an own image.

Start Paperless anywhere In the app under Advanced → Setup: “My own image”. With a package or a voucher the first start builds it by itself.

How does it work?
  1. 01

    Public image

    The system Paperless-ngx runs in is the same for everyone and holds no secret. It lies unencrypted on Aleph, with its hash; anyone can recompute it.

  2. 02

    Attested builder

    A small service in a confidential VM, measured as a whole, together with the image it seals. The app starts it only for your build, has the hardware confirm that exactly the published code runs there with exactly that image, and deletes it afterwards.

  3. 03

    Your image

    Only then the app sends the passphrase from your vault. The service seals the image with it and forgets it again. The app fetches the sealed image over the same attested channel and stores it on Aleph itself.

  4. 04

    Your VM

    At the start the VM opens the disk with your passphrase. A disk that was not sealed with it does not open, and nothing starts.

Who knows your image’s passphrase

  • Your vault: yes
    derives it
  • The builder: briefly
    during the build, in memory only
  • Your VM: briefly
    at the start, in memory only
  • Le Space: no
  • The node’s operator: no
  • GitHub: no

What can be compared in public: the public image’s hash and the builder’s measurement; the app shows both beside “Build my image”. Your encrypted image looks different for every person.

  • An attested builder: a measured V-PROGRAM in a confidential VM (AMD SEV-SNP). The app starts it only for your build and deletes it afterwards.
  • The check runs in your browser (WebAssembly): the AMD processor’s report is checked against AMD’s certificates and the measurement fixed in the app. In between, a relay only forwards encrypted data; it can read nothing.
  • Only then does the passphrase go to the builder. It seals the public image with it (LUKS2) and forgets it again.
  • The app fetches the sealed image back in pieces of 3 MiB, every connection confirmed by the hardware again, and stores it on Aleph itself (a STORE signed by your app).
  • At the start your VM opens the disk only with your passphrase. Any other disk does not open.

Good to know

  • Le Space provides the builder, currently on a single node. If it is down, no build is possible for the moment; your VM still starts.
  • Le Space runs the relays; you can enter one of your own. They only forward encrypted data.
  • Without a package the app’s address pays for building and storing from its Aleph credits; Aleph starts the builder only once they cover a day of its running time.
  • A build through the package has not been tried in real operation yet.

In detail: Your own image · Workflow

Prices

Choose a monthly package: always on, around the clock, or the hours you need in a month.

  • 15 hours €6.40 per month Backup included
  • 100 hours €16.40 per month Backup included
  • Always on, around the clock €90.50 per month Backup included

All prices include 19% VAT.

Included in every package: up to 8 GB of documents and building your own image.

The encrypted backup in three copies is included in every package. You need it for your documents to come back after a stop: stopping erases the VM, and the next start restores everything from the backup.

Without a package you can have your backups kept for a year, for €18 once. Keeping is not opening: restoring needs compute time, that is a package or extra hours.

Example: two hours a week are about 8.7 hours a month and fit in the smallest package.

Frequently asked questions

Is Paperless anywhere part of the Paperless-ngx project?

Paperless-ngx is an independent open source project (GPL-3.0). Paperless anywhere is offered by Le Space, is not affiliated with the project and is neither endorsed nor sponsored by it.

What is Paperless-ngx?

Paperless-ngx is the open source software that runs in your VM: it takes in documents, recognises their text and makes them searchable. With Paperless anywhere it runs in a confidential VM of your own, around the clock or on demand, and is backed up.

Does everyone get the same software?

Yes, the system is the same for everyone – but encrypted for each instance on its own. Your Paperless always runs on your own image: an attested builder seals the system with a passphrase from your vault that Le Space does not know. With a package or a voucher, the build is included; a Paperless that still runs on the public image gets its own at its next start. For simply trying it out there is the public image: it starts empty, without backups and without a fixed address. The documentation says how image and builder can be checked.

Do I need an account?

Not for the vault. A passkey on your device opens it; the 24 words are the way back in if the device is missing. Le Space can neither open nor recover the vault. When you buy a package, the payment service Stripe asks for an e-mail address, for the receipt and the subscription.

Can I pay the providers myself?

Yes. Instead of a package you then pay the providers directly from your own wallet. The VM on Aleph and the backups on Filecoin belong to your wallet’s address in that case.

  • What you need: a wallet (MetaMask, for example), Aleph credits for the VM, and USDFC and a little FIL for the backups.
  • What you approve: your wallet lets the app start and delete VMs for you, and lets a session key store backups for a limited time. Your wallet’s seed stays with you.
  • What still comes from Le Space: the app, the image (with the public one also its passphrase), and the relay through which the app checks the VM’s attestation.

You set this up in the app, under “Setup”.

What if the relay is down or blocked?

At every start the app looks up Le Space’s running relays and tries them in turn; if one fails, it takes the next. If none can be reached right now, one of your own helps. This changes nothing about security: the checking happens in your browser, and a relay sees encrypted data only, whether it is Le Space’s, yours or someone else’s. All that matters is that the connection comes about.

  • Anyone can start a relay of their own with the open project relay-button: an orbitdb-relay that offers the attestation path at /attest.
  • It runs as a VM on Aleph Cloud and needs Aleph credits of its own for that.
  • In the app you enter it in the setup under “Your own relays”. The app then tries it before Le Space’s.
What happens when a storage provider fails?

Your backup is kept in several copies at different providers, at independent operators where possible. If one fails, the others deliver.

  • At the top of the app, two lights show whether the copies of your newest backup answer and whether they are at different operators. The app asks the providers itself, every five minutes while the page is open.
  • A start that is to bring a backup back asks for no VM while no copy answers. So you pay for no VM that would stay empty; the backup is not lost by this.
  • If a provider fails during the upload, the VM goes on with the others: they get their copy, the backup counts as incomplete, and the next check two hours later tries all providers again.

How the providers prove they still hold your backup

Does the app notice beforehand that a provider cannot be reached?

In part. The app asks the providers of your newest backup itself, regularly, and shows the result as a light at the top. Before a start with a restore and before “Back up and stop” it asks once more; if none answers, it stops and tells you. The automatic backups every two hours go to the configured providers; the app does not yet suggest a replacement for a failed provider on its own.

The lights show only whether a provider answers. Whether it still holds your data, it proves on the chain; the app shows that under “What the chain says”.

Do I pay for failed providers, or for more and more copies?

With a package you don’t: the backup is included in the package, at a fixed price. What the providers get for it is set by the Filecoin Warm Storage contract on the chain, and it is the same when you pay them from your own wallet:

  • Only proving periods in which the provider proved it still holds the data are paid. A failed provider earns nothing for that time.
  • Each copy costs by its size for as long as it exists: 2.5 USDFC per TiB and month, plus 0.12 USDFC a month per data set (one per provider). As read from the chain on 2026-11-16.
  • The VM does not remove old backups on its own yet; each stays stored until it is deleted.

Proofs, deadlines and payment in detail

How safe is my own device in this?

Your documents are encrypted in the VM and in the backups, and the keys to them come into being only with you, when you open the vault. The limit is the browser on your device, as with every web app and every password manager in a browser: what lies open there can be read by a browser extension with access to the page, or by malware. It cannot get at the passkey itself, and without your approval by fingerprint or PIN the passkey opens nothing. A little care puts you on the safe side:

  • Use a browser profile of its own, without extensions, for Paperless anywhere, and install the app there.
  • Or take a private window, a phone or a tablet.
  • Enter the 24 words only in the app at paperless.le-space.de and keep them on paper. The passkey works for this address only; a fake page can still ask for the words.
  • Lock the vault when you are done, with the “Lock” button.

The details are in the security model.

What does it cost while Paperless anywhere is not running?

Only a running instance uses hours. Your monthly package runs on, though, and is billed every month until you cancel. The backup is included in the package and runs on with it. After the end of the paid period no new backups are made; the existing ones stay retrievable for at least 30 more days.

I have a voucher. How do I redeem it?

In the app, without a payment: create your vault and enter the code (PA-…) under “Redeem a voucher”. A voucher gives you a fixed period, usually a few days. What it covers, that is how many days, how many hours and whether the backup is included, is stated on the voucher; the app shows it after you redeem it.

  • The period starts when you redeem it and runs on in calendar days, even while Paperless is not running. It does not renew and does not turn into a subscription; to carry on, take a package.
  • Each code can be redeemed only once per vault, and only until its expiry date. While a package runs, no voucher can be redeemed.
  • Building an own image in the voucher’s period is included until it succeeds (up to 3 tries), and again for every new image version; the app then shows “included” instead of a price.
  • Back up or export your documents before it ends: 3 days later the app starts no more VMs, and to restore you then need a package.
  • If the voucher includes the backup, the backups stay available for at least 30 days afterwards.
Can I get at my documents without Le Space?

Yes, at any time and free of charge. In Paperless-ngx you export your documents with their metadata. And your backups lie with independent storage providers: the app fetches one straight from there, even without a running VM, and decrypts it in your browser, or it gives you a guide to do that on your own computer, with curl and age. The result is a zip with your documents that can be loaded into an empty Paperless-ngx.

  • In the app it is under “Advanced”, where you choose the backup: “Fetch a backup yourself”.
  • Only your vault has the key for it; the 24 words are enough to get it back.
  • After a package ends, the backups stay available for at least 30 days.
Help & support

Questions, a problem, something stuck? Write to us: paperless@le-space.de

About payment, invoices, vouchers and credits: support@le-space.de

Legal matters (withdrawal, cancellation, provider), as in the imprint: contact@le-space.de

Le Space never asks for your secrets

Not for your vault’s 24 words or your wallet’s seed phrase, not for a passphrase, your passkey, a recovery code or a DNS token. Whoever asks for them is not Le Space. Send none of them, not to us either.

What to send

Say briefly what you did and what happened. Add the diagnosis: in the app under “Help & support”, the button “Copy diagnosis”. It names the version, the state of the VM and the last error message, without secrets and without the names of your documents.

Read up yourself

Reporting a security issue

Please report it privately, not as an issue, comment or post: to security@le-space.de or through GitHub’s private reporting. How we handle it is in SECURITY.md.

Ready?

Creating a vault takes a minute. No account, no password.

Open the app →