Cómo generar PDFs automáticamente desde Google Sheets paso a paso

¿Cómo generar PDFs automáticamente desde Google Sheets? Si trabajas a diario con hojas de cálculo en la nube, tarde o temprano te vas a encontrar con la necesidad de crear PDFs automáticos desde Google Sheets. Facturas, informes, albaranes, listados de clientes, presupuestos… todo eso que sueles maquetar en una hoja se puede transformar en un documento en PDF sin tener que ir exportando a mano uno por uno.

La buena noticia es que Google ofrece todas las piezas necesarias para montar este sistema: Google Sheets, Google Apps Script y Google Drive. Con un poco de código (muy reutilizable) puedes generar PDFs en lote, guardarlos en una carpeta concreta, nombrarlos usando datos de celdas e incluso enviarlos por correo automáticamente a cada cliente. Y lo mejor: una vez montado, sólo tendrás que pulsar un botón o programar un disparador y olvidarte.

Concepto general: cómo funciona la generación automática de PDFs

Antes de meternos en el código, viene bien entender la idea global. La lógica que se suele usar para automatizar PDFs desde Google Sheets sigue un patrón bastante claro: se trabaja con varias hojas de datos, una hoja plantilla que será la base del PDF y un script que conecta todas las piezas.

Normalmente se parte de un libro de Google Sheets con varias pestañas: una hoja de clientes, otra de productos, otra con las transacciones o movimientos, una hoja donde se guardarán los resultados (por ejemplo, facturas generadas) y otra hoja que actúa como plantilla visual del documento que quieres convertir a PDF (por ejemplo, “Invoice Template”). Esa hoja plantilla tiene la maquetación, logos, tablas y celdas donde se insertan los datos.

El script recorre los datos (por ejemplo, cada cliente o cada registro de un día concreto), rellena la plantilla con la información correspondiente, fuerza a que la hoja se refresque, y a continuación llama a un método que genera un PDF a partir de esa pestaña. Por último, ese PDF se mete en una carpeta específica de Google Drive y se guarda en una tabla resumen, junto con otros campos de control.

Este enfoque permite también asociar un envío automático por correo: una vez generado el PDF, el propio script puede adjuntarlo en un email, mandarlo al cliente indicado y registrar en la hoja si el correo se ha enviado o no, evitando duplicados. Todo esto se orquesta con Google Apps Script, que es el lenguaje tipo JavaScript que vive detrás de las hojas de cálculo.

Un caso muy habitual es el de alguien que recibe respuestas de un formulario de Google durante todo el día, y quiere que, a partir de esas respuestas, la hoja genere un PDF por cada entrada de la fecha actual, lo guarde en Drive y opcionalmente lo descargue o lo mande por email. Con una estructura de script bien pensada, el sistema puede ir generando PDFs en lote según la fecha o según cualquier criterio que marques.

Estructura de libro y hojas necesarias para automatizar PDFs

Para replicar soluciones robustas como las que propone Google en sus ejemplos oficiales, conviene montar bien la estructura del archivo. Lo más habitual es trabajar con distintas pestañas para separar datos, transacciones y plantilla, de forma que el script pueda acceder a todo con claridad.

En un escenario clásico de facturación, suele haber al menos estas hojas con nombres definidos (que después se referencian en el código): una hoja Customers donde se guarda el listado de clientes (nombre, dirección, correo, etc.), una hoja Products con el catálogo de productos o servicios (SKU, descripción, precio), una hoja Transactions con las ventas o movimientos de cada cliente, una hoja Invoices donde acabará el registro de cada factura generada y, por último, una hoja Invoice Template, que es la plantilla utilizada para convertir en PDF.

El script define estas hojas como constantes (por ejemplo, CUSTOMERS_SHEET_NAME = «Customers», PRODUCTS_SHEET_NAME = «Products», etc.) para que, si cambias el nombre más adelante, sólo tengas que actualizar ese valor. Es importante mantener esta estructura limpia porque todas las funciones se apoyan en ella para leer datos, rellenar la plantilla y escribir resultados.

La plantilla de factura o documento suele incluir zonas muy concretas donde se escriben valores. Por ejemplo, los datos del cliente se colocan en celdas como B10 y B11, los datos de la factura (número, fecha, fecha de vencimiento) en otras celdas como F10, F12, F14, y la tabla de líneas de producto en un rango de filas, por ejemplo desde la fila 18 hasta la 24 en columnas B a G. Ese rango se rellena dinámicamente según cuántos ítems tenga la factura de ese cliente.

Además de la organización en pestañas, hace falta una carpeta en Google Drive que actuará como “buzón” donde se guardarán los PDFs. Esa carpeta se suele identificar por su nombre con una constante del estilo OUTPUT_FOLDER_NAME = «Customer PDFs». El script buscará esa carpeta y, si existe, irá creando dentro todos los archivos PDF generados, con el nombre que tú decidas (por ejemplo, combinando el número de factura y el nombre del cliente).

Funciones clave del script para procesar datos y generar PDFs

El corazón de la automatización es una serie de funciones construidas en Google Apps Script, que se asocian a la hoja de cálculo. La más importante suele ser una función principal, como processDocuments(), que es la que el usuario lanza desde un menú personalizado o desde un disparador.

Esta función principal hace varias cosas: primero obtiene la referencia al libro activo con SpreadsheetApp.getActiveSpreadsheet(), después localiza las hojas por nombre (clientes, productos, transacciones, facturas, plantilla) y por último “traduce” los rangos de datos a objetos JavaScript manejables. Para esto se usa una función de utilidad que convierte cada fila en un objeto con claves generadas a partir de los encabezados de la primera fila.

Con esos objetos en memoria (por ejemplo, un array de clientes, un array de productos y otro de transacciones), el script recorre uno a uno los clientes y llama a otra función específica, habitualmente algo del estilo createInvoiceForCustomer(). Esta segunda función es la que se encarga de filtrar todas las transacciones pertenecientes al cliente actual, montar las líneas de detalle, rellenar la plantilla y crear el PDF.

Dentro de esa función de creación por cliente, el flujo es muy claro: primero filtras las transacciones con algo equivalente a transactions.filter() para quedarte sólo con las del cliente que encaja con el nombre o el identificador. Después llamas a una función que deja la plantilla limpia, borrando los datos de cualquier factura anterior en los rangos relevantes.

Posteriormente el script recorre las transacciones del cliente para calcular las líneas de factura. Para cada línea, busca el producto correspondiente en la lista de productos (normalmente usando la clave SKU), calcula la cantidad, el precio unitario, el importe y va acumulando el total. Al final se obtiene un array de arrays que representa la tabla de líneas (por ejemplo, nombre del producto, descripción, código, cantidad, precio, total) y se coloca todo en bloque en la plantilla con un setValues() sobre el rango que abarca la tabla.

En ese mismo paso se aprovecha para generar un número de factura aleatorio o secuencial, así como las fechas relevantes. A menudo se utiliza un número aleatorio de seis dígitos para crear un identificador único, y para la fecha de vencimiento se suma un número de días (por ejemplo, 15) a la fecha actual con un cálculo basado en milisegundos. Estos valores también se insertan en la plantilla en las celdas reservadas.

Una vez que la plantilla está rellena y lista para ser convertida en documento, el script hace un SpreadsheetApp.flush() para asegurarse de que todos los cambios se han aplicado, y a veces se añade un pequeño Utilities.sleep(500) para dar margen a la interfaz antes de exportar. A partir de ahí, se llama a una función especializada, por ejemplo createPDF(), que se encarga de realizar la exportación real a PDF usando un endpoint de Google.

Exportar la plantilla a PDF y guardarla en una carpeta de Drive

La generación del PDF en sí se basa en construir una URL especial contra el servicio de hojas de cálculo de Google, con parámetros de exportación en formato PDF. Esa URL utiliza el identificador del libro (ssId) y el identificador interno de la hoja (el sheetId de la plantilla) para ajustar exactamente qué pestaña y qué rango se convierten en documento PDF.

La URL suele tener un formato similar a https://docs.google.com/spreadsheets/d/ID_DEL_LIBRO/export?format=pdf&… y a continuación una larga lista de parámetros que controlan el tamaño de página, orientación, márgenes, si se incluyen los nombres de las hojas, si se imprime la cuadrícula, el ajuste al ancho, etc. Entre esos parámetros, se incluyen también los límites de filas y columnas del rango a exportar (por ejemplo, r1=0, c1=0, r2=27, c2=9 para delimitar la factura completa).

Para poder descargar ese PDF desde el script, se usa UrlFetchApp.fetch() junto con cabeceras de autorización que incluyen el token de OAuth de ScriptApp. De este modo, la llamada tiene permisos para acceder al documento y generar el archivo binario. El resultado de la petición se convierte en un blob con getBlob() y se le asigna un nombre del estilo «Invoice#123456-NombreCliente.pdf» mediante setName().

Con el blob creado, el siguiente paso es guardarlo en la carpeta adecuada de Google Drive. Para ello se suele usar una función auxiliar, normalmente algo como getFolderByName_(), que busca una carpeta por su nombre dentro de tu Drive y devuelve el objeto carpeta. Una vez se tiene esa carpeta, se ejecuta folder.createFile(blob), creando el archivo PDF definitivo que ya aparece en tu unidad, con el nombre indicado por el script.

La función de creación de PDF devuelve el archivo de Drive (o su URL) para que la función que la llamó pueda hacer algo con esa referencia, como registrarla en una hoja de resumen. Así, por ejemplo, cada fila de la hoja «Invoices» podría almacenar el número de factura, la fecha, el nombre del cliente, su email, el total, la fecha de vencimiento, el enlace al PDF en Drive y un campo para indicar si se le ha enviado el email o no.

Este método de exportación basado en URL es muy flexible: puedes cambiar los márgenes, decidir si la salida será en vertical u horizontal, ajustar el tamaño del papel o incluir o quitar la numeración de páginas. Simplemente se modifican los parámetros de la URL en la función de exportación para adaptarla al tipo de documento que necesitas.

Enviar automáticamente los PDFs por correo electrónico

Una vez que los PDFs se están generando y guardando correctamente en Drive, es habitual dar un paso más y automatizar el envío por correo. Esto se hace desde otra función del script, a menudo llamada algo como sendEmails(), que recorre la hoja de facturas y comprueba qué PDFs faltan por enviar.

El proceso suele ser así: la función obtiene la hoja «Invoices», lee todas las filas y convierte esas filas en objetos usando de nuevo una función de utilidad. Entre los campos de cada factura habrá uno que indica si se ha enviado el email (por ejemplo, «email_sent»), y el script filtrará o saltará aquellas filas donde ese campo ya esté marcado como «Yes» para evitar envíos duplicados.

Para cada factura pendiente de enviar, se extrae la URL del PDF almacenado en Drive y se obtiene su identificador de archivo usando una expresión regular que caza la parte larga del ID. Con ese ID, se llama a DriveApp.getFileById() para recuperar el archivo desde Google Drive y se prepara el adjunto en formato PDF utilizando getAs(MimeType.PDF) si es necesario.

El correo se envía con GmailApp.sendEmail(), pasando como parámetros la dirección del destinatario (normalmente el email del cliente que se guardó en la hoja de «Customers» y que después se copió a «Invoices»), el asunto (por ejemplo, «Invoice Notification»), el cuerpo del mensaje y un objeto de opciones donde se incluyen los adjuntos y el nombre con el que se quiere firmar el correo. Aquí puedes personalizar tanto el texto como el asunto para que encaje con tu negocio.

Para poder probar el sistema sin arriesgarte a mandar correos reales a los clientes, es muy útil incluir dos constantes globales: una bandera de EMAIL_OVERRIDE y una dirección de correo de pruebas. Si la bandera está en verdadero, el script forzará que todos los correos se envíen únicamente a esa dirección de test, con lo que puedes depurar tranquilamente la automatización sin molestar a nadie.

Tras cada envío correcto, la función actualiza la hoja «Invoices» escribiendo en la columna correspondiente el valor «Yes» en la fila de esa factura. De esta manera, la próxima vez que ejecutes la función de envío, el script reconocerá que esa factura ya se ha enviado y pasará a la siguiente, manteniendo un control muy ordenado de qué documentos han sido ya comunicados al cliente.

Funciones de apoyo para tratar datos de hojas como objetos

Para que el código no se convierta en un caos, las soluciones más completas suelen incluir funciones auxiliares para convertir rangos en objetos. En lugar de manejar arrays de arrays con índices de columna, se leen las filas de datos junto con la fila de cabecera y se construyen objetos con claves legibles, lo que hace que el código principal sea mucho más entendible.

La primera función clave suele ser algo tipo dataRangeToObject(sheet), que recibe una hoja, lee todas sus filas y columnas con getRange().getValues(), extrae la primera fila como cabeceras y llama a una función que crea las claves de objeto a partir de esos títulos. Cada fila posterior se recorre para formar un objeto con par clave-valor, omitiendo celdas vacías y descartando filas sin datos.

La creación de claves limpias se hace con una función del estilo createObjectKeys(keys), que toma el array de cabeceras y les aplica una expresión regular para reemplazar todos los caracteres no alfanuméricos por guiones bajos y forzar las letras a minúscula. De esta forma, encabezados como «Customer Name» o «Invoice Link» se convierten en claves como customer_name e invoice_link, muy manejables en el código.

Otra utilidad común es una función getObjects(data, keys), que recorre la matriz de datos (sin la fila de cabecera) y va creando un objeto por cada fila, asignando a cada posición la clave correspondiente y comprobando con una función como isCellEmpty() si la celda está en blanco. Si toda la fila está vacía, se descarta y no se añade al array de resultados, con lo que se evita ruido en forma de filas vacías.

Estas funciones compartidas hacen que tanto el procesamiento de clientes, productos o transacciones sea uniforme: en todos los casos, el código puede acceder a propiedades como customer.customer_name, product.price o transaction.licenses de forma clara, sin tener que recordar en qué columna exacta estaba cada dato. Esto reduce errores y facilita adaptar el script a otras plantillas u otros tipos de documentos.

Además, se suelen incluir pequeñas rutinas de limpieza, como la función clearTemplateSheet(), que borra en bloque los rangos que corresponden a datos variables en la plantilla: celdas de nombre del cliente, dirección, número de factura, fechas, totales y las filas de la tabla de líneas. Así te aseguras de que cada vez que generas un nuevo PDF, la plantilla parte de una base vacía y no arrastra datos residuales.

Un detalle a tener en cuenta es que muchas de estas soluciones están basadas en ejemplos oficiales liberados bajo licencias abiertas, lo que te permite copiar el esqueleto del código y adaptarlo con tus propios nombres de hojas, rangos, textos de correo y estilos de documento sin problemas legales, siempre que respetes las condiciones de uso y no elimines créditos cuando sea obligatorio mantenerlos.

Casos prácticos: generar PDFs por fecha y trabajar con formularios

Más allá del ejemplo típico de facturas por cliente, hay otro escenario muy frecuente: personas que reciben respuestas de Google Forms en una hoja de cálculo y quieren que, para cada respuesta o para las respuestas de una fecha concreta, se genere un PDF con un diseño personalizado.

Imagina que tienes un formulario de partes de trabajo, de pedidos o de informes diarios. Cada vez que alguien rellena el formulario, la respuesta cae en una hoja de Google Sheets. A partir de ahí, quieres que la hoja coja todas las filas correspondientes al día de hoy, rellene una plantilla con los datos de cada respuesta y cree un PDF por registro, guardándolo en una carpeta concreta de Drive.

Este patrón es muy parecido al de las facturas, sólo que en lugar de iterar por clientes, se itera por filas cuyo campo de fecha coincide con la fecha actual. El script puede filtrar las respuestas comparando la columna de fecha con «hoy» y trabajar únicamente con esas filas. Para cada una, rellena la plantilla, llama a la rutina de exportación a PDF y guarda el archivo, idealmente nombrándolo con un valor relevante de la fila, como el nombre de la persona, un identificador o la fecha y hora.

Una petición común en foros de usuarios avanzados de Google es precisamente esta: «quiero que mi hoja recorra todas las iteraciones de la fecha de hoy y las cree y exporte como archivos PDF». La respuesta suele ir en la línea de adaptar la función principal de procesamiento para que en lugar de iterar por clientes, lo haga por filas filtradas por fecha, y cambie también la forma de nombrar el PDF (por ejemplo, usando una celda clave en lugar del número de factura).

Además, se puede combinar con disparadores de Apps Script para que el proceso se ejecute automáticamente al enviar el formulario o a una hora programada cada día. Un disparador de tipo onFormSubmit permitiría que, en el momento en que entra una nueva respuesta, el script rellene la plantilla con esos datos y genere el PDF al instante, sin intervención manual. Un disparador basado en tiempo podría, por su parte, recorrer al final del día todas las entradas de esa jornada y crear en lote todos los PDFs de golpe.

Lo interesante de todo este enfoque es que no estás limitado a un solo tipo de documento: puedes usar la misma técnica para crear certificados, hojas de evaluación, justificantes, cartas personalizadas o cualquier otro documento que se pueda maquetar en una hoja de cálculo. Cambias el diseño de la plantilla, ajustas qué campos rellenas y mantienes la lógica general de generación de PDF y almacenamiento en Drive.

Vista la arquitectura y las posibilidades, queda claro que dominar este tipo de automatización en Google Sheets te ahorra una cantidad de trabajo manual enorme, especialmente cuando gestionas volúmenes altos de formularios, clientes o documentos. Con unas pocas funciones bien estructuradas puedes dejar que el sistema haga por ti todo el trabajo repetitivo de exportar, nombrar, archivar y, si procede, enviar PDFs.

Con todo esto en marcha, acabas teniendo un flujo bastante profesional: datos en hojas, transformación a objetos, rellenado de plantilla, exportación a PDF, registro en hoja de control y envío de correos si procede. Una vez configurado y probado con tus propias plantillas y criterios (por cliente, por fecha, por tipo de formulario, etc.), trabajar con documentos en PDF generados automáticamente desde Google Sheets deja de ser un quebradero de cabeza y se convierte en una herramienta del día a día que agiliza muchísimo la gestión.