Firexport / Guías

Cómo renombrar un documento de Firestore (cambiar su ID)

Firestore no puede renombrar un documento. El ID de un documento forma parte de su ruta, y ni Firebase console ni los SDK tienen forma de cambiarlo. Renombrarlo significa crear el documento de nuevo con el nuevo ID y borrar el anterior, junto con todo lo que hay en sus subcolecciones, que borrar un documento no toca. Hay tres formas de hacerlo, según cuánto haya debajo del documento.

Actualizado el 27 de octubre de 2026. Firexport, la extensión del método 1, es nuestra. Los métodos 2 y 3 no la necesitan.

1. Cambiar el ID desde Firebase console con Firexport

Firexport es una extensión gratuita de Chrome que agrega Cambiar ID del documento al menú ⋮ de cada documento en la vista de panel (Panel view) de Firestore. Mueve el documento y todo lo que hay en sus subcolecciones al nuevo ID en una sola escritura: se hace todo o nada. Escribe con una cuenta de Google que tú conectas, así que no hay que configurar ninguna clave de cuenta de servicio ni código.

1. Instala Firexport desde Chrome Web Store.
2. En Firebase console, abre Firestore Database > Datos (Data) en vista de panel (Panel view) y haz clic en la colección que contiene el documento.
3. Pasa el cursor sobre el documento en la lista, haz clic en el ⋮ que aparece a la izquierda de su ID y luego en Cambiar ID del documento.
4. La primera vez, la ventana te pide Conectar cuenta de Google: elige la cuenta con la que accediste a la consola y permite el acceso en la ventana de Google.
5. Escribe el nuevo ID en Nuevo ID del documento y haz clic en Cambiar ID. Un documento sin subcolecciones se mueve de inmediato.
6. Si tiene subcolecciones, Firexport las lee primero y muestra cuántos documentos se moverán, cuántas escrituras hacen falta y cuántas lecturas se usaron para revisarlo. Haz clic en Mover. Luego la consola abre el documento con su nuevo ID.

Qué impide el movimiento

• Un documento que ya está en el nuevo ID, o debajo de él. Firexport nunca sobrescribe: la escritura se rechaza y no cambia nada.
• Un cambio en cualquiera de los documentos después de que Firexport los leyera. Si no, el contenido anterior acabaría en el nuevo ID mientras se borraba el contenido nuevo, así que no se escribe nada y puedes volver a intentarlo.
• Más de 250 documentos, o más de lo que cabe en una escritura (10 MiB). Firexport se detiene antes de escribir nada; usa el método 2.
• Un ID que Firestore no permite: uno que contiene /, que es solo . o .., que empieza y termina con __, o que supera los 1.500 bytes. Los espacios al principio o al final forman parte del ID, así que el cuadro los conserva.

Cada campo conserva su valor y su tipo exactos, porque Firexport escribe lo que leyó de Firestore y no lo que muestra la consola. Las escrituras usan los permisos de la cuenta conectada, así que las reglas de seguridad no se aplican. Los documentos van de tu navegador directamente a Google, y nunca a nosotros. Cambiar ID del documento es gratis en todos los planes.

Cambia el ID de un documento de Firestore desde la consola, con sus subcolecciones, en una sola escritura.

Añadir a Chrome — gratis

2. Moverlo con un script del Admin SDK

Para un documento con más de 250 documentos debajo, o para renombrar muchos documentos, un script de Node.js con el Firebase Admin SDK hace el mismo movimiento. El de abajo lee el documento y todas las subcolecciones que tiene debajo, luego crea cada documento en la nueva ruta y borra los antiguos. La nueva ruta también puede estar en otra colección, así que el mismo script sirve para mover un documento. Necesita una cuenta que pueda escribir en Firestore: un Propietario o Editor del proyecto, o el rol Usuario de Cloud Datastore.

1. Instala el SDK: npm install firebase-admin
2. Inicia sesión para obtener credenciales locales: gcloud auth application-default login. En un servidor, apunta GOOGLE_APPLICATION_CREDENTIALS a una clave de cuenta de servicio en su lugar.
3. Guarda el script de abajo como rename-document.mjs, reemplaza your-project-id y ejecuta node rename-document.mjs users/alice users/alice-smith.

// Usage: node rename-document.mjs users/alice users/alice-smith   → moves users/alice and everything under it
// Firestore has no rename: this creates the document at the new path with all its subcollections, then deletes the old ones.
import { initializeApp } from 'firebase-admin/app';
import { getFirestore } from 'firebase-admin/firestore';

initializeApp({ projectId: 'your-project-id' });
const db = getFirestore();
db.settings({ useBigInt: true }); // integers past 2^53 would otherwise lose their last digits on the way through
const [from, to] = process.argv.slice(2);
if (!from || !to) throw new Error('Usage: node rename-document.mjs <document path> <new document path>');
if (to === from || to.startsWith(`${from}/`)) throw new Error('The new path must be outside the document you move');

// true: one batch, so every write happens or none does (up to 10 MiB of data in all).
// false: for more than that. Copies everything first and deletes the old documents only once every copy is written.
const ONE_BATCH = true;

// The document and every document under it, in subcollections of subcollections too. listDocuments() also returns
// places that have subcollections but no fields, so the walk reaches what is under them; the places themselves aren't copied.
async function collect(ref, found) {
  const snapshot = await ref.get();
  if (snapshot.exists) found.push(snapshot);
  for (const collection of await ref.listCollections()) {
    for (const child of await collection.listDocuments()) await collect(child, found);
  }
  return found;
}

const docs = await collect(db.doc(from), []);
if (docs[0]?.ref.path !== from) throw new Error(`${from} doesn't exist`);
const target = (doc) => db.doc(to + doc.ref.path.slice(from.length));

if (ONE_BATCH) {
  // create() fails if a document is already at the new path, and lastUpdateTime fails if one changed after it was read.
  // Either way Firestore rejects the whole batch and nothing is written.
  const batch = db.batch();
  for (const doc of docs) batch.create(target(doc), doc.data());
  for (const doc of docs) batch.delete(doc.ref, { lastUpdateTime: doc.updateTime });
  await batch.commit();
} else {
  // BulkWriter keeps under Firestore's rate limits and retries what can be retried, but it isn't all or nothing.
  const writer = db.bulkWriter();
  const failures = [];
  for (const doc of docs) {
    writer.create(target(doc), doc.data()).catch((error) => failures.push(`${doc.ref.path}: ${error.message}`));
  }
  await writer.flush();
  if (failures.length) {
    failures.forEach((failure) => console.log(failure));
    throw new Error('Some copies failed, so nothing was deleted. Delete the copies that were written, then try again.');
  }
  for (const doc of docs) {
    writer.delete(doc.ref, { lastUpdateTime: doc.updateTime }).catch((error) => failures.push(`${doc.ref.path}: ${error.message}`));
  }
  await writer.close();
  failures.forEach((failure) => console.log(`Not deleted, ${failure}`));
}
console.log(`Moved ${docs.length} documents from ${from} to ${to}`);

• listDocuments() también devuelve un lugar que tiene subcolecciones pero ningún campo propio (los ID en cursiva de la consola), así que el script llega a los documentos que hay debajo. Ese lugar en sí no se copia: aparece en la nueva ruta en cuanto aparecen sus subcolecciones.
• Con ONE_BATCH activado, cada creación y cada borrado van en un solo lote. Si ya existe un documento en la nueva ruta, o alguno cambió después de que el script lo leyera, Firestore rechaza el lote y no se escribe nada.
• Un lote puede llevar hasta 10 MiB. Para un árbol más grande, pon ONE_BATCH en false: el script copia todo con BulkWriter y borra los documentos antiguos solo si se escribieron todas las copias. Eso no es todo o nada, así que no escribas en esos documentos mientras se ejecuta.
• Igual que el método 1, no pasa por las reglas de seguridad. Las marcas de tiempo, las referencias, los puntos geográficos y los bytes conservan sus tipos, y useBigInt mantiene exactos los enteros que superan 2⁵³. Hay una cosa que el Admin SDK no puede conservar: un double sin parte decimal, como 2.0, se lee como un número normal y se vuelve a escribir como el entero 2.

3. Copiarlo a mano en la consola

Para un documento con pocos campos y sin subcolecciones, basta con la consola. Hacen falta dos escrituras que no van ligadas entre sí, y tienes que volver a ingresar cada valor.

1. Abre el documento y anota el nombre, el tipo y el valor de cada campo.
2. En la misma colección, haz clic en Agregar documento (Add document), ingresa el nuevo ID en ID del documento (Document ID) y agrega los mismos campos con los mismos tipos. Haz clic en Guardar (Save).
3. Revisa el documento nuevo, luego abre el menú ⋮ del antiguo y haz clic en Borrar documento (Delete document).

Cuida los tipos sobre la marcha: un número escrito en un campo de tipo cadena sigue siendo una cadena, y una marca de tiempo hay que volver a ingresarla con el tipo marca de tiempo. Las subcolecciones no lo acompañan. Habría que copiar cada una de la misma forma, un documento a la vez.

Qué cambia con un nuevo ID

Lo muevas como lo muevas, el documento con el nuevo ID es un documento nuevo. Eso tiene algunas consecuencias.

• Fecha de creación. Cada documento movido recibe una nueva fecha de creación y de actualización.
• Referencias. Los campos de referencia de otros documentos siguen apuntando a la ruta antigua, igual que los ID guardados como cadenas, como un ownerId. Actualízalos tú.
• Cloud Functions y listeners. Cada documento movido dispara los activadores de creación y de eliminación, y las apps que escuchan la colección ven que se quita un documento y se agrega otro.
• Costo. Cada documento movido es una escritura y una eliminación en la factura, más las lecturas para encontrarlo y leerlo.

Preguntas frecuentes

¿Se puede renombrar un documento en Firestore?

No directamente. Firestore no tiene una operación para renombrar, y el ID de un documento no puede cambiar una vez creado. Para renombrarlo, crea un documento con el nuevo ID y los mismos datos, y luego borra el anterior. Cambiar ID del documento, de Firexport, y el script del Admin SDK de arriba hacen las dos cosas en una sola escritura.

¿Renombrar un documento mueve sus subcolecciones?

Solo si también las mueves. Las subcolecciones pertenecen a la ruta del documento, no a sus datos, así que copiar los campos las deja atrás, y borrar el documento anterior tampoco las borra. Firexport y el script de arriba mueven todas las subcolecciones, a cualquier profundidad, junto con el documento.

¿Puedo renombrar una colección en Firestore?

No. Una colección solo existe a través de los documentos que contiene, así que renombrarla significa mover cada documento al nuevo nombre de colección. Ni la consola ni Firexport lo hacen en un solo paso; un script que haga el movimiento de arriba con cada documento, sí.

¿Qué pasa con las referencias al documento anterior?

Siguen apuntando a la ruta antigua, que deja de existir después del movimiento. Firestore no actualiza los campos de referencia ni los ID guardados en otros documentos, así que búscalos y actualízalos después de renombrar.

¿Cuánto cuesta renombrar un documento de Firestore?

Cada documento movido es una escritura y una eliminación, más las lecturas para encontrarlo a él y a sus subcolecciones. Firexport muestra la cifra antes de que hagas clic en Mover. En el plan gratuito Spark eso sale de las 20.000 escrituras y 20.000 eliminaciones diarias.