Import a Redis

Move a Redis from another host (Heroku Key-Value Store, Upstash, Render Key Value, Railway, Redis Cloud, ElastiCache or your own server) into a new Deplane Redis: paste its URL, check it, and start; or give Deplane an RDB file, uploaded or from a link. Your keys arrive with their expiry times.

Press Import on the Redis page of the dashboard, or run deplane redis import. The command and its flags are in the CLI reference, and every error has a fix in Troubleshooting and error codes.

An import is for people: CI tokens and AI tools cannot start one, and the assistant never takes a Redis URL or password. The import always creates a new Redis; it never overwrites one you have.

Three ways in

Use the URL when you can: it works with every managed host, including the ones that give you no file. Use a file for a Redis Deplane cannot reach, or one you would rather not open to the internet.

From the URL

1. Stop writes for an exact copy. The copy reads the keys one by one while the source keeps running, so a key written during the copy may or may not arrive. Scale your app to 0 or turn on maintenance mode before you start; a Redis that fits takes a minute or two. The CLI asks you to confirm this (--yes answers it), and the dashboard has a checkbox.
2. Paste the URL. It is asked for at a hidden prompt, or read from stdin; it is never an argument. Deplane checks the source (read-only) and shows what it found: the server and its version, the size of the data, the keys in each database, how the keys will be copied, warnings, and whether the import is possible, with the reasons if not.
3. Name the new Redis and start. Deplane creates the Redis as deplane redis create does (it counts against your plan), copies the keys into it and shows the keys copied as it goes.
4. Check the counts. When it is done, the import shows how many keys the source had, how many the new Redis has, and how many expired during the copy. If the new Redis has fewer than the source minus the expired ones, it warns you: something was probably still writing to the source.
5. Attach it to your app: deplane redis attach NAME --app APP, or Attach to an app on its page. The app gets REDIS_URL and rolls out a new release.

How keys are copied. Deplane reads each key with DUMP and writes it with RESTORE: an exact copy of every type, with its expiry time. A Redis newer than a Deplane Redis (Redis 7.4 or later, Redis 8, Valkey 9), or a host that does not allow DUMP, is copied type by type instead: strings, hashes, lists, sets, sorted sets and streams with their values and expiry times. Type by type does not keep stream consumer groups or the expiry times of single hash fields (Redis 7.4), and cannot make an empty stream; the check says when it will be used, and warns about what it loses.

What the check refuses: more than 150 MB of data (a Deplane Redis holds 200 MB), a Redis in cluster mode, and keys of module types (RedisJSON, RediSearch, Bloom filters, TimeSeries), which a Deplane Redis does not have. Other databases than the one the URL names are listed as not copied. A host that does not answer part of INFO gets "unknown" for that line and a warning, not a refusal; the copy still stops if the data does not fit.

From an RDB file

An RDB file is the snapshot Redis writes to disk (dump.rdb). Deplane checks its header, stores it as the new Redis's first backup, and loads it with the same restore every Redis backup uses. A file is already a snapshot, so you do not need to stop writes to anything: the new Redis holds the data as it was when the file was written.

• Upload: deplane redis import --rdb ./dump.rdb --name cache, or the file field on the import page. The CLI checks the file before it sends anything: that it is an RDB file, at most 256 MB, and not newer than version 11.
• Link: deplane redis import --rdb-url, then paste an https:// link that downloads the file itself (not a page about it). Deplane downloads it from your team's own sandbox, not from Deplane's servers, follows at most 3 redirects (each https), and stops at 256 MB.

A file loads every database in it, as it is; your app's REDIS_URL uses database 0. A file made by a newer Redis (RDB version 12 or later: Redis 7.4 and 8, Valkey 9) is refused at once: copy that Redis from its URL instead. Module types cannot be found before the load: a file that holds them fails to load, with a clear message. After the load, a Redis that holds more than 190 MB fails with "the data needs more room than a Deplane Redis has".

What touches the source

The import only reads. To the source it sends HELLO or AUTH, PING, SELECT, INFO, SCAN, TYPE, PTTL, DUMP and DBSIZE, and when copying type by type GET, HSCAN, LRANGE, SSCAN, ZRANGE and XRANGE. It never writes, and never sends KEYS, MONITOR, CONFIG, SAVE, BGSAVE, DEBUG, CLIENT or REPLICAOF: the importer refuses to send any command that is not on that list. It uses one connection. DUMP of a very large key pauses the source for a moment (Redis runs one command at a time); the limits below keep that short.

Your password and your link

• The URL is sent once, over HTTPS, in the body of a request: never in an address, a log line, an audit entry or a command's arguments. Deplane stores it encrypted for the length of the import and erases it when the import is done, cancelled, failed or expired. Audit entries keep only the host, port and database number.
• The file link is treated the same way: a presigned link lets anyone who has it download your data until it expires. Make it expire soon (an hour is plenty).
• TLS: with rediss://, the connection is encrypted, but the server's certificate is not checked, because Heroku Key-Value Store, the most common source, uses a self-signed certificate. A plain redis:// URL works too, with a warning that the password crosses the internet unencrypted; prefer rediss:// when the host offers it, and change the password afterwards if it matters.

Let Deplane connect

Deplane connects to the source from a short list of addresses. If the source only accepts listed addresses, allow them: deplane redis import status and the import page list them, and the API's GET /v1/redis-imports returns them as egress_ips. Hosts on private ranges, and names that resolve to them, cannot be reached: the source needs an address on the internet. One of your own Deplane Redis can be copied into another.

If something goes wrong

• Cancel works in every state before Done (deplane redis import cancel). The copy stops, and the new Redis is emptied, so a half copy never looks complete. The Redis stays: use it, or delete it with deplane redis destroy NAME.
• A failed import ends the same way, with the reason: for example that the data needs more room than a Deplane Redis has, that a key holds more than 64 MB, or that the source refused a read. See import_failed.
• A check that fails or expires leaves nothing behind. A checked import that you do not start within an hour expires, and its stored URL or link is erased.
• While an import runs, its new Redis cannot be attached, destroyed, backed up or restored (redis_importing), and nightly backups skip it.

Provider notes

Heroku Key-Value Store (Heroku Redis). Get the URL with heroku redis:credentials -a APP (or heroku config:get REDIS_URL -a APP). Use the rediss:// URL: Heroku's certificate is self-signed, which Deplane accepts because it does not check certificates. Heroku gives no RDB file, so the URL is the only way. Turn on maintenance mode (heroku maintenance:on -a APP) for the copy.

Upstash. Use the rediss:// URL from the database's page (Upstash always uses TLS). If the database does not allow DUMP, the check says so and the copy goes type by type. Some INFO lines may show as unknown; that is a warning, not a refusal.

Render Key Value. Use the External URL from the Key Value's Connect menu, not the internal one. Render only accepts outside connections from the addresses you list under its access control: add Deplane's addresses there.

Railway. Use the REDIS_PUBLIC_URL variable. It only exists when the Redis has a public TCP proxy (in the service's networking settings); turn one on for the import and off again after. If the URL is redis://, the password crosses the internet unencrypted: change it after the move if that matters.

Amazon ElastiCache. An ElastiCache cache has no public address, so Deplane can copy it from its URL only if you have made it reachable from the internet yourself, with its security group allowing Deplane's addresses. The simpler way is a file: export a backup to an S3 bucket from the ElastiCache console, make a link that expires soon (aws s3 presign s3://BUCKET/FILE.rdb --expires-in 3600), and run deplane redis import --rdb-url.

Redis Cloud. Use the database's public endpoint with its password (rediss:// when TLS is on for the database), and add Deplane's addresses to its allow list if it has one. Or export the database to a bucket and give Deplane a link to the file.

Your own server. Redis must listen on an address Deplane can reach (bind in redis.conf, for example the server's public address) and have a password (requirepass, or an ACL user). Open the port in your firewall for Deplane's addresses only, and close it again after the import. If you set up TLS (tls-port), use rediss://. Or skip the network: run redis-cli BGSAVE (or SAVE on a quiet server), find the file in the folder redis-cli CONFIG GET dir names, and upload it with deplane redis import --rdb dump.rdb --name NAME.

Limits

See also Limits.

This page is also available as Markdown. AI agents can start at /llms.txt.