The exifr npm package is a powerful tool for extracting EXIF (Exchangeable Image File Format) data from images. It supports a wide range of image formats and can extract various types of metadata, including GPS information, camera settings, and more.
Extract Basic EXIF Data
This feature allows you to extract basic EXIF data from an image. The code sample demonstrates how to use the `exifr.parse` method to read EXIF data from a specified image file.
const exifr = require('exifr');
async function getBasicExifData(imagePath) {
const exifData = await exifr.parse(imagePath);
console.log(exifData);
}
getBasicExifData('path/to/image.jpg');Extract GPS Data
This feature allows you to extract GPS data from an image. The code sample demonstrates how to use the `exifr.gps` method to read GPS metadata from a specified image file.
const exifr = require('exifr');
async function getGpsData(imagePath) {
const gpsData = await exifr.gps(imagePath);
console.log(gpsData);
}
getGpsData('path/to/image.jpg');Extract Thumbnail
This feature allows you to extract the thumbnail image embedded in the EXIF data. The code sample demonstrates how to use the `exifr.thumbnail` method to read the thumbnail from a specified image file.
const exifr = require('exifr');
async function getThumbnail(imagePath) {
const thumbnail = await exifr.thumbnail(imagePath);
console.log(thumbnail);
}
getThumbnail('path/to/image.jpg');The exif-parser package is another tool for extracting EXIF data from images. It is known for its performance and simplicity. Compared to exifr, exif-parser is more lightweight but may not support as many features or image formats.
The piexifjs package allows for both reading and writing EXIF data in JPEG images. It is a versatile tool for manipulating EXIF metadata. Compared to exifr, piexifjs offers more functionality for modifying EXIF data but may be more complex to use.
The jpeg-js package is a pure JavaScript implementation for decoding and encoding JPEG images. While it is not specifically focused on EXIF data, it can be used in conjunction with other tools to handle image metadata. Compared to exifr, jpeg-js is more general-purpose and not specialized in EXIF extraction.
📑 The fastest and most versatile JavaScript EXIF reading library.
Try it yourself - demo page.
npm install exifr
also availabe as UMD bundle transpiled for ES5
https://unpkg.com/exifr
Works everywhere and accepts pretty much everything you throw at it.
ArrayBuffer, Uint8Array, DataView, <img> elements, string URL and paths, Object URL, Base64 URLimport, require() or <script> it in your .mjs, .js or .html file.ESM in Node.js
import * as exifr from 'exifr'
// exifr handles disk reading. Only reads a few hundred bytes.
exifr.parse('./myimage.jpg')
.then(exif => console.log('Camera:', exif.Make, exif.Model))
.catch(console.error)
CJS in Node.js
let exifr = require('exifr')
let fs = require('fs').promises
// Or read the file on your own and feed the buffer into exifr.
fs.readFile('./myimage.jpg')
.then(exifr.parse)
.then(exif => console.log('lat lon', exif.latitude, exif.longitude))
.catch(console.error)
UMD in Browser
<img src="./myimage.jpg">
<script src="./node_modules/exifr/index.js"></script>
<script>
// UMD module exposed on global window.exifr object
exifr.parse(document.querySelector('img'))
.then(exif => console.log('Exposure:', exif.ExposureTime))
</script>
ESM in Browser
<input id="filepicker" type="file" multiple>
<script type="module">
import {parse} from './node_modules/exifr/index.js'
document.querySelector('#filepicker').addEventListener('change', async e => {
let files = Array.from(e.target.files)
let promises = files.map(parse)
let exifs = await Promise.all(promises)
let dates = exifs.map(exif => exif.DateTimeOriginal.toGMTString())
console.log(`${files.length} photos taken on:`, dates)
})
</script>
Extracting thumbnail
let img = document.querySelector("#thumb")
document.querySelector('input[type="file"]').addEventListener('change', async e => {
let file = e.target.files[0]
img.src = await exifr.thumbnailUrl(file)
})
let thumbBuffer = await exifr.thumbnailBuffer(imageBuffer)
Usage in WebWorker
let worker = new Worker('./worker.js')
worker.postMessage('../test/IMG_20180725_163423.jpg')
worker.onmessage = e => console.log(e.data)
// worker.js
importScripts('./node_modules/exifr/index.js')
let exifr = self.exifr // UMD
self.onmessage = async e => postMessage(await exifr.parse(e.data))
exifr exports parse, thumbnailBuffer, thumbnailUrl functions and ExifParser class
parse(input[, options]) => Promise<object>Accepts any input argument, parses it and returns exif object.
thumbnailBuffer(input) => Promise<Buffer|ArrayBuffer>Extracts embedded thumbnail from the photo and returns it as a Buffer (Node.JS) or an ArrayBuffer (browser).
Only parses as little EXIF as necessary to find offset of the thumbnail.
thumbnailUrl(input) => Promise<string>Browser only - exports the thumbnail wrapped in Object URL.
User is expected to revoke the URL when not needed anymore.
ExifParser classAfore mentioned functions are wrappers that internally instantiate new ExifParse(options) class, then call parser.read(input), and finally call either parser.parse() or parser.extractThumbnail().
To do both parsing EXIF and extracting thumbnail efficiently you can use this class yourself.
let parser = new ExifParser(options)
let exif = await parser.read(input)
let thumb = await parser.extractThumbnail()
inputcan be:
string file pathstring URLstring Base64string Object URL / Blob URLBufferArrayBufferUint8ArrayDataViewFileBlob<img> elementoptionsis optional argument and can be either:
object with granular settingsboolean shortcut to enable parsing all segments and blocksparseChunkSize
In browser it's sometimes better to download larger chunk in hope that it contains the whole EXIF (and not just its beginning like in case of seekChunkSize) in prevention of additional loading and fetching.
Supports HTTP ranges.
If you're not concerned about performance and time (mostly in Node.js) you can tell exifr to just read the whole file into memory at once.`
options.wholeFile bool/undefined default undefined
Sets whether to read the file as a whole or just by small chunks.
Used when file path or url to the image is given.
true - whole file mode
undefined - chunked mode, default value
seekChunkSize) and allows reading/fetching additional chunks.
false - chunked mode
parseChunkSize) in hopes that the EXIF isn't larger then the chunk.
options.seekChunkSize number default: 512 Bytes (0.5 KB)
Byte size of the first chunk that will be read and parsed for EXIF.
EXIF is usually within the first few bytes of the file. If not than there likely is no EXIF. It's not necessary to read through the whole file.
Node.js: Used for all input types.
Browser: Used when input arg is buffer. Otherwise, parseChunkSize is used.
options.parseChunkSize number default: 64 * 1024 (64KB)
Size of the chunk to fetch in the browser in chunked mode.
Much like seekChunkSize but used in the browser (and only if we're given URL) where subsequent chunk fetching is more expensive than fetching one larger chunk with hope that it contains the EXIF.
Node.js: Not used.
Browser: Used when input arg is string URL. Otherwise, seekChunkSize is used.
If parsing file known to have EXIF fails try:
seekChunkSizeparseChunkSize in the browser if file URL is used as input.options.tiff: true - APP1 - TIFF
options.exif: true - Sub Exif.options.gps: true - GPS latitue and longitude data.options.thumbnail: false - Size and other information about embedded thumbnail.options.interop: false - This is a thing too.options.xmp: false - APP1 - XMP
options.icc: false - APP2 - ICCoptions.iptc: false - APP13 - IPTC
options.postProcess number default: true
Translate enum values to strings, convert dates to Date instances, etc...
options.mergeOutput number default: true
Changes output format by merging all segments and blocks into a single object.
As you've already read, this lib was built to be fast. Fast enough to handle whole galleries.
We're able to parse image within a couple of milliseconds (tens of millis on phones) thanks to selective disk reads (Node.js) and Blob / ArrayBuffer (Browser) manipulations. Because you don't need to read the whole file and parse through a MBs of data if we an educated guess can be made to only read a couple of small chunks where EXIF usually is. Plus each supported data type is approached differently to ensure the best performance.
Observations from testing with +-4MB pictures (Highest quality, highest resolution Google Pixel photos, tested on a decade old quad core CPU). Note: These are no scientific measurements.
The library is already production ready and battle-tested, but there's always room for improvement
Probably as an additional opt-in extension file to keep the core as light as possible.
MIT, Mike Kovařík, Mutiny.cz
[2.0.0] - 2019-07-05
getExif() function. It's available as named export parse()along few new ones.*.tif and *.tiff file support (raw TIFF segments not wrapped in jpg APPn segments)FAQs
📷 The fastest and most versatile JavaScript EXIF reading library.
The npm package exifr receives a total of 118,617 weekly downloads. As such, exifr popularity was classified as popular.
We found that exifr demonstrated a not healthy version release cadence and project activity because the last version was released a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
Node.js will be enforcing stricter semver-major PR policies a month before major releases to enhance stability and ensure reliable release candidates.
Security News
Research
Socket's threat research team has detected five malicious npm packages targeting Roblox developers, deploying malware to steal credentials and personal data.
Security News
vlt introduced its new package manager and a serverless registry this week, innovating in a space where npm has stagnated.