---
title: "Cannot use import statement outside a module oplossen in de browser en in Node.js"
description: "SyntaxError: Cannot use import statement outside a module betekent dat het bestand draaide als klassiek script of als CommonJS. Laad het als module, dan draait dezelfde import wel."
canonical: "https://logbrew.co/nl/errors/cannot-use-import-statement-outside-a-module"
last_updated: "2026-11-21"
---

# Cannot use import statement outside a module oplossen in de browser en in Node.js

`SyntaxError: Cannot use import statement outside a module` betekent dat het bestand draaide als klassiek script of als CommonJS. Laad het als module, dan draait dezelfde `import` wel.

Getest op 21 november 2026 met Chrome 157, Safari 27.2, Node.js 22.18.0 en @logbrew/browser 0.1.22

Door [Furkan Erday](https://github.com/furkanerday). Furkan Erday is de oprichter van LogBrew. Hij bouwt LogBrew elke dag met Claude Code en Codex.

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

## Wat 5 scripttags deden met 1 `import`

| Hoe de pagina het laadde | Code draaide | Issue in LogBrew |
| --- | --- | --- |
| `<script src>` zonder type | Nee | `SyntaxError` |
| Inline `<script>` | Nee | `SyntaxError` |
| `<script src>` van een andere origin | Nee | `Error`, regel 0 |
| SDK in een `type="module"`-script | Nee | Nee |
| `<script type="module">` | Ja | Geen fout |

Chrome 157 en Safari 27.2 gaven voor elke tag hetzelfde resultaat.

## Zoek waar het bestand als klassiek script draaide

### Bekijk de scripttag die het bestand laadt

De tag heeft geen `type`-attribuut, dus de browser leest `app.js` als klassiek script, en een klassiek script kan geen `import` gebruiken. Chrome 157 stopte op regel 1, kolom 1, voordat er ook maar één regel van het bestand draaide. Een inline script gaf dezelfde melding.

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

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

pour("IPA");
```

Uitvoer

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

### Safari geeft een andere melding voor hetzelfde bestand

Safari 27.2 las dezelfde `app.js` en gooide `SyntaxError: Unexpected token '{'. import call expects one or two arguments.` De melding gaat over een `import()`-aanroep en noemt geen module. De oorzaak en de oplossing zijn hetzelfde.

Uitvoer

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

### Een export in een klassiek script faalt ook

Een bestand dat alleen exporteert en via een klassieke tag laadt, stopt bij de eerste `export`. Chrome meldde `Unexpected token 'export'` en Safari `Unexpected keyword 'export'`. Allebei betekenen ze dat de pagina een module als klassiek script laadde.

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

Uitvoer

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

### Kijk in Node.js naar het type-veld van package.json

Node.js 22.18.0 gooide dezelfde melding toen `package.json` `"type": "commonjs"` had. De stack loopt via `wrapSafe` in de CommonJS-loader. Zonder `type`-veld draaide Node.js het bestand als module en gaf het in plaats daarvan een waarschuwing.

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

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

Uitvoer

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

## Laad het bestand als module

### Zet het moduletype op de scripttag

Met `type="module"` op dezelfde tag draaiden `app.js` en de `import` ervan in Chrome 157 en Safari 27.2. De browser laadt `tap.js` dan zelf. Laadt een klassieke tag `tap.js` ook nog, haal die tag dan weg, want die stopt nog steeds bij `export`.

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

### Zet het moduletype in package.json

Zet `"type": "module"` in `package.json`, of hernoem het bestand naar `.mjs`. Allebei draaiden ons bestand zonder waarschuwing. Node.js leest een `.mjs`-bestand als module en een `.cjs`-bestand als CommonJS, wat het `type`-veld ook zegt.

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

// node app.js
```

Uitvoer

```text
poured IPA
```

### Laad de LogBrew-SDK eerst in een klassiek script

Een parsefout treedt op voordat er één regel van dat bestand draait, dus de foutlistener moet al op de pagina staan. De browser voert een modulescript pas uit nadat hij de pagina heeft gelezen, dus dat is te laat. Met de SDK in een klassiek script in `<head>` legde LogBrew de fout vast. Met de SDK in een `type="module"`-script niets.

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

## Wat we zagen in onze test

We serveerden 1 pagina op `http://127.0.0.1:28180` en openden die in Chrome 157 en Safari 27.2, met `@logbrew/browser` 0.1.22 als eerste geladen. We laadden dezelfde code op 5 manieren en lazen `error.message` uit het `error`-event.

Chrome noemde de oorzaak, Safari niet. Beide browsers draaiden het bestand met `type="module"`. Een script van een andere origin gaf alleen `Script error.`, zonder bestandsnaam en met regel 0, omdat de browser de details van een script van een andere origin verbergt.

Node.js 22.18.0 gaf de fout alleen met `"type": "commonjs"`. Zonder `type`-veld draaide het het bestand en gaf het de waarschuwing hieronder.

Uitvoer

```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>` zonder type | `Cannot use import statement outside a module` | `Unexpected token '{'. import call expects one or two arguments.` |
| Inline `<script>` zonder type | `Cannot use import statement outside a module` | `Unexpected token '{'. import call expects one or two arguments.` |
| `tap.js` met een `export`, klassieke tag | `Unexpected token 'export'` | `Unexpected keyword 'export'` |
| `<script src>` van een andere origin | `Script error.` | `Script error.` |
| `<script type="module">` | Draaide | Draaide |

## Waarom een klassiek script geen import kan gebruiken

De MDN-pagina over deze fout zegt dat een `import`-declaratie alleen op het hoogste niveau van een module mag staan, en dat de gewone oorzaak een bestand is dat niet als module draait. Een browser leest een bestand alleen als module als de tag `type="module"` heeft. Zonder type parset hij het als klassiek script en stopt hij bij de eerste `import`.

Een klassiek script mag de functieaanroep `import()` wel gebruiken. De melding van Safari gaat over die aanroep, en meldt daarom een ontbrekend argument en geen ontbrekende module.

Node.js beslist per bestand. Eerst telt de extensie, dan het `type`-veld van de dichtstbijzijnde `package.json`. Volgens de Node.js-documentatie draait sinds v22.7.0 en v20.19.0 een bestand zonder `type`-veld als module als het niet als CommonJS te parsen is.

nodejs/node#39353 vroeg in 2021 of Node.js kon kiezen op basis van het entrypoint en niet van `package.json`. Het issue is in 2022 gesloten. Met `type` of `.mjs` is de keuze nog steeds duidelijk, en verdwijnt de waarschuwing.

1. `.mjs` `.cjs`
2. `package.json` `type`
3. Syntaxdetectie, als er geen `type`-veld is

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

## Wat LogBrew vastlegt

De SDK legde elke parsefout vast als 1 issue met de naam `Browser error: SyntaxError`, met de groeperingssleutel `browser.error:SyntaxError`. Het issue had het bestandspad en de regel, geen stackframes en de melding `redacted`, omdat de SDK geen foutmeldingen verstuurt.

De import- en exportfouten uit beide browsers kwamen in datzelfde issue, omdat de sleutel alleen het fouttype bevat. Het veld `sourcePath` zegt welk bestand je moet aanpassen. Het script van een andere origin werd een apart issue, `Browser error: Error`, met regel 0 en zonder bestandspad.

Met de SDK in een modulescript legde LogBrew niets vast voor dezelfde pagina. Laad de SDK in een klassiek script vóór je eigen code, zoals in de laatste stap.

- `Browser error: SyntaxError`
  - `mechanism`: `browser.error`
  - `handled`: `false`
  - `sourcePath`: `/app.js`
  - `lineNumber`: `1`
  - Stackframes: 0
  - Groeperingssleutel: `browser.error:SyntaxError`
  - Melding: `redacted`
- `Browser error: Error`
  - `lineNumber`: `0`
  - Groeperingssleutel: `browser.error:Error`

## Veelgestelde vragen

### Wat betekent Cannot use import statement outside a module?

Het bestand heeft een `import`-declaratie, maar draaide als klassiek script in de browser of als CommonJS in Node.js. Laad het als module om dit op te lossen.

### Hoe los ik het op in de browser?

Zet `type="module"` op de scripttag die het bestand laadt. In onze test draaide dezelfde `app.js` daarna in Chrome 157 en Safari 27.2.

### Hoe los ik het op in Node.js?

Zet `"type": "module"` in `package.json`, of hernoem het bestand naar `.mjs`. Sinds v22.7.0 herkent Node.js modulesyntax ook in een pakket zonder `type`-veld en geeft het een waarschuwing.

### Waarom toont Safari een andere fout?

Safari 27.2 meldde `Unexpected token '{'. import call expects one or two arguments.` voor hetzelfde bestand. Het is hetzelfde probleem, met dezelfde oplossing.

### Wat betekent Unexpected token export?

Een klassiek script kan ook geen `export` gebruiken. Chrome meldde `Unexpected token 'export'` en Safari `Unexpected keyword 'export'`. Laad ook dat bestand als module.

## Zie elk script dat niet te parsen is

De LogBrew browser-SDK legt elke parsefout vast met het bestand en de regel, gegroepeerd per fouttype. Begin met het ruime gratis abonnement, zonder creditcard.

[Gratis beginnen](https://logbrew.co/nl)

## Bronnen

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

## Meer fouten oplossen

- [De Script error oplossen die zijn melding, bestand en regel verbergt](https://logbrew.co/nl/errors/script-error)
- [De fout Failed to fetch oplossen en de 3 oorzaken uit elkaar houden](https://logbrew.co/nl/errors/failed-to-fetch)
- [java.lang.NullPointerException in Kotlin en Android oplossen via de melding](https://logbrew.co/nl/errors/nullpointerexception)
- [Los Minified React error #418 en #185 op met de volledige melding en je eigen regel](https://logbrew.co/nl/errors/minified-react-error)
- [AxiosError Network Error oplossen en zien welke van de 3 oorzaken je hebt](https://logbrew.co/nl/errors/axios-network-error)
- [HTTP-fout 499 oplossen en zien wie stopte met wachten](https://logbrew.co/nl/errors/http-499)
- [Fouten die we reproduceerden, en hoe je elke oplost](https://logbrew.co/nl/errors)
