Módulo 1: Google Sheets

Leer y Buscar Filas

Descripción de la cápsula

Leer es la operación más segura de Google Sheets: no modifica nada, no duplica nada, no borra nada. Por eso empezamos aquí. Pero "leer" no es solo "traer todas las filas" — eso casi nunca es lo que quieres. Lo que quieres es leer con criterio: "las filas donde el estado es 'pendiente'", "la fila cuyo email es exactamente este", "las 10 filas más recientes".

Esa lectura selectiva se llama lookup (búsqueda), y es una de las habilidades más importantes de todo el módulo. ¿Por qué? Porque antes de escribir o actualizar, casi siempre necesitas buscar primero: ¿este lead ya existe en la hoja? ¿qué fila tengo que actualizar? El lookup es el paso que evita duplicados y pisar datos.

En esta cápsula dominas las dos operaciones de lectura del nodo (Get Row(s) con y sin filtro) y aprendes el patrón mental "buscar antes de actuar".

Lo que vas a aprender

Al terminar esta cápsula serás capaz de:

✅ Leer todas las filas de una hoja y entender el formato del output
✅ Filtrar filas por el valor de una columna (lookup)
✅ Combinar varios filtros para búsquedas más precisas
✅ Manejar el caso "no se encontró nada" sin que el workflow se rompa
✅ Aplicar el patrón "buscar antes de actuar" que usarás en las cápsulas 04 y 05
✅ Limitar y ordenar resultados cuando la hoja es grande

Las dos formas de leer

El nodo Google Sheets, con Operation: Get Row(s), lee de dos maneras según configures los filtros:

Modo	Qué hace	Cuándo usarlo
Sin filtro	Devuelve todas las filas de datos	Procesar la hoja completa, generar un reporte
Con filtro (lookup)	Devuelve solo las filas que cumplen un criterio	Buscar un registro específico, filtrar por estado

La diferencia es un campo en el nodo: Filters. Si lo dejas vacío, lees todo. Si agregas un filtro, haces lookup.

Leer todas las filas

La configuración base:

Operation: Get Row(s)
Document: tu hoja
Sheet: la pestaña
Filters: (vacío)

Resultado: un item por cada fila de datos. Si tu hoja tiene 50 filas, recibes 50 items.

Cuidado con hojas grandes. Leer "todas las filas" de una hoja con 10,000 registros mete 10,000 items a tu workflow. Eso es lento y puede chocar con límites. Si tu hoja es grande, siempre filtra o usa el límite de filas (más abajo).

Leer con filtro: el lookup

Aquí está el corazón de la cápsula. Para buscar filas específicas:

Configuración

Operation: Get Row(s)
Filters → Add Filter:
- Column: la columna donde buscar (ej. email)
- Value: el valor a buscar (ej. ana@example.com)

Resultado: solo los items cuya columna email sea exactamente ana@example.com.

Ejemplo concreto

Hoja Leads:

name	email	status
Ana	ana@example.com	pending
Beto	beto@example.com	contacted
Carla	carla@example.com	pending

Filtro Column: status, Value: pending → devuelve 2 items (Ana y Carla).

Filtro Column: email, Value: beto@example.com → devuelve 1 item (Beto).

Usar un valor dinámico

El Value del filtro no tiene que ser texto fijo. Puede venir de un nodo anterior con una expression:

{{ $json.email }}

Esto es lo que hace el lookup poderoso: buscas en la hoja el dato que llegó por el trigger. "Llegó un email por webhook → busca si ese email ya está en la hoja".

Combinar varios filtros

Puedes agregar más de un filtro. Por defecto n8n los combina con AND (todas las condiciones deben cumplirse):

Filtro 1: Column: status, Value: pending Filtro 2: Column: city, Value: CDMX

→ devuelve las filas que están pendientes Y son de CDMX.

El nodo de Google Sheets hace coincidencia exacta por valor. No hace "contiene", "mayor que" ni rangos. Si necesitas lógica más rica (fechas dentro de un rango, texto parcial), lee las filas y filtra después con un nodo Filter o IF — eso se cubre a fondo en G4 (Data Handling).

El patrón clave: "buscar antes de actuar"

Este es el patrón mental que vas a repetir todo el módulo:

Antes de escribir o actualizar una hoja, busca primero.

Lookup: ¿existe ya este registro? (Get Row(s) con filtro)

Decisión: IF — ¿el lookup devolvió algo o no?

Acción: si existe → actualizar (cápsula 05). Si no existe → agregar (cápsula 04).

Sin este patrón, los workflows duplican datos: cada vez que llega el mismo lead, se agrega otra fila. Con este patrón, el workflow es idempotente — puede correr 10 veces con el mismo dato y la hoja queda igual.

Visualmente:

Trigger → Google Sheets (Get Row(s), filtro por email)
            │
            ▼
          IF: ¿hay resultados?
            │
      ┌─────┴─────┐
      ▼           ▼
  SÍ existe   NO existe
  → Update    → Append

Lo construirás completo en el mini-proyecto (cápsula 08).

Manejar "no se encontró nada"

Cuando el lookup no encuentra coincidencias, el nodo no da error — simplemente devuelve 0 items. Eso es correcto, pero tu workflow tiene que estar preparado.

Cómo detectarlo

Después del nodo Google Sheets, un IF que revise si hay datos. Una forma robusta es contar los items:

{{ $input.all().length > 0 }}

true → el lookup encontró algo
false → no encontró nada

Por qué importa

Si tu workflow asume que "siempre hay un resultado" y conecta el output directo a un nodo que usa {{ $json.name }}, cuando el lookup devuelve 0 items ese nodo ni se ejecuta (no hay items que procesar) o falla. El IF te da las dos ramas explícitas: "encontré" y "no encontré".

Limitar y ordenar (hojas grandes)

Cuando la hoja es grande y solo quieres una parte:

Return Only First Match: si activas esta opción, el nodo devuelve solo la primera fila que cumple el filtro. Útil cuando buscas por una columna que debería ser única (como un email) y quieres exactamente un item.
Combinar con filtros: la mejor forma de mantener el volumen bajo siempre es filtrar bien, no leer todo y recortar después.

El nodo de Google Sheets no tiene un "ordenar por columna" potente. Si necesitas ordenar (por fecha, por valor), lee las filas y usa el nodo Sort de n8n después. Igual que con el filtrado avanzado, el ordenamiento fino es territorio de G4.

Trampas comunes

Trampa 1: El filtro no encuentra nada que "obviamente" está ahí

Qué pasa: Buscas Value: CDMX y la columna tiene cdmx o CDMX (con espacio). El nodo hace coincidencia exacta — CDMX ≠ cdmx ≠ CDMX .

Cómo evitar: Mantén tus hojas consistentes. Si los datos vienen sucios, normaliza el valor de búsqueda antes (todo a minúsculas, sin espacios) — técnica de G4.

Trampa 2: Asumir que el lookup siempre devuelve un solo resultado

Qué pasa: Filtras por email esperando una fila, pero el mismo email está duplicado en la hoja → recibes 2 items y el workflow procesa ambos.

Cómo evitar: Usa Return Only First Match si esperas un único resultado, o asegura que la columna realmente no tenga duplicados (eso es justo lo que el patrón "buscar antes de actuar" previene a futuro).

Trampa 3: Leer la hoja completa "por si acaso"

Qué pasa: Tu workflow lee 5,000 filas cada ejecución cuando solo necesitaba una. Lento, y consume cuota de la API de Google.

Cómo evitar: Pregúntate siempre "¿qué filas necesito de verdad?" y filtra. Leer todo es la excepción (reportes), no la regla.

Trampa 4: Filtrar por una columna con número y que no coincida

Qué pasa: Filtras Column: quantity, Value: 100 y no encuentra la fila que tiene 100. A veces la celda guarda 100.0 o el valor llega como texto "100".

Cómo evitar: Para columnas numéricas usadas como filtro, verifica el formato en la hoja. Lo más confiable para lookup es filtrar por columnas de texto (email, ID, código) que sean estables.

Ejercicio: tres lecturas

Objetivo: practicar lectura completa, lookup simple y lookup combinado.

Preparación

Usa una hoja Leads con estas columnas y al menos 6 filas variadas:

name	email	status	city

Tu tarea

Construye tres workflows (o uno con tres ramas), cada uno con Manual Trigger → Google Sheets:

Lectura completa: trae todas las filas. ¿Cuántos items recibes?
Lookup simple: trae solo las filas con status = pending
Lookup combinado: trae solo las filas con status = pending Y city = CDMX

Ver pistas

Filters vacío → recibes 1 item por fila de datos
Filters → Add Filter → Column status, Value pending
Dos filtros (n8n los combina con AND): status=pending + city=CDMX

Verifica contando: el resultado del 3 debe ser ≤ el del 2 ≤ el del 1.

Resumen y siguiente paso

Leer es la operación más segura — no modifica nada; por eso empezamos aquí
Get Row(s) sin filtro = todas las filas; con filtro = lookup selectivo
El Value del filtro puede ser dinámico ({{ $json.email }}) — buscas en la hoja el dato que llegó por el trigger
Varios filtros se combinan con AND; el nodo hace coincidencia exacta, no "contiene" ni rangos
Patrón clave: "buscar antes de actuar" — lookup → IF → update o append. Hace los workflows idempotentes
Un lookup sin resultados devuelve 0 items, no error — maneja ese caso con un IF
4 trampas: coincidencia exacta sensible a mayúsculas/espacios, asumir un único resultado, leer todo sin necesidad, formatos numéricos

Antes de avanzar deberías poder:

Leer una hoja completa y leer con filtro
Usar un valor dinámico en el filtro
Explicar el patrón "buscar antes de actuar"
Detectar cuando un lookup no encontró nada

Lo que sigue (cápsula 04):

Ya sabes leer. Ahora escribes: la operación Append, que agrega filas nuevas al final de la hoja. Vas a aprender a escribir sin pisar datos existentes y, sobre todo, a no duplicar — aplicando el patrón "buscar antes de actuar" que acabas de ver.

Recursos adicionales

n8n Google Sheets node Docs - Operaciones del nodo.
n8n IF node Docs - Para construir la rama "existe / no existe".
n8n Filter node Docs - Para filtrado avanzado después de leer.

Creado: Mayo 14, 2026 Versión: 1.0

← AnteriorConectar Google Sheets a n8n Siguiente →Escribir Filas Nuevas (Append)