---
title: "Soluciona Cannot use import statement outside a module en el navegador y en Node.js"
description: "SyntaxError: Cannot use import statement outside a module significa que el archivo se ejecutó como script clásico o como CommonJS. Cárgalo como módulo y el mismo import se ejecuta."
canonical: "https://logbrew.co/es/errors/cannot-use-import-statement-outside-a-module"
last_updated: "2026-11-21"
---

# Soluciona Cannot use import statement outside a module en el navegador y en Node.js

`SyntaxError: Cannot use import statement outside a module` significa que el archivo se ejecutó como script clásico o como CommonJS. Cárgalo como módulo y el mismo `import` se ejecuta.

Probado el 21 de noviembre de 2026 con Chrome 157, Safari 27.2, Node.js 22.18.0 y @logbrew/browser 0.1.22

Por [Furkan Erday](https://github.com/furkanerday). Furkan Erday es el fundador de LogBrew. Desarrolla LogBrew con Claude Code y Codex todos los días.

Canonical: https://logbrew.co/es/errors/cannot-use-import-statement-outside-a-module

## Qué hicieron 5 etiquetas script con 1 `import`

| Cómo la cargó la página | El código se ejecutó | Incidencia en LogBrew |
| --- | --- | --- |
| `<script src>` sin tipo | No | `SyntaxError` |
| `<script>` en línea | No | `SyntaxError` |
| `<script src>` de otro origen | No | `Error`, línea 0 |
| SDK en un script `type="module"` | No | No |
| `<script type="module">` | Sí | Sin error |

Chrome 157 y Safari 27.2 dieron el mismo resultado con cada etiqueta.

## Averigua dónde se ejecutó el archivo como script clásico

### Revisa la etiqueta script que carga el archivo

La etiqueta no tiene atributo `type`, así que el navegador lee `app.js` como script clásico, y un script clásico no puede usar `import`. Chrome 157 se detuvo en la línea 1, columna 1, antes de ejecutar ninguna línea del archivo. Un script en línea dio el mismo mensaje.

```bash
<!-- index.html -->
<script src="/app.js"></script>

// app.js
import { pour } from "./tap.js";

pour("IPA");
```

Salida

```text
Uncaught SyntaxError: Cannot use import statement outside a module
```

### Safari da otro mensaje para el mismo archivo

Safari 27.2 leyó el mismo `app.js` y lanzó `SyntaxError: Unexpected token '{'. import call expects one or two arguments.` El mensaje habla de una llamada a `import()` y no menciona ningún módulo. La causa y la solución son las mismas.

Salida

```text
SyntaxError: Unexpected token '{'. import call expects one or two arguments.
```

### Un export en un script clásico también falla

Un archivo que solo exporta, cargado con una etiqueta clásica, se detiene en su primer `export`. Chrome mostró `Unexpected token 'export'` y Safari `Unexpected keyword 'export'`. Ambos significan que la página cargó un módulo como script clásico.

```bash
// tap.js, loaded with <script src="/tap.js"></script>
export function pour(beer) {
  document.body.dataset.poured = beer;
}
```

Salida

```text
Uncaught SyntaxError: Unexpected token 'export'
```

### En Node.js, revisa el campo type de package.json

Node.js 22.18.0 lanzó el mismo mensaje cuando `package.json` tenía `"type": "commonjs"`. La pila pasa por `wrapSafe` en el cargador de CommonJS. Sin campo `type`, Node.js ejecutó el archivo como módulo y mostró una advertencia en su lugar.

```bash
// package.json
{ "name": "lab", "type": "commonjs" }

// node app.js
import { pour } from "./tap.js";
```

Salida

```text
import { pour } from "./tap.js";
^^^^^^

SyntaxError: Cannot use import statement outside a module
    at wrapSafe (node:internal/modules/cjs/loader:1620:18)
    at Module._compile (node:internal/modules/cjs/loader:1662:20)
```

## Carga el archivo como módulo

### Añade el tipo module a la etiqueta script

Con `type="module"` en la misma etiqueta, `app.js` y su `import` se ejecutaron en Chrome 157 y Safari 27.2. El navegador carga entonces `tap.js` por ti. Si una etiqueta clásica también carga `tap.js`, quítala, porque sigue deteniéndose en `export`.

```bash
<script type="module" src="/app.js"></script>
```

### Define el tipo module en package.json

Pon `"type": "module"` en `package.json`, o cambia la extensión del archivo a `.mjs`. Las 2 opciones ejecutaron nuestro archivo sin advertencia. Node.js lee un archivo `.mjs` como módulo y uno `.cjs` como CommonJS, diga lo que diga el campo `type`.

```bash
// package.json
{ "name": "lab", "type": "module" }

// node app.js
```

Salida

```text
poured IPA
```

### Carga primero el SDK de LogBrew en un script clásico

Un error de análisis ocurre antes de que se ejecute ninguna línea de ese archivo, así que el listener de errores ya debe estar en la página. El navegador ejecuta un script de módulo solo después de leer la página, así que llega tarde. Con el SDK en un script clásico dentro de `<head>`, LogBrew registró el error. Con el SDK en un script `type="module"`, no registró nada.

```bash
// logbrew.ts
import { installLogBrewBrowser } from "@logbrew/browser";

installLogBrewBrowser({ clientKey: "LOGBREW_BROWSER_KEY" });

// bun build logbrew.ts --format=iife --outfile=public/logbrew.js
// index.html, in <head> before every other script:
// <script src="/logbrew.js"></script>
```

## Lo que vimos al probarlo

Servimos 1 página en `http://127.0.0.1:28180` y la abrimos en Chrome 157 y Safari 27.2, con `@logbrew/browser` 0.1.22 cargado primero. Cargamos el mismo código de 5 formas y leímos `error.message` del evento `error`.

Chrome nombró la causa y Safari no. Los 2 navegadores ejecutaron el archivo con `type="module"`. Un script de otro origen dio solo `Script error.`, sin nombre de archivo y en la línea 0, porque el navegador oculta los detalles de un script de otro origen.

Node.js 22.18.0 dio el error solo con `"type": "commonjs"`. Sin campo `type`, ejecutó el archivo y mostró la advertencia de abajo.

Salida

```text
poured IPA
(node:37250) [MODULE_TYPELESS_PACKAGE_JSON] Warning: Module type of file:///…/app.js is not specified and it doesn't parse as CommonJS.
Reparsing as ES module because module syntax was detected. This incurs a performance overhead.
To eliminate this warning, add "type": "module" to /…/package.json.
```

|  | Chrome 157 | Safari 27.2 |
| --- | --- | --- |
| `<script src>` sin tipo | `Cannot use import statement outside a module` | `Unexpected token '{'. import call expects one or two arguments.` |
| `<script>` en línea sin tipo | `Cannot use import statement outside a module` | `Unexpected token '{'. import call expects one or two arguments.` |
| `tap.js` con un `export`, etiqueta clásica | `Unexpected token 'export'` | `Unexpected keyword 'export'` |
| `<script src>` de otro origen | `Script error.` | `Script error.` |
| `<script type="module">` | Se ejecutó | Se ejecutó |

## Por qué un script clásico no puede usar import

La página de MDN sobre este error dice que una declaración `import` solo puede ir en el nivel superior de un módulo, y que la causa habitual es un archivo que no se ejecuta como módulo. Un navegador lee un archivo como módulo solo si su etiqueta tiene `type="module"`. Sin tipo, lo analiza como script clásico y se detiene en el primer `import`.

Un script clásico sí puede usar la llamada de función `import()`. El mensaje de Safari habla de esa llamada, por eso informa de un argumento que falta y no de un módulo.

Node.js decide archivo por archivo. Primero mira la extensión y luego el campo `type` del `package.json` más cercano. Según la documentación de Node.js, desde v22.7.0 y v20.19.0 un archivo sin campo `type` que no se puede analizar como CommonJS se ejecuta como módulo.

nodejs/node#39353 pidió en 2021 que Node.js eligiera según el punto de entrada y no según `package.json`. Se cerró en 2022. Definir `type` o usar `.mjs` sigue dejando clara la elección, y quita la advertencia.

1. `.mjs` `.cjs`
2. `package.json` `type`
3. Detección de sintaxis, si no hay campo `type`

- [nodejs/node#39353](https://github.com/nodejs/node/issues/39353) Detect require vs. import based on the entry point, not package.json. Cerrado, 45 comentarios.

## Lo que LogBrew registra

El SDK registró cada error de análisis como 1 incidencia llamada `Browser error: SyntaxError`, con la clave de agrupación `browser.error:SyntaxError`. La incidencia tenía la ruta del archivo y la línea, ningún frame de pila y el mensaje `redacted`, porque el SDK no envía mensajes de error.

Los errores de import y export de los 2 navegadores fueron a esa misma incidencia, porque la clave solo contiene el tipo de error. El campo `sourcePath` te dice qué archivo corregir. El script de otro origen fue una incidencia aparte, `Browser error: Error`, con la línea 0 y sin ruta de archivo.

Con el SDK en un script de módulo, LogBrew no registró nada para la misma página. Carga el SDK en un script clásico antes de tu código, como en el último paso.

- `Browser error: SyntaxError`
  - `mechanism`: `browser.error`
  - `handled`: `false`
  - `sourcePath`: `/app.js`
  - `lineNumber`: `1`
  - Frames de pila: 0
  - Clave de agrupación: `browser.error:SyntaxError`
  - Mensaje: `redacted`
- `Browser error: Error`
  - `lineNumber`: `0`
  - Clave de agrupación: `browser.error:Error`

## Preguntas frecuentes

### ¿Qué significa Cannot use import statement outside a module?

El archivo tiene una declaración `import`, pero se ejecutó como script clásico en el navegador o como CommonJS en Node.js. Cárgalo como módulo para solucionarlo.

### ¿Cómo lo soluciono en el navegador?

Añade `type="module"` a la etiqueta script que carga el archivo. En nuestra prueba, el mismo `app.js` se ejecutó después en Chrome 157 y Safari 27.2.

### ¿Cómo lo soluciono en Node.js?

Pon `"type": "module"` en `package.json`, o cambia la extensión del archivo a `.mjs`. Desde v22.7.0, Node.js también detecta la sintaxis de módulo en un paquete sin campo `type` y muestra una advertencia.

### ¿Por qué Safari muestra otro error?

Safari 27.2 mostró `Unexpected token '{'. import call expects one or two arguments.` para el mismo archivo. Es el mismo problema, con la misma solución.

### ¿Qué significa Unexpected token export?

Un script clásico tampoco puede usar `export`. Chrome mostró `Unexpected token 'export'` y Safari `Unexpected keyword 'export'`. Carga ese archivo también como módulo.

## Ve cada script que no se puede analizar

El SDK de navegador de LogBrew registra cada error de análisis con su archivo y su línea, agrupado por tipo de error. Empieza con el generoso plan gratuito, sin tarjeta.

[Empezar gratis](https://logbrew.co/es)

## Fuentes

- [MDN, SyntaxError: import declarations may only appear at top level of a module](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/import_decl_module_top_level)
- [MDN, Using modules on the web](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules/Modules_on_the_web)
- [Node.js docs, Determining module system](https://nodejs.org/api/packages.html#determining-module-system)
- [nodejs/node#39353](https://github.com/nodejs/node/issues/39353)

## Más soluciones a errores

- [Soluciona el error Script error que oculta su mensaje, archivo y línea](https://logbrew.co/es/errors/script-error)
- [Soluciona el error Failed to fetch y distingue sus 3 causas](https://logbrew.co/es/errors/failed-to-fetch)
- [Soluciona java.lang.NullPointerException en Kotlin y Android a partir de su mensaje](https://logbrew.co/es/errors/nullpointerexception)
- [Corrige Minified React error #418 y #185 con el mensaje completo y tu línea de código](https://logbrew.co/es/errors/minified-react-error)
- [Soluciona AxiosError Network Error y averigua cuál de sus 3 causas tienes](https://logbrew.co/es/errors/axios-network-error)
- [Soluciona el error HTTP 499 y averigua quién dejó de esperar](https://logbrew.co/es/errors/http-499)
- [Errores que reproducimos, y cómo solucionar cada uno](https://logbrew.co/es/errors)
