HEIC to JPG Converter

You shot a weekend's worth of photos on your iPhone, moved them onto a computer or shared them somewhere useful, and landed on a folder of gray placeholders. Files ending in .heic. Your client's Windows laptop wants nothing to do with them. The slideshow software at the venue chokes. The print shop's uploader politely refuses. That's the wall, and you've just hit it. The converter at the top of this page is the ladder: drop HEIC files in, get plain JPGs out, and carry on with your day.

It runs entirely in your browser. There is no upload queue, no watermark stamped across the corner, no 'upgrade to convert more than 3 files' screen. You can convert one photo or a batch of two hundred — the work happens on your own machine, in the tab you're reading right now, and the files never touch a server.

This article is the long version. What HEIC actually is, why Apple bet on it, what happens inside the file when it becomes a JPG, which quality setting to pick, and where the conversion surprises people. I've spent enough evenings rescuing client photos from HEIC purgatory to have opinions on all of it.

HEIC stands for High Efficiency Image Container — a box for images compressed with HEVC, the same family of coding that powers modern video. It's built on the HEIF standard (ISO/IEC 23008-12), and the payoff is efficiency: a HEIC file holds roughly the same picture quality as a JPEG at about half the size.

Apple made it the default camera format in September 2017 with iOS 11. That single switch quietly changed the shape of every iPhone photo library since. A current 12-megapixel iPhone shot is 4032×3024 pixels — about 12.2 million of them — and HEIC keeps that at roughly 1.5 to 2 MB where a full-quality JPEG wants 3.5 to 4 MB. Multiply the difference across a thousand photos and the reasoning writes itself: half the storage, same picture.

There's a catch, and you already know it. Efficiency isn't compatibility. JPEG dates to 1992, and three decades of software can open it — every printer kiosk, every decade-old laptop, every government form uploader. HEIC is natively readable on Apple devices, on newer Android flagships, and inside Safari. Chrome and Firefox? Still no. Windows needs codec extensions from the Store, and those installs have a habit of demanding updates or a dollar at the worst moment. So the most modern format in your pocket is, functionally, the least welcome one everywhere else.

JPEG — technically ISO/IEC 10918-1, published by the ITU as recommendation T.81 — compresses each 8×8 pixel block with a discrete cosine transform and discards detail your eye is least likely to miss. It's lossy. It's old enough to run for president. And it remains the one format you can hand to any person, on any device, with zero questions asked.

• Print shops and photo labs, whose front counters still run on JPG-only intake
• Government, school, and job application portals with hard format whitelists
• Older Windows machines without codec packs, which is most of them
• Email attachments going to a mixed list of recipients
• Real-estate MLS portals that reject HEIC on sight
• Conference-room laptops, digital photo frames, projectors, and pharmacy kiosks

That's the entire case for this converter. HEIC is the better archive; JPEG is the better handshake. You keep the efficient file in your library and mint the universal one whenever someone else needs to open it. The split also explains why converters like this one feel less like an anachronism every year and more like a border checkpoint between two territories that aren't merging anytime soon — Apple has doubled down on HEIC for storage reasons, while the receiving end of the world upgrades at the speed of government procurement, which is to say glacially.

People use HEIC and HEIF almost interchangeably, and the sloppiness is forgivable because the relationship is confusing on purpose. HEIF is the standard — High Efficiency Image Format, ISO/IEC 23008-12 — that defines how images and sequences are stored in a container. HEIC is a specific flavor of that container that stores images coded with HEVC. There's also HEIFS for sequences, and a cousin that uses AVC (H.264) compression instead of HEVC, which some cameras emit.

In practice: Apple writes .heic files, Samsung cameras write .heic or .heif depending on model and mode, and a handful of drones and mirrorless cameras write .heif or .hif. This tool reads the container rather than trusting the extension, which matters more than you'd think — I've seen mislabeled files from a Galaxy S21 that parsed perfectly once the decoder stopped trusting the three letters after the dot. If a file genuinely isn't HEIF inside, you'll get a clear error rather than a mangled image, which is the honest behavior.

1. 1

   Drop your files

   Drag HEIC or HEIF files anywhere onto the tool, or click the file picker and multi-select. Whole-folder selections work in one pass — the tool takes as many files as your browser can hold in memory.

2. 2

   Pick a quality level

   Quality 85 is the default and the right call for sharing. Slide up to 95 for print or archive copies, down to 75 for quick previews. The readout updates per file so you can watch the size trade in real time.

3. 3

   Set a maximum dimension if you need one

   Delivery galleries, email batches, and web uploads rarely need 4032 pixels on the long edge. Capping output at 2048 or 1600 pixels cuts file size dramatically with no visible loss on screen.

4. 4

   Watch the progress

   Each file decodes and re-encodes locally. A 12-megapixel HEIC takes a second or two per image on a typical laptop; you get per-file progress, not a mystery spinner.

5. 5

   Download what you need

   Grab files individually or take the whole batch as a ZIP. Originals are never touched — the tool writes new JPGs and leaves your HEICs exactly where they were.

6. 6

   Sanity-check the first file

   Open the first JPG before sending anything to a client. Nine times out of ten it's perfect; the tenth time you'll catch a color-profile surprise worth fixing before delivery, not after the complaints.

Browsers can't decode HEIC on their own — Safari is the notable exception, since Apple ships the decoder with the operating system. So this tool loads libheif, the open-source HEIF library, compiled to WebAssembly: the same C++ code that powers native HEIF support in desktop applications, running sandboxed inside your tab. It parses the container, pulls out the image item, decodes the HEVC-compressed data, and produces raw pixels.

From there it's the classic browser pipeline. The pixels are drawn to an HTML canvas — the same drawing surface games and design tools use — and the canvas re-encodes them as JPEG at your chosen quality. In one end goes a container most software can't read; out the other end comes the most readable image format on Earth. No server, no queue, no copy of your photos living on someone else's disk.

One detail worth knowing before you rely on it: canvas re-encoding writes the image from scratch, which means the EXIF block — camera model, timestamps, and GPS coordinates if your phone recorded them — does not survive the trip. For delivery files that's usually what you want anyway. If a workflow of yours depends on embedded metadata, test one file first and plan accordingly.

• Parse — libheif reads the HEIF container structure and locates the image item
• Decode — the HEVC-coded data is decompressed into raw RGB pixel data
• Draw — pixels land on a canvas at full resolution, honoring the rotation flag
• Encode — the canvas serializes to JPEG at your chosen quality in one pass

Numbers from actual jobs, rounded the way a working photographer would round them. Your files will vary with scene content — detailed scenes compress worse than skies — but the ratios hold.

Full resolution nearly doubles the size — that's the cost of JPEG's older compression. If the photo is headed for email or an online gallery, cap the long edge at 2048 pixels and the same image lands at just over 2 MB, which every inbox on the list will tolerate.

The size cap changed the deliverable entirely. At full size this batch needed a file-transfer service and a patient client; at 2048 pixels it uploaded to the venue's proofing gallery in one pass and nobody noticed the difference on a screen. Same photos, one decision, six times smaller.

Quality 95 pushes file sizes up sharply — the JPEG curve bends hardest above 90 — but when a lab prints your work, a few extra megabytes are cheaper than re-shooting. The rule of thumb I use: 85 for screens, 95 for paper, and nothing in between worth agonizing over.

Google's WebP compression study measured WebP at 25–35% smaller than JPEG at matched quality, which is why it's the default for web delivery pipelines. But you can't email a WebP to a print lab and expect a smile, and half the software in an office still can't open it. When the destination is another person rather than your own server, JPEG wins.

If you're optimizing images for a site you control, pair this converter with a dedicated image compressor — same browser, same privacy story, purpose-built for squeezing every last kilobyte out of the files you just converted.

JPEG quality runs on a 0–100 scale, and the useful range is narrower than the slider suggests. Around 75 sits the famous knee — the point where quality loss starts becoming visible and size savings start flattening at the same time. Below 60 you'll see blocking on smooth areas like skies and skin. Above 90, sizes balloon for gains nobody can see on any screen ever made. The slider goes to 100 anyway, the way pizza menus sell a 20-inch pie: somebody will order it, and it exists, and that's about all you can say for it.

• Quality 75 — thumbnails, previews, proof sheets, anything disposable
• Quality 85 — the delivery default; artifacts invisible at viewing size
• Quality 95 — print and archive; overkill for screens but correct for paper
• Quality 100 — technically allowed, practically pointless; size approaches uncompressed with no visible gain

Every photo an iPhone takes can carry an EXIF block — Exchangeable Image File Format metadata riding in the file header. It records the camera model, the lens, exposure settings, the date and time, and, when Location Services allows, GPS coordinates precise enough to point at a front door. HEIC files carry this payload exactly like JPEGs do.

Now consider what a typical online converter asks you to do: upload those files to a stranger's server, wait, download the results. You've just transmitted your home address, your kid's school, and the layout of your living room to a machine with unknown retention rules. In the EU, photographs of identifiable people or places count as personal data under GDPR — handing them to a processing service without a lawful basis is precisely the kind of thing regulators care about.

This tool never sees your files. Decoding happens in your tab, and closing the tab erases everything. That's not a privacy-policy promise — it's the physics of the architecture. Incidentally, because the re-encode writes a clean JPEG, the converted files you share come out metadata-free by default, which is the safer default for anything leaving your custody.

Nine conversions out of ten are boring, which is the goal. The tenth is usually one of these five situations:

• Samsung HEICs — Galaxy phones that save HEIF use the same extension but sometimes pack depth-map or HDR auxiliary data that trips simpler decoders. If one Samsung file fails while Apple files sail through, re-export it from the Samsung gallery app as JPG and move on; libheif handles most variants, and newer builds handle more.
• HDR-heavy iPhone shots — recent iPhones attach gain maps for HDR display. The decoded result can look flatter than the on-screen preview promised. Check exposure on the first converted file; a small brightness correction in any editor fixes it.
• Colors look slightly off — iPhone photos carry the Display P3 color profile. The converted JPG keeps the profile tag where software honors it, but older apps assume sRGB and shift the hues. If a client on old software sees muted reds, re-export with an sRGB conversion before sending.
• A batch stalls partway — you've hit a memory ceiling. Two hundred full-resolution files at once is genuinely a lot of pixels. Split the batch; nothing was lost, nothing was uploaded, just run the remainder.
• Files still read as HEIC on the other end — Windows file associations lie more often than files do. Check the extension: if it ends in .jpg, it is a JPEG, whatever the icon claims until the icon cache catches up.

Wedding and event photographers, converting client galleries to the one format every proofing service accepts without a support ticket. Real-estate agents pushing iPhone listing photos into MLS portals that reject HEIC outright. Teachers assembling field-trip photos into a slideshow for parents night. Grandparents who receive photos they actually want to print at the pharmacy kiosk. Office managers building the company-recap deck. Etsy sellers photographing inventory between shipments and uploading from whatever computer is closest.

The pattern repeats for all of them: photos start life on a phone, and they need to end up somewhere that predates HEIC. That somewhere is usually older, slower, and stubborn about formats. JPEG is the common language that gets everyone through the door, and this converter is the translator that works at 11 p.m. when the client needs it now.

First: the iPhone has a setting called Transfer to Mac or PC, under Settings → Photos, with an Automatic option that converts to JPEG during a USB transfer. It's genuinely useful — but only when you remember it exists before plugging the cable in, and it does nothing for AirDrop or cloud-drive sync. Second: keep your originals in HEIC and mint JPEG copies on demand. Storage is the expensive side of that trade, and disk space is cheaper than lost originals.

And if the destination enforces a size cap — an upload form that stops at 2 MB, a mail server that bounces at 10 MB — do the resize and the convert in the same pass here. One motion: drop, cap, download. Two fewer browser tabs, one happier afternoon.

Conversion is usually step one of a chain. The JPGs you just made often need to become a PDF for an application packet, a smaller file for an upload form, or the same swap in reverse for a PNG source. These are the natural follow-ups, all running in the same privacy-first way.

• JPG to PDF — bundle the converted batch into a single document for forms and clients
• PNG to JPG Converter — the same universal-format swap when your source is PNG
• Image Compressor — squeeze the converted JPGs further when a portal enforces a size cap