node-qrcode

qr code generator

7,419

615

7,419

View on GitHub View on NPM

Top Related Projects

qrcode-generator

2,117

QR Code Generator implementation in JavaScript, Java and more.

qrcodejs

13,501

Cross-browser QRCode generator for javascript

jsQR

3,671

A pure javascript QR code reading library. This library takes in raw images and will locate, extract and parse any QR code found within.

QR-Code-generator

5,181

High-quality QR Code generator library in Java, TypeScript/JavaScript, Python, Rust, C++, C.

zxing

32,636

ZXing ("Zebra Crossing") barcode scanning library for Java, Android

html5-qrcode

4,880

A cross platform HTML5 QR code reader. See end to end implementation at: https://scanapp.org

Quick Overview

Node-qrcode is a popular QR code generator library for Node.js and browsers. It provides a simple and flexible way to create QR codes in various formats, including terminal output, PNG images, and SVG.

Pros

Easy to use with a straightforward API
Supports multiple output formats (terminal, PNG, SVG)
Works in both Node.js and browser environments
Highly customizable with various styling options

Cons

Limited to QR code generation (no scanning functionality)
Some advanced features may require additional configuration
Documentation could be more comprehensive for complex use cases

Code Examples

Generate a QR code as a data URL:

const QRCode = require('qrcode');

QRCode.toDataURL('https://example.com', (err, url) => {
  if (err) throw err;
  console.log(url);
});

Create a QR code image file:

const QRCode = require('qrcode');

QRCode.toFile('qr.png', 'Some text', {
  color: {
    dark: '#00F',  // Blue dots
    light: '#0000' // Transparent background
  }
}, (err) => {
  if (err) throw err;
  console.log('QR code saved!');
});

Generate a QR code in the terminal:

const QRCode = require('qrcode');

QRCode.toString('I love QR codes!', {type:'terminal'}, (err, string) => {
  if (err) throw err;
  console.log(string);
});

Getting Started

Install the library:
```
npm install qrcode
```

Import and use in your project:

const QRCode = require('qrcode');

// Generate QR code
QRCode.toDataURL('Hello, World!', (err, url) => {
  if (err) throw err;
  console.log(url);
});

For browser usage, include the library in your HTML:

<script src="https://cdn.jsdelivr.net/npm/qrcode@1.5.1/build/qrcode.min.js"></script>

Competitor Comparisons

qrcode-generator

2,117

QR Code Generator implementation in JavaScript, Java and more.

Pros of qrcode-generator

Multi-language support: Implementations available in JavaScript, Java, and other languages
Lightweight and simple to use, with minimal dependencies
Supports various output formats, including SVG and Canvas

Cons of qrcode-generator

Less actively maintained compared to node-qrcode
Fewer advanced features and customization options
Limited documentation and examples

Code Comparison

qrcode-generator:

var qr = qrcode(4, 'L');
qr.addData('Hello, World!');
qr.make();
var imgTag = qr.createImgTag(4);

node-qrcode:

const QRCode = require('qrcode');
QRCode.toDataURL('Hello, World!', function (err, url) {
  console.log(url);
});

Both libraries offer straightforward ways to generate QR codes, but node-qrcode provides a more modern, Promise-based API with additional options for customization and error handling. qrcode-generator's approach is simpler but less flexible.

node-qrcode is generally more suitable for Node.js projects and offers better integration with modern JavaScript ecosystems. qrcode-generator might be preferred for its multi-language support and simplicity in basic use cases.

qrcodejs

13,501

Cross-browser QRCode generator for javascript

Pros of qrcodejs

Pure JavaScript implementation, works directly in the browser without server-side processing
Lightweight and easy to integrate into web projects
Supports various output formats including Canvas, Table, and SVG

Cons of qrcodejs

Less actively maintained compared to node-qrcode
Limited options for error correction and encoding modes
Lacks support for more advanced features like logo embedding

Code Comparison

qrcodejs:

var qrcode = new QRCode("qrcode", {
    text: "http://example.com",
    width: 128,
    height: 128,
    colorDark : "#000000",
    colorLight : "#ffffff",
    correctLevel : QRCode.CorrectLevel.H
});

node-qrcode:

const QRCode = require('qrcode');

QRCode.toDataURL('http://example.com', {
    width: 128,
    margin: 2,
    color: {
        dark: '#000000',
        light: '#ffffff'
    }
}, (err, url) => {
    if (err) throw err;
    console.log(url);
});

Both libraries offer simple ways to generate QR codes, but node-qrcode provides more options and flexibility. qrcodejs is ideal for quick, client-side implementations, while node-qrcode is better suited for server-side generation and more complex use cases.

jsQR

3,671

A pure javascript QR code reading library. This library takes in raw images and will locate, extract and parse any QR code found within.

Pros of jsQR

Pure JavaScript implementation, works in both browser and Node.js environments
Supports QR code detection and decoding from images
Lightweight and has no external dependencies

Cons of jsQR

Limited to QR code reading only, cannot generate QR codes
May have slower performance compared to native implementations
Less actively maintained, with fewer recent updates

Code Comparison

jsQR:

import jsQR from "jsqr";

const code = jsQR(imageData.data, imageData.width, imageData.height);
if (code) {
  console.log("Found QR code", code.data);
}

node-qrcode:

import QRCode from "qrcode";

QRCode.toDataURL("I am a pony!", function (err, url) {
  console.log(url);
});

Key Differences

jsQR focuses on QR code detection and decoding, while node-qrcode primarily generates QR codes
node-qrcode offers more output formats (PNG, SVG, terminal) and customization options
jsQR is more suitable for client-side QR code reading, while node-qrcode is better for server-side QR code generation

Use Cases

Choose jsQR for browser-based QR code scanning applications
Opt for node-qrcode when you need to generate QR codes, especially on the server-side
Consider using both libraries in combination for a full-featured QR code application with both reading and writing capabilities

QR-Code-generator

5,181

High-quality QR Code generator library in Java, TypeScript/JavaScript, Python, Rust, C++, C.

Pros of QR-Code-generator

Multi-language support: Implementations in Java, TypeScript/JavaScript, Python, C++, and C
Extensive documentation and detailed explanations of QR code concepts
Offers both high-level and low-level APIs for fine-grained control

Cons of QR-Code-generator

Less focused on Node.js integration compared to node-qrcode
Fewer built-in output options (e.g., PNG, SVG) without additional processing

Code Comparison

QR-Code-generator (TypeScript):

import * as qr from "qrcodegen";
const qr0 = qr.QrCode.encodeText("Hello, world!", qr.QrCode.Ecc.MEDIUM);
const svg: string = qr0.toSvgString(4);

node-qrcode (JavaScript):

const QRCode = require('qrcode');
QRCode.toDataURL('Hello, world!', function (err, url) {
  console.log(url);
});

Both libraries offer straightforward ways to generate QR codes, but node-qrcode provides a more Node.js-centric approach with built-in output options. QR-Code-generator offers more flexibility across different programming languages and provides lower-level control over the QR code generation process.

zxing

32,636

ZXing ("Zebra Crossing") barcode scanning library for Java, Android

Pros of zxing

Multi-platform support (Java, Android, C++, etc.)
Broader functionality, including barcode generation and scanning
More comprehensive and mature codebase with extensive documentation

Cons of zxing

Larger library size, potentially impacting performance
Steeper learning curve due to its extensive features
Not specifically optimized for Node.js environments

Code Comparison

zxing (Java):

BitMatrix matrix = new MultiFormatWriter().encode(
    "Hello World", BarcodeFormat.QR_CODE, 300, 300);
MatrixToImageWriter.writeToFile(
    matrix, "PNG", new File("qr-code.png"));

node-qrcode (JavaScript):

const QRCode = require('qrcode');
QRCode.toFile('qr-code.png', 'Hello World', {
  width: 300
}, function (err) {
  if (err) throw err;
});

Summary

zxing offers a more comprehensive solution for barcode and QR code handling across multiple platforms, making it suitable for larger projects with diverse requirements. However, its broader scope can lead to increased complexity and resource usage.

node-qrcode, on the other hand, provides a simpler, more focused solution specifically for QR code generation in Node.js environments. It offers easier integration and usage for JavaScript developers but lacks the extensive features and cross-platform support of zxing.

Choose zxing for multi-platform projects requiring extensive barcode functionality, and node-qrcode for simpler QR code generation tasks in Node.js applications.

html5-qrcode

4,880

A cross platform HTML5 QR code reader. See end to end implementation at: https://scanapp.org

Pros of html5-qrcode

Browser-based QR code scanning using HTML5 and JavaScript
Real-time scanning from camera or file input
Supports multiple cameras and has a user-friendly UI

Cons of html5-qrcode

Limited to browser environments, not suitable for server-side use
May have compatibility issues with older browsers
Lacks some advanced QR code generation features

Code Comparison

html5-qrcode:

const html5QrCode = new Html5Qrcode("reader");
html5QrCode.start(
  { facingMode: "environment" },
  { fps: 10, qrbox: 250 },
  qrCodeSuccessCallback,
  qrCodeErrorCallback
);

node-qrcode:

const QRCode = require('qrcode');
QRCode.toDataURL('I am a pony!', function (err, url) {
  console.log(url);
});

Key Differences

html5-qrcode focuses on QR code scanning in browsers, while node-qrcode is primarily for QR code generation
node-qrcode can be used in both server-side and client-side environments
html5-qrcode offers more advanced scanning features, including camera selection and real-time processing
node-qrcode provides more options for QR code generation, including various output formats (PNG, SVG, terminal)

Both libraries serve different primary purposes, with html5-qrcode excelling in QR code scanning and node-qrcode in QR code generation. The choice between them depends on the specific requirements of your project.

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

node-qrcode

QR code/2d barcode generator.

Highlights
Installation
Usage
Error correction level
QR Code capacity
Encoding Modes
Binary data
Multibyte characters
API
GS1 QR Codes
Credits
License

Highlights

Works on server and client (and react native with svg)
CLI utility
Save QR code as image
Support for Numeric, Alphanumeric, Kanji and Byte mode
Support for mixed modes
Support for chinese, cyrillic, greek and japanese characters
Support for multibyte characters (like emojis :smile:)
Auto generates optimized segments for best data compression and smallest QR Code size
App agnostic readability, QR Codes by definition are app agnostic

Installation

Inside your project folder do:

npm install --save qrcode

or, install it globally to use qrcode from the command line to save qrcode images or generate ones you can view in your terminal.

npm install -g qrcode

Usage

CLI

Usage: qrcode [options] <input string>

QR Code options:
  -v, --qversion  QR Code symbol version (1 - 40)                       [number]
  -e, --error     Error correction level           [choices: "L", "M", "Q", "H"]
  -m, --mask      Mask pattern (0 - 7)                                  [number]

Renderer options:
  -t, --type        Output type                  [choices: "png", "svg", "utf8"]
  -w, --width       Image width (px)                                    [number]
  -s, --scale       Scale factor                                        [number]
  -q, --qzone       Quiet zone size                                     [number]
  -l, --lightcolor  Light RGBA hex color
  -d, --darkcolor   Dark RGBA hex color
  --small  Output smaller QR code to terminal                          [boolean]

Options:
  -o, --output  Output file
  -h, --help    Show help                                              [boolean]
  --version     Show version number                                    [boolean]

Examples:
  qrcode "some text"                    Draw in terminal window
  qrcode -o out.png "some text"         Save as png image
  qrcode -d F00 -o out.png "some text"  Use red as foreground color

If not specified, output type is guessed from file extension.
Recognized extensions are png, svg and txt.

Browser

node-qrcode can be used in browser through module bundlers like Browserify and Webpack or by including the precompiled bundle present in build/ folder.

Module bundlers

<!-- index.html -->
<html>
  <body>
    <canvas id="canvas"></canvas>
    <script src="bundle.js"></script>
  </body>
</html>

// index.js -> bundle.js
var QRCode = require('qrcode')
var canvas = document.getElementById('canvas')

QRCode.toCanvas(canvas, 'sample text', function (error) {
  if (error) console.error(error)
  console.log('success!');
})

Precompiled bundle

<canvas id="canvas"></canvas>

<script src="/build/qrcode.js"></script>
<script>
  QRCode.toCanvas(document.getElementById('canvas'), 'sample text', function (error) {
    if (error) console.error(error)
    console.log('success!');
  })
</script>

If you install through npm, precompiled files will be available in node_modules/qrcode/build/ folder.

The precompiled bundle have support for Internet Explorer 10+, Safari 5.1+, and all evergreen browsers.

NodeJS

Require the module qrcode

var QRCode = require('qrcode')

QRCode.toDataURL('I am a pony!', function (err, url) {
  console.log(url)
})

render a qrcode for the terminal

var QRCode = require('qrcode')

QRCode.toString('I am a pony!',{type:'terminal'}, function (err, url) {
  console.log(url)
})

ES6/ES7

Promises and Async/Await can be used in place of callback function.

import QRCode from 'qrcode'

// With promises
QRCode.toDataURL('I am a pony!')
  .then(url => {
    console.log(url)
  })
  .catch(err => {
    console.error(err)
  })

// With async/await
const generateQR = async text => {
  try {
    console.log(await QRCode.toDataURL(text))
  } catch (err) {
    console.error(err)
  }
}

Error correction level

Error correction capability allows to successfully scan a QR Code even if the symbol is dirty or damaged. Four levels are available to choose according to the operating environment.

Higher levels offer a better error resistance but reduce the symbol's capacity.
If the chances that the QR Code symbol may be corrupted are low (for example if it is showed through a monitor) is possible to safely use a low error level such as Low or Medium.

Possible levels are shown below:

Level	Error resistance
L (Low)	~7%
M (Medium)	~15%
Q (Quartile)	~25%
H (High)	~30%

The percentage indicates the maximum amount of damaged surface after which the symbol becomes unreadable.

Error level can be set through options.errorCorrectionLevel property.
If not specified, the default value is M.

QRCode.toDataURL('some text', { errorCorrectionLevel: 'H' }, function (err, url) {
  console.log(url)
})

QR Code capacity

Capacity depends on symbol version and error correction level. Also encoding modes may influence the amount of storable data.

The QR Code versions range from version 1 to version 40.
Each version has a different number of modules (black and white dots), which define the symbol's size. For version 1 they are 21x21, for version 2 25x25 e so on. Higher is the version, more are the storable data, and of course bigger will be the QR Code symbol.

The table below shows the maximum number of storable characters in each encoding mode and for each error correction level.

Mode	L	M	Q	H
Numeric	7089	5596	3993	3057
Alphanumeric	4296	3391	2420	1852
Byte	2953	2331	1663	1273
Kanji	1817	1435	1024	784

Note: Maximum characters number can be different when using Mixed modes.

QR Code version can be set through options.version property.
If no version is specified, the more suitable value will be used. Unless a specific version is required, this option is not needed.

QRCode.toDataURL('some text', { version: 2 }, function (err, url) {
  console.log(url)
})

Encoding modes

Modes can be used to encode a string in a more efficient way.
A mode may be more suitable than others depending on the string content. A list of supported modes are shown in the table below:

Mode	Characters	Compression
Numeric	0, 1, 2, 3, 4, 5, 6, 7, 8, 9	3 characters are represented by 10 bits
Alphanumeric	0â9, AâZ (upper-case only), space, $, %, *, +, -, ., /, :	2 characters are represented by 11 bits
Kanji	Characters from the Shift JIS system based on JIS X 0208	2 kanji are represented by 13 bits
Byte	Characters from the ISO/IEC 8859-1 character set	Each characters are represented by 8 bits

Choose the right mode may be tricky if the input text is unknown.
In these cases Byte mode is the best choice since all characters can be encoded with it. (See Multibyte characters)
However, if the QR Code reader supports mixed modes, using Auto mode may produce better results.

Mixed modes

Mixed modes are also possible. A QR code can be generated from a series of segments having different encoding modes to optimize the data compression.
However, switching from a mode to another has a cost which may lead to a worst result if it's not taken into account. See Manual mode for an example of how to specify segments with different encoding modes.

Auto mode

By default, automatic mode selection is used.
The input string is automatically splitted in various segments optimized to produce the shortest possible bitstream using mixed modes.
This is the preferred way to generate the QR Code.

For example, the string ABCDE12345678?A1A will be splitted in 3 segments with the following modes:

Segment	Mode
ABCDE	Alphanumeric
12345678	Numeric
?A1A	Byte

Any other combinations of segments and modes will result in a longer bitstream.
If you need to keep the QR Code size small, this mode will produce the best results.

Manual mode

If auto mode doesn't work for you or you have specific needs, is also possible to manually specify each segment with the relative mode. In this way no segment optimizations will be applied under the hood.
Segments list can be passed as an array of object:

  var QRCode = require('qrcode')

  var segs = [
    { data: 'ABCDEFG', mode: 'alphanumeric' },
    { data: '0123456', mode: 'numeric' }
  ]

  QRCode.toDataURL(segs, function (err, url) {
    console.log(url)
  })

Kanji mode

With kanji mode is possible to encode characters from the Shift JIS system in an optimized way.
Unfortunately, there isn't a way to calculate a Shifted JIS values from, for example, a character encoded in UTF-8, for this reason a conversion table from the input characters to the SJIS values is needed.
This table is not included by default in the bundle to keep the size as small as possible.

If your application requires kanji support, you will need to pass a function that will take care of converting the input characters to appropriate values.

An helper method is provided by the lib through an optional file that you can include as shown in the example below.

Note: Support for Kanji mode is only needed if you want to benefit of the data compression, otherwise is still possible to encode kanji using Byte mode (See Multibyte characters).

  var QRCode = require('qrcode')
  var toSJIS = require('qrcode/helper/to-sjis')

  QRCode.toDataURL(kanjiString, { toSJISFunc: toSJIS }, function (err, url) {
    console.log(url)
  })

With precompiled bundle:

<canvas id="canvas"></canvas>

<script src="/build/qrcode.min.js"></script>
<script src="/build/qrcode.tosjis.min.js"></script>
<script>
  QRCode.toCanvas(document.getElementById('canvas'),
    'sample text', { toSJISFunc: QRCode.toSJIS }, function (error) {
    if (error) console.error(error)
    console.log('success!')
  })
</script>

Binary data

QR Codes can hold arbitrary byte-based binary data. If you attempt to create a binary QR Code by first converting the data to a JavaScript string, it will fail to encode propery because string encoding adds additional bytes. Instead, you must pass a Uint8ClampedArray or compatible array, or a Node Buffer, as follows:

// Regular array example
// WARNING: Element values will be clamped to 0-255 even if your data contains higher values.
const QRCode = require('qrcode')
QRCode.toFile(
  'foo.png',
  [{ data: [253,254,255], mode: 'byte' }],
  ...options...,
  ...callback...
)

// Uint8ClampedArray example
const QRCode = require('qrcode')

QRCode.toFile(
  'foo.png',
  [{ data: new Uint8ClampedArray([253,254,255]), mode: 'byte' }],
  ...options...,
  ...callback...
)

// Node Buffer example
// WARNING: Element values will be clamped to 0-255 even if your data contains higher values.
const QRCode = require('qrcode')

QRCode.toFile(
  'foo.png',
  [{ data: Buffer.from([253,254,255]), mode: 'byte' }],
  ...options...,
  ...callback...
)

TypeScript users: if you are using @types/qrcode, you will need to add a // @ts-ignore above the data segment because it expects data: string.

Multibyte characters

Support for multibyte characters isn't present in the initial QR Code standard, but is possible to encode UTF-8 characters in Byte mode.

QR Codes provide a way to specify a different type of character set through ECI (Extended Channel Interpretation), but it's not fully implemented in this lib yet.

Most QR Code readers, however, are able to recognize multibyte characters even without ECI.

Note that a single Kanji/Kana or Emoji can take up to 4 bytes.

API

Browser:

create()
toCanvas()
toDataURL()
toString()

Server:

create()
toCanvas()
toDataURL()
toString()
toFile()
toFileStream()

Browser API

`create(text, [options])`

Creates QR Code symbol and returns a qrcode object.

`text`

Type: String|Array

Text to encode or a list of objects describing segments.

`options`

See QR Code options.

`returns`

Type: Object

// QRCode object
{
  modules,              // Bitmatrix class with modules data
  version,              // Calculated QR Code version
  errorCorrectionLevel, // Error Correction Level
  maskPattern,          // Calculated Mask pattern
  segments              // Generated segments
}

`toCanvas(canvasElement, text, [options], [cb(error)])`

`toCanvas(text, [options], [cb(error, canvas)])`

Draws qr code symbol to canvas.
If canvasElement is omitted a new canvas is returned.

`canvasElement`

Type: DOMElement

Canvas where to draw QR Code.

`text`

Type: String|Array

Text to encode or a list of objects describing segments.

`options`

See Options.

`cb`

Type: Function

Callback function called on finish.

Example

QRCode.toCanvas('text', { errorCorrectionLevel: 'H' }, function (err, canvas) {
  if (err) throw err

  var container = document.getElementById('container')
  container.appendChild(canvas)
})

`toDataURL(text, [options], [cb(error, url)])`

`toDataURL(canvasElement, text, [options], [cb(error, url)])`

Returns a Data URI containing a representation of the QR Code image.
If provided, canvasElement will be used as canvas to generate the data URI.

`canvasElement`

Type: DOMElement

Canvas where to draw QR Code.

`text`

Type: String|Array

Text to encode or a list of objects describing segments.

`options`

type

Type: String
Default: image/png

Data URI format.
Possible values are: image/png, image/jpeg, image/webp.
rendererOpts.quality

Type: Number
Default: 0.92

A Number between 0 and 1 indicating image quality if the requested type is image/jpeg or image/webp.

See Options for other settings.

`cb`

Type: Function

Callback function called on finish.

Example

var opts = {
  errorCorrectionLevel: 'H',
  type: 'image/jpeg',
  quality: 0.3,
  margin: 1,
  color: {
    dark:"#010599FF",
    light:"#FFBF60FF"
  }
}

QRCode.toDataURL('text', opts, function (err, url) {
  if (err) throw err

  var img = document.getElementById('image')
  img.src = url
})

`toString(text, [options], [cb(error, string)])`

Returns a string representation of the QR Code.

`text`

Type: String|Array

Text to encode or a list of objects describing segments.

`options`

type

Type: String
Default: utf8

Output format.
Possible values are: terminal,utf8, and svg.

See Options for other settings.

`cb`

Type: Function

Callback function called on finish.

Example

QRCode.toString('http://www.google.com', function (err, string) {
  if (err) throw err
  console.log(string)
})

Server API

`create(text, [options])`

See create.

`toCanvas(canvas, text, [options], [cb(error)])`

Draws qr code symbol to node canvas.

`text`

Type: String|Array

Text to encode or a list of objects describing segments.

`options`

See Options.

`cb`

Type: Function

Callback function called on finish.

`toDataURL(text, [options], [cb(error, url)])`

Returns a Data URI containing a representation of the QR Code image.
Only works with image/png type for now.

`text`

Type: String|Array

Text to encode or a list of objects describing segments.

`options`

See Options for other settings.

`cb`

Type: Function

Callback function called on finish.

`toString(text, [options], [cb(error, string)])`

Returns a string representation of the QR Code.
If choosen output format is svg it will returns a string containing xml code.

`text`

Type: String|Array

Text to encode or a list of objects describing segments.

`options`

type

Type: String
Default: utf8

Output format.
Possible values are: utf8, svg, terminal.

See Options for other settings.

`cb`

Type: Function

Callback function called on finish.

Example

QRCode.toString('http://www.google.com', function (err, string) {
  if (err) throw err
  console.log(string)
})

`toFile(path, text, [options], [cb(error)])`

Saves QR Code to image file.
If options.type is not specified, the format will be guessed from file extension.
Recognized extensions are png, svg, txt.

`path`

Type: String

Path where to save the file.

`text`

Type: String|Array

Text to encode or a list of objects describing segments.

`options`

type

Type: String
Default: png

Output format.
Possible values are: png, svg, utf8.
rendererOpts.deflateLevel (png only)

Type: Number
Default: 9

Compression level for deflate.
rendererOpts.deflateStrategy (png only)

Type: Number
Default: 3

Compression strategy for deflate.

See Options for other settings.

`cb`

Type: Function

Callback function called on finish.

Example

QRCode.toFile('path/to/filename.png', 'Some text', {
  color: {
    dark: '#00F',  // Blue dots
    light: '#0000' // Transparent background
  }
}, function (err) {
  if (err) throw err
  console.log('done')
})

`toFileStream(stream, text, [options])`

Writes QR Code image to stream. Only works with png format for now.

`stream`

Type: stream.Writable

Node stream.

`text`

Type: String|Array

Text to encode or a list of objects describing segments.

`options`

See Options.

Options

QR Code options

`version`

Type: Number

QR Code version. If not specified the more suitable value will be calculated.

`errorCorrectionLevel`

Type: String
Default: M

Error correction level.
Possible values are low, medium, quartile, high or L, M, Q, H.

`maskPattern`

Type: Number

Mask pattern used to mask the symbol.
Possible values are 0, 1, 2, 3, 4, 5, 6, 7.
If not specified the more suitable value will be calculated.

`toSJISFunc`

Type: Function

Helper function used internally to convert a kanji to its Shift JIS value.
Provide this function if you need support for Kanji mode.

Renderers options

`margin`

Type: Number
Default: 4

Define how much wide the quiet zone should be.

`scale`

Type: Number
Default: 4

Scale factor. A value of 1 means 1px per modules (black dots).

`small`

Type: Boolean
Default: false

Relevant only for terminal renderer. Outputs smaller QR code.

`width`

Type: Number

Forces a specific width for the output image.
If width is too small to contain the qr symbol, this option will be ignored.
Takes precedence over scale.

`color.dark`

Type: String
Default: #000000ff

Color of dark module. Value must be in hex format (RGBA).
Note: dark color should always be darker than color.light.

`color.light`

Type: String
Default: #ffffffff

Color of light module. Value must be in hex format (RGBA).

GS1 QR Codes

There was a real good discussion here about them. but in short any qrcode generator will make gs1 compatible qrcodes, but what defines a gs1 qrcode is a header with metadata that describes your gs1 information.

https://github.com/soldair/node-qrcode/issues/45

Credits

This lib is based on "QRCode for JavaScript" which Kazuhiko Arase thankfully MIT licensed.

License

MIT

The word "QR Code" is registered trademark of:
DENSO WAVE INCORPORATED

Top Related Projects

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

Top Related Projects

Quick Overview

Pros

Cons

Code Examples

Getting Started

Competitor Comparisons

Pros of qrcode-generator

Cons of qrcode-generator

Code Comparison

Pros of qrcodejs

Cons of qrcodejs

Code Comparison

Pros of jsQR

Cons of jsQR

Code Comparison

Key Differences

Use Cases

Pros of QR-Code-generator

Cons of QR-Code-generator

Code Comparison

Pros of zxing

Cons of zxing

Code Comparison

Summary

Pros of html5-qrcode

Cons of html5-qrcode

Code Comparison

Key Differences

Convert designs to code with AI

README

node-qrcode

Highlights

Installation

Usage

CLI

Browser

Module bundlers

Precompiled bundle

NodeJS

ES6/ES7

Error correction level

QR Code capacity

Encoding modes

Mixed modes

Auto mode

Manual mode

Kanji mode

Binary data

Multibyte characters

API

Browser API

create(text, [options])

text

options

returns

toCanvas(canvasElement, text, [options], [cb(error)])

toCanvas(text, [options], [cb(error, canvas)])

canvasElement

text

options

cb

Example

toDataURL(text, [options], [cb(error, url)])

toDataURL(canvasElement, text, [options], [cb(error, url)])

canvasElement

text

options

type

rendererOpts.quality

cb

Example

toString(text, [options], [cb(error, string)])

text

options

type

cb

Example

Server API

create(text, [options])

`create(text, [options])`

`text`

`options`

`returns`

`toCanvas(canvasElement, text, [options], [cb(error)])`

`toCanvas(text, [options], [cb(error, canvas)])`

`canvasElement`

`text`

`options`

`cb`

`toDataURL(text, [options], [cb(error, url)])`

`toDataURL(canvasElement, text, [options], [cb(error, url)])`

`canvasElement`

`text`

`options`

`type`

`rendererOpts.quality`

`cb`

`toString(text, [options], [cb(error, string)])`

`text`

`options`

`type`

`cb`

`create(text, [options])`

`toCanvas(canvas, text, [options], [cb(error)])`

`text`

`options`

`cb`

`toDataURL(text, [options], [cb(error, url)])`

`text`

`options`

`cb`

`toString(text, [options], [cb(error, string)])`

`text`

`options`

`type`

`cb`

`toFile(path, text, [options], [cb(error)])`

`path`

`text`

`options`

`type`

`rendererOpts.deflateLevel` (png only)

`rendererOpts.deflateStrategy` (png only)

`cb`

`toFileStream(stream, text, [options])`

`stream`

`text`

`options`

`version`

`errorCorrectionLevel`

`maskPattern`

`toSJISFunc`

`margin`

`scale`

`small`

`width`

`color.dark`

`color.light`