Saltar al contenido

Server Components vs. Client Components en Next.js: qué corre dónde

Guía/ 14 min de lectura

El modelo mental de Server y Client Components en Next.js: un árbol de servidor con hojas de cliente, componentes de servidor como children y lo que llega al navegador.

  • React
  • Next.js
  • Rendimiento
En este artículo (9)
  1. Por defecto, en Next.js todo son Server Components
  2. Qué puede hacer un Server Component
  3. Cuándo necesitas 'use client'
  4. Empujar lo interactivo a las hojas
  5. Pasar Server Components como children (o como cualquier prop)
  6. Qué viaja al navegador: HTML, RSC Payload y JavaScript
  7. Errores comunes
  8. Preguntas frecuentes
  9. Checklist

En Next.js con el App Router, los componentes son Server Components por defecto: corren en el servidor, pueden leer datos y su código nunca llega al navegador. Los Client Components son las hojas interactivas del árbol. Al navegador solo viajan el HTML, la salida serializada de los Server Components y el JavaScript de esas hojas.

Ya explicamos dónde poner 'use client' y cuánto JavaScript ahorras al bajarlo. Aquí va el modelo mental que hay detrás: el árbol de componentes, quién es dueño de quién y qué se serializa. Todo lo que mostramos salió de una demo local en Next.js 15.5.23 con React 19, con el payload real que devolvió el servidor.

Por defecto, en Next.js todo son Server Components

La guía de Server y Client Components de Next.js lo dice en su primera línea: los layouts y las páginas son Server Components por defecto. No hay directiva para marcarlos. La referencia de React aclara una confusión frecuente: 'use server' no marca Server Components, marca Server Functions, que son otra cosa.

Un Server Component se renderiza antes de llegar al navegador, en un entorno aparte: una vez durante el build o en cada petición. Su código no se manda al cliente. Lo que se manda es su resultado, ya calculado.

Piensa en tu página como un árbol. La raíz (el layout) y casi todas las ramas son de servidor. El cliente aparece solo donde algo tiene que responder al usuario: un selector de talla, unas pestañas, un buscador. Esas son las hojas. Esta es la ficha de producto de nuestra demo:

el árbol de una ficha de productoservidorclientelayout.tsxpage.tsx · asynch1 · precioAddToCartTabsReviews · asyncdueño: pagepadre: Tabsservidor por defecto, cliente en las hojasReviews corre en el servidor aunque Tabs lo muestre

Desliza la figura para verla completa

layout.tsx, page.tsx, el título, el precio y Reviews corren en el servidor. AddToCart y Tabs son de cliente. Fíjate en Reviews: aparece dentro de Tabs, pero no es de cliente. Más abajo verás por qué.

Un detalle de la guía de la frontera entre servidor y cliente evita muchos malentendidos: un Client Component también se renderiza en el servidor. Next.js lo convierte en HTML para la primera carga y después el navegador lo hidrata. La diferencia real es otra: el código de un Server Component nunca llega al navegador; el de un Client Component sí.

Qué puede hacer un Server Component

Como corre solo en el servidor, un Server Component puede hacer cosas que un componente de navegador no puede:

  • Ser async y esperar datos durante el render. React lo llama componentes asíncronos: escribes await getProduct(id) dentro del componente, sin una ruta de API intermedia.
  • Leer la base de datos, archivos o claves secretas. Nada de eso llega al cliente, siempre que no lo pases como prop (lo veremos con costCents).
  • Usar librerías pesadas sin enviarlas. El ejemplo de React convierte Markdown con marked y sanitize-html: en un componente de cliente ambas entran en el bundle; en uno de servidor, no.
  • Mostrar contenido en el primer HTML. El texto ya está en la respuesta, sin esperar JavaScript.

Lo que no puede hacer es todo lo que depende del navegador o del tiempo: useState, useEffect, manejadores como onClick, contexto de React y APIs como window. Su código no existe en el navegador, así que no tiene cómo reaccionar a un clic.

Ojo: no toda la interactividad necesita JavaScript propio. La guía de Next.js da tres ejemplos que funcionan en un Server Component: <details> se abre y se cierra solo, un <form> puede enviar a una Server Function con su prop action y <video controls> se reproduce sin ayuda. Antes de crear un componente de cliente, revisa si el HTML ya lo resuelve.

Cuándo necesitas 'use client'

La guía de Next.js da cuatro motivos para un Client Component: estado y eventos, efectos de ciclo de vida, APIs del navegador y hooks propios que usan cualquiera de los anteriores. Súmale un quinto: un provider de contexto, porque el contexto no funciona en Server Components. Si el componente no hace ninguna de esas cosas, déjalo en el servidor.

Si el componente…Va enPor qué
Lee la base de datos o usa una clave secretaServidorEl código y la clave no salen del servidor
Usa una librería pesada solo para pintar (Markdown, fechas, resaltado)ServidorLa librería no entra al bundle
Solo muestra datos: título, precio, descripción, reseñasServidorNo hay nada que hidratar
Abre y cierra con <details> o envía un formularioServidorEl navegador ya trae ese comportamiento
Usa useState u onClickClienteNecesita código que responda en el navegador
Usa useEffectClienteLos efectos solo corren en el navegador
Lee window o localStorageClienteSon APIs que no existen en el servidor
Da un contexto (provider)Cliente, envolviendo childrenEl contexto no existe en Server Components

Con useEffect vale la pena una pregunta antes: ¿lo necesitas? Muchos componentes se vuelven de cliente solo por un efecto que copia props en estado; revisa cuándo sobra useEffect para datos derivados. Y si el efecto pide datos al montar, casi siempre ese dato debería leerlo un Server Component.

¿servidor o cliente? decide por lo que hacesi el componente…va enlee la base de datos o una claveservidorusa una librería pesada para pintarservidorsolo muestra datos: precio, textoservidorabre y cierra con <details>servidor (HTML nativo)usa useState u onClickclienteusa useEffectclientelee window o localStorageclienteda un contexto (provider)cliente, con childrensin ninguna de estas, déjalo en el servidorcriterios de la guía de Next.js y de la referencia de React

Desliza la figura para verla completa

Empujar lo interactivo a las hojas

La regla de forma del árbol: la raíz y las ramas en el servidor, el cliente en las hojas. Esta es la página de la demo, un Server Component asíncrono:

import { notFound } from "next/navigation";
import { getProduct } from "@/lib/products";
import AddToCart from "./add-to-cart";
import Tabs from "./tabs";
import Reviews from "./reviews";

export default async function Page({ params }: { params: Promise<{ id: string }> }) {
  const { id } = await params;
  const product = await getProduct(id);
  if (!product) notFound();

  const price = new Intl.NumberFormat("es-MX", { style: "currency", currency: "MXN" })
    .format(product.priceCents / 100);

  return (
    <main>
      <h1>{product.name}</h1>
      <p>{price}</p>
      <AddToCart productId={product.id} sizes={product.sizes} />
      <Tabs
        panels={[
          { label: "Reseñas", content: <Reviews productId={product.id} /> },
          { label: "Envío", content: <p>Envío gratis desde $999.</p> },
        ]}
      />
    </main>
  );
}
  1. Sin directiva: es Server Component por defecto, y por eso puede ser async.
  2. getProduct viene de lib/products.ts, que empieza con import "server-only". Si un archivo de cliente llegara a importarlo, el build falla.
  3. await params: en Next.js 15 los parámetros de la ruta llegan como promesa.
  4. El precio se formatea aquí. Al navegador llega el texto $1,899.00, no Intl ni los centavos.
  5. AddToCart recibe solo lo que usa: un id y un array de tallas. No recibe el producto completo, y eso importa (ver más abajo).
  6. Tabs recibe un array de paneles; cada content es JSX que esta página renderiza.

La hoja de cliente es pequeña:

"use client";

import { useState } from "react";

export default function AddToCart({ productId, sizes }: { productId: string; sizes: string[] }) {
  const [size, setSize] = useState(sizes[0]);
  const [added, setAdded] = useState(false);

  return (
    <div>
      {sizes.map((s) => (
        <button key={s} aria-pressed={s === size} onClick={() => setSize(s)}>
          {s}
        </button>
      ))}
      <button onClick={() => setAdded(true)} data-product={productId}>
        {added ? `Agregado: talla ${size}` : "Agregar al carrito"}
      </button>
    </div>
  );
}
  1. "use client" en la primera línea: este archivo es la entrada al grafo de cliente.
  2. Dos estados: la talla elegida y si ya se agregó.
  3. Cada talla es un botón con aria-pressed, así un lector de pantalla anuncia cuál está activa.
  4. El botón final cambia su texto al hacer clic. En la demo, Playwright eligió la talla 27, hizo clic y leyó «Agregado: talla 27».

Si mañana la página necesita un buscador, va en otra hoja. Lo que no hace falta es mover la página entera al cliente; cuánto pesa ese error lo medimos en el artículo de 'use client'.

Pasar Server Components como children (o como cualquier prop)

Aquí está la parte que más confunde. Tabs es de cliente porque cambia de pestaña con useState. Pero muestra Reviews, que es asíncrono y lee datos. ¿Cómo puede un componente de cliente mostrar uno de servidor?

"use client";

import { useState, type ReactNode } from "react";

export default function Tabs({ panels }: { panels: { label: string; content: ReactNode }[] }) {
  const [active, setActive] = useState(0);

  return (
    <section>
      {panels.map((p, i) => (
        <button key={p.label} aria-pressed={i === active} onClick={() => setActive(i)}>
          {p.label}
        </button>
      ))}
      {panels.map((p, i) => (
        <div key={p.label} hidden={i !== active}>
          {p.content}
        </div>
      ))}
    </section>
  );
}
  1. Tabs no importa Reviews. Solo declara que recibe paneles con un content de tipo ReactNode.
  2. Pinta un botón por panel y guarda el índice activo en estado.
  3. Renderiza todos los paneles y oculta los inactivos con hidden. Así el texto de todas las pestañas queda en el HTML inicial.

La guía de la frontera de Next.js lo explica con dos papeles que React separa. El dueño es el componente en cuyo código está el JSX del hijo: page.tsx escribe <Reviews />, así que es su dueño. El padre es quien lo contiene en el árbol renderizado: Tabs. Como el dueño es de servidor, Reviews se renderiza en el servidor, y Tabs recibe su salida para colocarla, nunca su código.

La referencia de 'use client' lo resume así: la frontera vive en el árbol de dependencias de módulos, no en el árbol de renderizado. Que un componente aparezca dentro de otro no dice dónde corre. Lo dice quién lo importa.

children funciona igual, porque es una prop más: un modal o un desplegable de cliente que envuelve {children} puede mostrar contenido de servidor. Lo que no funciona es importar el componente de servidor dentro del archivo de cliente. Lo probamos: un archivo con "use client" que importaba reviews.tsx rompió el build, porque arrastró lib/products.ts al grafo de cliente:

./lib/products.ts
Error:   x You're importing a component that needs "server-only". That only works in a Server Component which is not supported in the pages/ directory.

Import trace for requested module:
./lib/products.ts
./app/p/[id]/reviews.tsx
./app/bad/tabs-bad.tsx

Sin server-only, el error habría sido otro o, peor, ninguno: el módulo se habría mandado al navegador. Por eso conviene ponerlo en todo archivo que lea datos o claves.

Qué viaja al navegador: HTML, RSC Payload y JavaScript

En la primera carga, según la guía de Next.js, el navegador recibe tres cosas: el HTML, que muestra la página de inmediato aunque todavía no responda; el RSC Payload, una representación serializada del árbol de Server Components; y el JavaScript de los Client Components, que los hidrata. En navegaciones posteriores dentro del sitio llega solo el payload, y los Client Components se renderizan en el navegador.

lo que viaja al navegador en la primera cargaHTML<h1>Tenis Ruta</h1>botones de tallareseñas en textopanel Envío ocultoRSC Payloadsalida de ReviewsI[2710] AddToCartI[3790] Tabsprops: productId,sizes, panelsJavaScriptAddToCart + Tabs965 B sin gzipuseState, onClickno viaja: el código de Reviews, getReviews ni costCentsel formato del payload es interno de Reactsalida, referencias y props, no códigodemo local: Next.js 15.5.23, next build y next start

Desliza la figura para verla completa

Pedimos el payload de la página con la cabecera RSC: 1. Estas son cuatro de sus líneas, tal cual. El formato es interno de React y puede cambiar: léelo para entender, no para depender de él.

e:I[2710,["841","static/chunks/app/p/%5Bid%5D/page-e5fb1ad810c9ab0d.js"],"default"]
f:I[3790,["841","static/chunks/app/p/%5Bid%5D/page-e5fb1ad810c9ab0d.js"],"default"]
4:["$","main",null,{"children":[["$","h1",null,{"children":"Tenis Ruta"}],["$","p",null,{"children":"$$1,899.00"}],["$","$Le",null,{"productId":"1","sizes":["25","26","27"]}],["$","$Lf",null,{"panels":[{"label":"Reseñas","content":"$L10"},{"label":"Envío","content":["$","p",null,{"children":"Envío gratis desde $999."}]}]}]]}]
10:["$","ul",null,{"children":[["$","li","Ana",{"children":["★★★★★"," ","Cómodos desde el primer día."," (","Ana",")"]}],["$","li","Luis",{"children":["★★★★"," ","La talla es exacta."," (","Luis",")"]}]]}]
  1. e y f son referencias a Client Components: el módulo 2710 (AddToCart) y el 3790 (Tabs), y el archivo de JavaScript donde viven.
  2. La línea 4 es la salida de la página: un main con el h1 y el precio ya calculados (el $$ es un $ escapado). $Le es un hueco para AddToCart con sus props productId y sizes; $Lf es Tabs con sus paneles.
  3. El panel de reseñas apunta a $L10, y la línea 10 es una lista ul con el texto de las reseñas. No hay rastro de Reviews ni de getReviews: solo su resultado.

Del lado del JavaScript, el chunk de la página pesa 965 bytes sin comprimir y contiene dos módulos: AddToCart y Tabs. Buscamos en todos los archivos de .next/static el texto de las reseñas, getReviews y el costo del producto: no aparecen.

Lo que pasas como prop se publica

Los datos cruzan la frontera por props, y las props se serializan. En la demo, el producto tiene un campo interno, costCents, lo que le cuesta a la tienda. Con productId y sizes no sale. En una variante de la página pasamos el objeto completo a un componente de cliente que solo usaba el nombre, y esto apareció en el payload, y también dentro del HTML:

4:["$","$Le",null,{"product":{"id":"1","name":"Tenis Ruta","priceCents":189900,"costCents":74250,"sizes":["25","26","27"]}}]

Cualquiera que abra el código fuente de la página puede leerlo. TypeScript no avisa, porque el tipo es correcto. La regla: pasa a las hojas solo los campos que usan. Es el mismo principio que con las variables de entorno: lo que llega al cliente es público, como explicamos en NEXT_PUBLIC_ y secretos.

No todo se puede serializar. React acepta primitivos, arrays, Map, Set, Date, objetos planos, JSX, promesas y Server Functions. No acepta clases, instancias ni funciones normales. Pasamos una función para formatear el precio y el build se detuvo al prerenderizar, aunque tsc no se quejó:

Error: Functions cannot be passed directly to Client Components unless you explicitly expose it by marking it with
"use server". Or maybe you meant to call this function rather than return it.
  {cents: 189900, format: function format}
                          ^^^^^^^^^^^^^^^

La salida es la que ya usa la demo: formatea en el servidor y pasa el texto.

El HTML inicial y el LCP

Como el contenido de los Server Components ya está en el HTML, el navegador puede pintarlo y descubrir la imagen principal sin esperar JavaScript. Comparamos con una versión vieja de la misma ficha: una página con "use client" que pedía el producto a una ruta de API dentro de useEffect. Su HTML inicial solo contenía «Cargando…»; el nombre del producto aparecía después de hidratar y hacer la petición. Si en esa ficha hubiera una foto, la imagen más grande también llegaría tarde, que es justo lo que empeora el LCP de la imagen principal.

Errores comunes

  • Creer que 'use server' marca un Server Component. No hay directiva para ellos; 'use server' es para Server Functions.
  • Creer que un Client Component solo corre en el navegador. También se renderiza en el servidor para el HTML inicial; por eso window fuera de un efecto falla.
  • Importar un Server Component dentro de un archivo de cliente. Se vuelve de cliente, o rompe el build si usa server-only. Pásalo como children o como prop.
  • Pasar objetos completos a las hojas. Todo campo viaja en el payload y en el HTML, incluidos los internos.
  • Pasar funciones como props. El build falla al prerenderizar. Calcula en el servidor o usa una Server Function.
  • Pedir en useEffect datos que el servidor ya tiene. Retrasa el contenido y suma una petición.
  • Poner el provider de contexto alrededor de todo <html>. La guía de Next.js pide ponerlo lo más abajo posible, envolviendo solo {children}.

Preguntas frecuentes

¿Un Server Component se vuelve a renderizar si cambia el estado de su hijo?

No. El estado vive en el componente de cliente y se actualiza en el navegador. El Server Component solo se vuelve a renderizar cuando Next.js renderiza la ruta otra vez: una navegación, un refresh o una revalidación.

¿Puede un Client Component ser async?

No. Los componentes asíncronos son de servidor. Si un Client Component necesita un dato del servidor, recíbelo como prop; o recibe una promesa iniciada en el servidor y léela con use dentro de un Suspense.

¿Los Server Components ayudan al SEO?

Ayudan a que el contenido esté en el primer HTML, que es lo que lee un rastreador que no ejecuta JavaScript. Los Client Components también aportan HTML en ese render; lo que no aparece es el contenido que depende de una interacción o de un efecto.

¿Cómo sé si un componente sin directiva es de servidor o de cliente?

Mira quién lo importa. Si lo importa un módulo con 'use client' o algo que cuelga de él, es de cliente en ese uso. Si lo importa un Server Component, es de servidor. El mismo archivo puede ser las dos cosas en lugares distintos.

Checklist

  • Las páginas y los layouts no llevan 'use client'.
  • Cada componente de cliente usa estado, eventos, efectos, APIs del navegador o contexto.
  • Lo interactivo está en hojas pequeñas, cada una en su archivo.
  • El contenido de servidor entra a los componentes de cliente como children u otra prop, nunca como import.
  • Las hojas reciben solo los campos que usan, nada de objetos completos.
  • No pasas funciones normales como props a componentes de cliente.
  • Los archivos que leen datos o claves empiezan con import "server-only".
  • Los datos de la primera carga los lee un Server Component, no un useEffect.
  • Revisaste el HTML y el payload (RSC: 1) de una página en busca de campos internos.

Con el árbol claro, decidir dónde va cada componente se vuelve una pregunta corta: ¿necesita el navegador? Si no, se queda en el servidor.

El HTML nativo también resuelve parte de la interactividad sin enviar JavaScript, como la Popover API. Y cuando un componente de servidor recibe datos de fuera, valídalos en la entrada con zod.

¿Viste esto en Instagram? Todas las guías de los Reels están en ecomlabs.dev/guias.

Escrito por

Luis Morales

Luis Morales

Desarrollador frontend y Shopify, EcomLabs

@luismoralesdev en Instagram

Publicado el 19 de noviembre de 2026 · actualizado el 20 de noviembre de 2026

← Blog