---
title: "Risolvi Cannot use import statement outside a module nel browser e in Node.js"
description: "SyntaxError: Cannot use import statement outside a module vuol dire che il file è stato eseguito come script classico o come CommonJS. Caricalo come modulo e lo stesso import funziona."
canonical: "https://logbrew.co/it/errors/cannot-use-import-statement-outside-a-module"
last_updated: "2026-11-21"
---

# Risolvi Cannot use import statement outside a module nel browser e in Node.js

`SyntaxError: Cannot use import statement outside a module` vuol dire che il file è stato eseguito come script classico o come CommonJS. Caricalo come modulo e lo stesso `import` funziona.

Testato il 21 novembre 2026 con Chrome 157, Safari 27.2, Node.js 22.18.0 e @logbrew/browser 0.1.22

Di [Furkan Erday](https://github.com/furkanerday). Furkan Erday è il fondatore di LogBrew. Sviluppa LogBrew ogni giorno con Claude Code e Codex.

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

## Cosa hanno fatto 5 tag script con 1 `import`

| Come l’ha caricato la pagina | Codice eseguito | Problema in LogBrew |
| --- | --- | --- |
| `<script src>` senza tipo | No | `SyntaxError` |
| `<script>` inline | No | `SyntaxError` |
| `<script src>` da un’altra origine | No | `Error`, riga 0 |
| SDK in uno script `type="module"` | No | No |
| `<script type="module">` | Sì | Nessun errore |

Chrome 157 e Safari 27.2 hanno dato lo stesso risultato per ogni tag.

## Trova dove il file è stato eseguito come script classico

### Guarda il tag script che carica il file

Il tag non ha l’attributo `type`, quindi il browser legge `app.js` come script classico, e uno script classico non può usare `import`. Chrome 157 si è fermato alla riga 1, colonna 1, prima di eseguire qualsiasi riga del file. Uno script inline ha dato lo stesso messaggio.

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

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

pour("IPA");
```

Output

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

### Safari dà un altro messaggio per lo stesso file

Safari 27.2 ha letto lo stesso `app.js` e ha lanciato `SyntaxError: Unexpected token '{'. import call expects one or two arguments.` Il messaggio parla di una chiamata `import()` e non cita i moduli. La causa e la soluzione sono le stesse.

Output

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

### Anche un export in uno script classico fallisce

Un file che esporta e basta, caricato con un tag classico, si ferma al primo `export`. Chrome ha detto `Unexpected token 'export'` e Safari `Unexpected keyword 'export'`. In entrambi i casi la pagina ha caricato un modulo come script classico.

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

Output

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

### In Node.js, guarda il campo type del package.json

Node.js 22.18.0 ha lanciato lo stesso messaggio quando il `package.json` aveva `"type": "commonjs"`. Lo stack passa da `wrapSafe` nel loader CommonJS. Senza il campo `type`, Node.js ha eseguito il file come modulo e ha stampato un avviso al posto dell’errore.

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

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

Output

```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)
```

## Carica il file come modulo

### Aggiungi il tipo module al tag script

Con `type="module"` sullo stesso tag, `app.js` e il suo `import` sono stati eseguiti in Chrome 157 e Safari 27.2. Il browser carica poi `tap.js` da solo. Se anche un tag classico carica `tap.js`, toglilo, perché si ferma ancora su `export`.

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

### Imposta il tipo module nel package.json

Imposta `"type": "module"` nel `package.json`, o rinomina il file in `.mjs`. Entrambi hanno eseguito il nostro file senza avvisi. Node.js legge un file `.mjs` come modulo e un file `.cjs` come CommonJS, qualunque cosa dica il campo `type`.

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

// node app.js
```

Output

```text
poured IPA
```

### Carica prima l’SDK di LogBrew in uno script classico

Un errore di parsing scatta prima che venga eseguita qualsiasi riga di quel file, quindi il listener degli errori deve già essere sulla pagina. Il browser esegue uno script modulo solo dopo aver letto la pagina, quindi arriva troppo tardi. Con l’SDK in uno script classico nel `<head>`, LogBrew ha registrato l’errore. Con l’SDK in uno script `type="module"`, non ha registrato nulla.

```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>
```

## Cosa abbiamo visto nei test

Abbiamo servito 1 pagina su `http://127.0.0.1:28180` e l’abbiamo aperta in Chrome 157 e Safari 27.2, con `@logbrew/browser` 0.1.22 caricato per primo. Abbiamo caricato lo stesso codice in 5 modi e letto `error.message` dall’evento `error`.

Chrome ha indicato la causa, Safari no. Entrambi i browser hanno eseguito il file con `type="module"`. Uno script da un’altra origine ha dato solo `Script error.`, senza nome del file e con riga 0, perché il browser nasconde i dettagli di uno script di un’altra origine.

Node.js 22.18.0 ha dato l’errore solo con `"type": "commonjs"`. Senza il campo `type`, ha eseguito il file e stampato l’avviso qui sotto.

Output

```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>` senza tipo | `Cannot use import statement outside a module` | `Unexpected token '{'. import call expects one or two arguments.` |
| `<script>` inline senza tipo | `Cannot use import statement outside a module` | `Unexpected token '{'. import call expects one or two arguments.` |
| `tap.js` con un `export`, tag classico | `Unexpected token 'export'` | `Unexpected keyword 'export'` |
| `<script src>` da un’altra origine | `Script error.` | `Script error.` |
| `<script type="module">` | Eseguito | Eseguito |

## Perché uno script classico non può usare import

La pagina MDN di questo errore dice che una dichiarazione `import` può stare solo al livello più alto di un modulo, e che la causa abituale è un file che non viene eseguito come modulo. Un browser legge un file come modulo solo se il suo tag ha `type="module"`. Senza tipo, lo analizza come script classico e si ferma al primo `import`.

Uno script classico può usare la chiamata di funzione `import()`. Il messaggio di Safari parla di quella chiamata, per questo segnala un argomento mancante e non un modulo mancante.

Node.js decide file per file. Guarda prima l’estensione, poi il campo `type` del `package.json` più vicino. Secondo la documentazione di Node.js, da v22.7.0 e v20.19.0 un file senza campo `type` che non si può analizzare come CommonJS viene eseguito come modulo.

nodejs/node#39353 chiedeva nel 2021 che Node.js scegliesse in base al punto di ingresso e non al `package.json`. È stata chiusa nel 2022. Impostare `type` o usare `.mjs` rende comunque chiara la scelta, e toglie l’avviso.

1. `.mjs` `.cjs`
2. `package.json` `type`
3. Rilevamento della sintassi, se manca il campo `type`

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

## Cosa registra LogBrew

L’SDK ha registrato ogni errore di parsing come 1 problema chiamato `Browser error: SyntaxError`, con la chiave di raggruppamento `browser.error:SyntaxError`. Il problema aveva il percorso del file e la riga, nessun frame dello stack e il messaggio `redacted`, perché l’SDK non invia i messaggi di errore.

Gli errori di import ed export di entrambi i browser sono finiti in quello stesso problema, perché la chiave contiene solo il tipo di errore. Il campo `sourcePath` ti dice quale file correggere. Lo script da un’altra origine è diventato un problema a parte, `Browser error: Error`, con riga 0 e senza percorso del file.

Con l’SDK in uno script modulo, LogBrew non ha registrato nulla per la stessa pagina. Carica l’SDK in uno script classico prima del tuo codice, come nell’ultimo passo.

- `Browser error: SyntaxError`
  - `mechanism`: `browser.error`
  - `handled`: `false`
  - `sourcePath`: `/app.js`
  - `lineNumber`: `1`
  - Frame dello stack: 0
  - Chiave di raggruppamento: `browser.error:SyntaxError`
  - Messaggio: `redacted`
- `Browser error: Error`
  - `lineNumber`: `0`
  - Chiave di raggruppamento: `browser.error:Error`

## Domande frequenti

### Cosa vuol dire Cannot use import statement outside a module?

Il file contiene una dichiarazione `import`, ma è stato eseguito come script classico nel browser o come CommonJS in Node.js. Caricalo come modulo per risolvere.

### Come lo risolvo nel browser?

Aggiungi `type="module"` al tag script che carica il file. Nel nostro test, lo stesso `app.js` è poi stato eseguito in Chrome 157 e Safari 27.2.

### Come lo risolvo in Node.js?

Imposta `"type": "module"` nel `package.json`, o rinomina il file in `.mjs`. Da v22.7.0, Node.js rileva anche la sintassi dei moduli in un pacchetto senza campo `type` e stampa un avviso.

### Perché Safari mostra un errore diverso?

Safari 27.2 ha segnalato `Unexpected token '{'. import call expects one or two arguments.` per lo stesso file. È lo stesso problema, con la stessa soluzione.

### Cosa vuol dire Unexpected token export?

Nemmeno `export` funziona in uno script classico. Chrome ha detto `Unexpected token 'export'` e Safari `Unexpected keyword 'export'`. Carica come modulo anche quel file.

## Vedi ogni script che non supera il parsing

L’SDK per browser di LogBrew registra ogni errore di parsing con il file e la riga, raggruppato per tipo di errore. Inizia con il generoso piano gratuito, senza carta.

[Inizia gratis](https://logbrew.co/it)

## Fonti

- [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)

## Altre soluzioni agli errori

- [Risolvi l’errore di script che nasconde messaggio, file e riga](https://logbrew.co/it/errors/script-error)
- [Risolvi l’errore Failed to fetch e distingui le sue 3 cause](https://logbrew.co/it/errors/failed-to-fetch)
- [Risolvi java.lang.NullPointerException in Kotlin e Android partendo dal messaggio](https://logbrew.co/it/errors/nullpointerexception)
- [Risolvi l’errore Minified React #418 e #185 con il messaggio completo e la tua riga di codice](https://logbrew.co/it/errors/minified-react-error)
- [Risolvi l’errore di rete AxiosError e scopri quale delle 3 cause hai](https://logbrew.co/it/errors/axios-network-error)
- [Risolvi l’errore HTTP 499 e scopri chi ha smesso di aspettare](https://logbrew.co/it/errors/http-499)
- [Errori che abbiamo riprodotto, e come risolvere ciascuno](https://logbrew.co/it/errors)
