Installation

npm install -g javascript-obfuscator

Exemples

# Basic usage (standard obfuscation)
javascript-obfuscator input.js --output output.js

# VM obfuscation (requires Pro API token)
javascript-obfuscator input.js --output output.js \
  --pro-api-token=<YOUR_PRO_API_TOKEN> \
  --vm-obfuscation=true \
  --options-preset=vm-medium-obfuscation  

# VM obfuscation with a specific version (requires Pro API token)
javascript-obfuscator input.js --output output.js \
  --pro-api-token=<YOUR_PRO_API_TOKEN> \
  --pro-api-version=5.0.3 \
  --vm-obfuscation=true \
  --vm-bytecode-format=binary
  
# Obfuscation with Parse HTML option (requires Pro API token)
javascript-obfuscator input.js --output output.js \
  --pro-api-token=<YOUR_PRO_API_TOKEN> \
  --parse-html=true \
  --compact=true \
  --control-flow-flattening=true \
  --dead-code-injection=true \
  --string-array=true

# Standard obfuscation (no token needed)
javascript-obfuscator input.js --output output.js \
  --compact=true \
  --control-flow-flattening=true \
  --dead-code-injection=true \
  --string-array=true

Consultez la documentation de la CLI pour toutes les options disponibles.

const JavaScriptObfuscator = require('javascript-obfuscator');

const code = `
function calculateSecret(x, y) {
    return x * y + 42;
}
`;

// VM obfuscation (requires Pro API token)
const vmResult = await JavaScriptObfuscator.obfuscatePro(
    code,
    {
        vmObfuscation: true,
        vmBytecodeFormat: 'binary',
        compact: true
    },
    {
        apiToken: process.env.OBFUSCATOR_API_TOKEN,
        // version: '5.0.3',  // optional: specify version
        // timeout: 300000    // optional: timeout in ms (default: 5 min)
    },
    (message) => console.log('Progress:', message)  // optional: progress callback
);


// Obfuscation with Parse HTML option (requires Pro API token)
const htmlResult = await JavaScriptObfuscator.obfuscatePro(
    code,
    {
        parseHtml: true,
        compact: true,
        controlFlowFlattening: true,
        deadCodeInjection: true,
        stringArray: true
    },
    {
        apiToken: process.env.OBFUSCATOR_API_TOKEN
    },
    (message) => console.log('Progress:', message)  // optional: progress callback
);

console.log(htmlResult.getObfuscatedCode());

// Standard obfuscation (no token needed)
const standardResult = JavaScriptObfuscator.obfuscate(code, {
    compact: true,
    controlFlowFlattening: true,
    deadCodeInjection: true,
    stringArray: true
});

console.log(standardResult.getObfuscatedCode());

Consultez la documentation de l'API pour toutes les options disponibles.

code obligatoire - code JavaScript à obfusquer

options - objet contenant les options d'obfuscation

Au moins une fonctionnalité Pro est requise : vmObfuscation: true ou parseHtml: true

Options disponibles : compact, controlFlowFlattening, deadCodeInjection, stringArray, sourceMap, et bien d'autres.

Consultez la section Référence des options pour la liste complète des options disponibles.

La réponse est transmise en flux au format JSON délimité par des sauts de ligne (NDJSON). Chaque ligne est un objet JSON doté d'un champ type :

progress - mises à jour d'état pendant le traitement

result - résultat final pour les sorties de petite taille (<1 MB)

chunk - données partielles pour les sorties volumineuses (fragments de 1 MB)

chunk_end - indique que tous les fragments ont été envoyés

error - message d'erreur en cas d'échec du traitement

Réponse d'erreur

{"type": "error", "message": "Error description"}

Exemple rapide d'obfuscation de code via l'API avec cURL.

curl -X POST https://obfuscator.io/api/v1/obfuscate \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OBFUSCATOR_API_TOKEN" \
  -d '{
    "code": "function test() { return 42; }",
    "options": { "vmObfuscation": true, "compact": true }
  }'

Exemple complet avec streaming et réassemblage des fragments.

// Optional: specify version via query parameter (default: latest)
const response = await fetch("https://obfuscator.io/api/v1/obfuscate?version=7.8.0", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "Authorization": "Bearer YOUR_API_TOKEN"
  },
  body: JSON.stringify({
    code: yourCode,
    options: { vmObfuscation: true, compact: true }
  })
});

const reader = response.body.getReader();
const decoder = new TextDecoder();

// Buffers for reassembling chunked responses
const codeChunks = [];
const sourceMapChunks = [];
let result = { code: '', sourceMap: '' };

while (true) {
  const { done, value } = await reader.read();
  if (done) break;

  const lines = decoder.decode(value).split('\n');
  for (const line of lines) {
    if (!line) continue;
    const msg = JSON.parse(line);

    switch (msg.type) {
      case 'progress':
        console.log(msg.message);
        break;
      case 'chunk':
        // Large results are sent in 1MB chunks
        if (msg.field === 'code') codeChunks[msg.index] = msg.data;
        if (msg.field === 'sourceMap') sourceMapChunks[msg.index] = msg.data;
        break;
      case 'chunk_end':
        result.code = codeChunks.join('');
        result.sourceMap = sourceMapChunks.join('') || msg.sourceMap || '';
        break;
      case 'result':
        result = { code: msg.code, sourceMap: msg.sourceMap || '' };
        break;
      case 'error':
        throw new Error(msg.message);
    }
  }
}
console.log('Done:', result.code);

Limite de débit : 30 requêtes par minute

Taille de fichier maximale (API REST) : 4 MB (Pro), 7 MB (Team), 10 MB (Business). Les corps de requête dépassant 4.4 MB doivent passer par le point de terminaison de téléversement (Team/Business uniquement).

Taille de sortie maximale : illimitée (transmise en flux par fragments)

Quota mensuel : selon votre forfait d'abonnement

HTTP 429 : limite de débit ou quota dépassé. HTTP 413 : entrée trop volumineuse.

400 - requête incorrecte (JSON invalide, code manquant)

401 - non authentifié (clé d'API invalide ou absente)

403 - interdit (accès à l'API non inclus dans le forfait)

413 - charge utile trop volumineuse (dépasse la limite du forfait)

429 - trop de requêtes ou quota dépassé

500 - erreur interne du serveur