Free Online File Converters
Convert between common image and document formats. Every converter names what it does and does not preserve — and /what-conversions-lose states it for all 563 pairs at once. Files are uploaded, converted and deleted within 30 minutes. Before choosing a format, check what each conversion keeps and loses.
Ebook converters
EPUB, MOBI, AZW3, FB2 and the rest — reflowable formats, where the page break is decided by the reader rather than the file.
AZW3 to Word
AZW3 presents a book to a reflowable reader; DOCX presents a document to an editor. Converting between them is most useful when the words need comments, tracked revisions, search, translation, or a new office layout. The result is editable extraction from a readable ebook, not recovery of the publisher's private Word manuscript. Chapters and ordinary paragraphs can become useful DOCX structure, while Kindle CSS, pagination, hidden navigation, and specialized artwork may need a human style pass afterward.
AZW3 to EPUB
AZW3 is Amazon's Kindle Format 8: capable on Kindle devices, but tied to a retailer-specific reading ecosystem. EPUB is the open ebook format used by Kobo, Apple Books, PocketBook, library apps, and many independent readers. Converting a DRM-free AZW3 can make a personal library much easier to move, while preserving the book's reflowable structure rather than freezing it into pages. The important qualifications are DRM, metadata quality, and Kindle-only styling.
AZW3 to MOBI
AZW3 is Kindle Format 8, the more capable successor to the older MOBI family. That makes this conversion a compatibility move, not a general upgrade: a legacy reader or delivery pipeline may accept MOBI when it cannot handle the newer package. The cost is feature loss. Complex CSS, embedded fonts, advanced navigation, scalable artwork, and newer Kindle layout behavior may be reduced to what an older MOBI consumer understands. Use an unprotected source and test the result on the actual older device when compatibility matters.
AZW3 to PDF
AZW3 is built for a reflowable Kindle screen, where the reader can change the font, margins, and orientation. PDF makes the opposite promise: a page has a chosen size, a chosen text layout, and a stable position for every line. Converting AZW3 to PDF is useful for a print proof, classroom handout, or citation copy, but it is a new typesetting pass rather than a way to preserve every Kindle view exactly. Use a readable, DRM-free source and inspect the pages before printing a long book.
AZW3 to TXT
AZW3 contains a reader package around its book text: records, metadata, styles, navigation, and often images. TXT deliberately removes almost all of that and leaves a linear stream that a search tool, archive, or script can inspect without an ebook parser. This is the right direction for keyword research, text comparison, and accessibility experiments. It is the wrong direction for preserving a cover, visual hierarchy, links, typography, or image evidence. Use only readable content you are authorized to extract.
CHM to EPUB
CHM was designed to make a linked help system available offline, while EPUB was designed to let a reader resize and repaginate a publication. Moving between them is a useful way to read an old technical manual on a phone or ebook application, but the operation is a reconstruction rather than a simple repackaging. A CHM can contain hundreds of HTML topics, a contents hierarchy, CSS, images, scripts, and viewer metadata. EPUB can hold chapters and resources too, yet it expects a publication spine and ebook navigation. This page converts readable material into that model while being candid about missing styles, incomplete assets, and the fact that no DRM is removed or bypassed.
DOC to EPUB
A DOC file can still contain a perfectly useful manuscript, but it comes from an older Word document model that is not an ebook package. This converter uses an explicit DOC to ODT to EPUB path: LibreOffice first opens the binary Word file and writes an OpenDocument Text intermediate, then Caliber reads that ODT and builds the final reflowable EPUB. That two-stage route is important because EPUB needs chapters, XHTML content, navigation, and portable resources rather than fixed Word pages. Ordinary paragraphs, headings, lists, links, and many inline images can make the trip. Exact pagination, macros, floating objects, comments, and unusual legacy controls should be treated as possible losses, not invisible guarantees.
DOCX to EPUB
DOCX to EPUB is useful when a Word manuscript needs to become a book rather than another fixed document. DOCX stores editable paragraphs, styles, relationships, images, and other Office parts; EPUB turns the readable result into XHTML chapters with a navigation structure that can reflow on a phone or dedicated reader. The conversion is therefore a publishing handoff, not a way to preserve every Word canvas effect. Real heading styles give the converter stronger chapter signals than text that was merely made large and bold. Images can travel, while floating shapes, text boxes, tracked-change markup, comments, macros, and carefully positioned page furniture may be simplified or dropped. The DOCX remains the editable master, and the EPUB should be proofread as a separate reading edition.
EPUB to AZW3
EPUB is the practical master format for a library that moves between readers, while AZW3 is a useful Kindle-specific delivery copy. Converting a readable EPUB to AZW3 gives compatible Kindle hardware a KF8-era package with richer CSS than classic MOBI. It does not make the book more portable than EPUB, and it does not turn a retailer's protected purchase into a usable source file.
EPUB to Word
An EPUB is designed for a reader that chooses its own page shape; a DOCX is built for office editing, comments, and a document canvas. So converting EPUB to DOCX gets you an editable manuscript, not a print-perfect replica. The words and much of the hierarchy can become workable Word content, while ebook CSS, pagination, and specialized navigation may need repair by the editor.
EPUB to HTML
EPUB is a publication package, not a single web page. It can contain several XHTML chapters, a navigation document, CSS files, fonts, images, metadata, and a reading order. This converter asks Caliber for an HTMLZ result and then extracts one HTML member from that archive as the download. That is useful when the main text needs to enter a web editor or a simple HTML workflow, but it is deliberately narrower than unpacking the whole EPUB. Because only one member is returned, the output may lose its companion CSS, images, fonts, scripts, and ebook-wide navigation. Treat the result as an extracted content starting point, not as a complete website replica.
EPUB to MOBI
Before converting anything, check the year on your Kindle. Since 2022, Amazon has accepted EPUB through Send to Kindle and stopped accepting MOBI, which reverses the advice most pages about this still give. MOBI is for hardware that predates that change.
EPUB to TXT
EPUB is a structured ebook package full of XHTML, styles, images, navigation, and metadata. TXT is only a stream of characters. Converting between them is useful when a search index, command-line tool, accessibility pipeline, or long-term text archive needs the words without a reader's layout rules. It is intentionally destructive: styling and visual context are traded for simple, portable text.
FB2 to DOCX
FictionBook is unusually generous about meaning: its XML can identify a section, poem, epigraph, citation, author, and series entry instead of merely describing how large something should look. DOCX is the practical destination when that content needs office editing, comments, translation, or a new manuscript layout. Converting FB2 to DOCX can make a strong editable starting point because the source exposes structure, but it still has to map ebook semantics into Word styles. Poems, images, nested sections, and special typography deserve a deliberate review.
FB2 to EPUB
FictionBook is a format most of the English-speaking web has never met and which holds a large share of the Russian-language e-book world. If you have an .fb2 and a reader that shrugs at it, this is the conversion that fixes that.
FB2 to MOBI
FB2 is a self-contained XML book format with unusually clear semantic tags for sections, poems, epigraphs, authors, and embedded images. MOBI is a more widely recognized ebook delivery format, especially in older reading software and legacy device workflows. Converting FB2 to MOBI translates that structure into a package a compatible reader can deliver, but the target is less expressive. Ordinary novels travel well; deep styling, complex tables, modern fonts, and carefully positioned artwork may become simpler. This is a practical delivery copy, not a replacement for the structured FB2 master.
FB2 to PDF
FictionBook, or FB2, stores an ebook as structured XML with metadata, semantic sections, and images encoded inside the same file. PDF needs to make different decisions: it must choose page dimensions, type metrics, margins, line breaks, and image placement before anyone opens the result. Converting FB2 to PDF is therefore an XML-to-fixed-page rendering job. It is useful for printing and stable citations, but it gives up some of the flexibility that makes an ebook comfortable to read.
FB2 to TXT
FB2 is an XML format built for fiction, with the book's structure and metadata described in tags rather than in styling. Converting to plain text keeps the reading order and the paragraph breaks and drops everything else, which is what you want when the destination is a script, a search index, or a device that reads nothing but text.
HTML to EPUB
HTML to EPUB is a good fit when the source is already a document tree: an article, course handout, collection of chapters, or static page saved as an HTML file. HTML carries headings, paragraphs, links, lists, tables, images, and style references, which gives Caliber more structure than a PDF or TXT file. It is not the same as capturing a live website. This server conversion receives the uploaded file, does not browse its URL, and cannot recreate JavaScript state, a framework component, remote fonts, or a site's full responsive design. Local or embedded assets may be available if they are part of what the job receives; a URL reference alone does not guarantee that an image or stylesheet is bundled. EPUB readers support a subset of browser CSS, so fixed positioning, animations, forms, scripts, and complex widgets need a simpler ebook treatment. Keep the source HTML and asset set for future edits.
Markdown to EPUB
Markdown to EPUB works best when a document already has a clear outline and the next destination is a reader rather than a code repository. Markdown expresses headings, paragraphs, emphasis, links, lists, code, and sometimes images in a compact source format. Caliber can interpret that structure and package it as EPUB chapters with navigation and reflowable styling. The result is more organized than a plain-text import, but Markdown is a family of related flavors, not one universal language. Tables, task lists, admonitions, front matter, raw HTML, footnotes, and custom directives may be treated differently or become plain content. Image paths also need an asset workflow; a relative reference does not guarantee that a file is inside the EPUB. This conversion does not execute scripts, fetch a live repository, remove DRM from an encrypted source, or recreate a site theme. Keep the Markdown as the editable source and read the generated book as a publishing artifact.
MOBI to AZW3
AZW3 is the Kindle-family format built around KF8, while classic MOBI carries the older rendering model. Moving a DRM-free MOBI to AZW3 can give a compatible Kindle a better stylesheet, typography, and reflow engine. It is an upgrade in what the container can express, not a way to recover styling that the MOBI never contained or bypass a book's protection.
MOBI to Word
MOBI was made for a small reading screen, not for an editor's office workflow. A DOCX gives the text a familiar home for comments, revisions, search, and copy editing. Converting MOBI to DOCX is therefore an office handoff: it recovers a usable manuscript-shaped document from a readable ebook, but it cannot restore a publisher's source file or guarantee the appearance of the original reading view.
MOBI to EPUB
MOBI exists because Amazon bought the company that made it and built a reading empire on top. EPUB exists because everyone else standardized. This conversion is what you run when a book is in the first world and your reading happens in the second.
MOBI to HTML
MOBI is a book container intended for ebook reading, while HTML is a web document that normally depends on nearby style sheets and media. This converter sends the readable MOBI through Caliber, asks for HTML output, and receives an HTMLZ archive. The server then extracts one HTML or XHTML member from that archive and returns it as the download. That makes a chapter or text sample easier to open in a browser or paste into a CMS, but it is not a full unpack of the MOBI publication. The selected HTML may reference CSS, images, fonts, or other members that are not returned beside it. The result is best treated as a content extraction that needs inspection, not as a guaranteed visual clone of a Kindle reading experience.
MOBI to PDF
A MOBI is designed to reflow as a reader changes the screen and font. A PDF does the opposite: it decides where every line, image, and heading belongs on a page. Converting MOBI to PDF is therefore a rendering job with useful fixed page output, not a neutral container swap. That distinction determines whether the result is convenient or frustrating.
MOBI to TXT
A MOBI is a reader-oriented package with compressed records, navigation, and device-era formatting. TXT removes that machinery and leaves a stream of words. That trade is valuable when a search index, text-analysis script, accessibility experiment, or durable archive needs the content without an ebook application. It is a poor choice when the cover, links, images, typography, or visual structure are part of what you need to preserve.
ODT to EPUB
ODT to EPUB turns an OpenDocument Text file into a portable ebook without first freezing it as PDF. ODT is an open, XML-based word-processing format that can carry paragraph styles, lists, fields, tables, images, footnotes, and page-oriented design. EPUB is also a structured package, but its normal reading model is a flow of XHTML chapters rather than a sheet of paper. That makes ODT a useful source for essays, manuals, and manuscripts, especially when the author used named heading styles. It also creates clear boundaries: page breaks, master-page headers, text frames, drawing objects, and print-specific spacing may not have a direct reflowable equivalent. Caliber can convert readable, unencrypted content, not remove DRM or unlock a protected document. Keep the ODT as the editable master and inspect the EPUB in the reader that your audience will actually use.
PDF to EPUB
PDF to EPUB is a change from a finished page drawing to a book that can reflow. A PDF records where glyphs, images, and lines were placed on each page; EPUB records chapters, XHTML content, styles, and reading order. Caliber has to infer that second structure from the first. That can produce a comfortable ebook for a text-led report or novel, but it cannot promise the PDF's page geometry. Columns, sidebars, tables, captions, headers, and footers are all visual relationships that may need reconstruction. A scanned PDF has an additional boundary: without a text layer, this conversion cannot read the photographed words. The result is best treated as a reflowable working edition, with the original PDF retained for exact layout, citations, or archival evidence.
TXT to EPUB
TXT to EPUB is a simple route from a plain manuscript to a book that readers can resize and carry in an ebook library. Plain text is deliberately modest: it stores characters, line endings, and sometimes an encoding, but it does not contain fonts, images, semantic headings, hyperlinks, footnotes, or a table of contents. Caliber can package the prose and make a readable flow, while using blank lines or familiar patterns to infer some paragraphs and sections. It cannot recover structure that was never written down. A clean novel draft or public-domain text can work well; a screenplay, code listing, poem with significant spacing, or text copied from a formatted page needs a careful preview. The EPUB is a new reading container, not a restoration of missing formatting, and plain TXT has no normal DRM layer for the converter to remove.
Spreadsheet converters
XLS, XLSX, ODS and CSV. A converted spreadsheet is a delivery copy: formulas and pivot tables stay behind in the original.
CSV to ODS
Getting a data file into a spreadsheet means giving every cell a type it never had. That inference is what makes the file usable — numbers that sum, dates that sort — and it is also what turns a product code with a leading zero into an ordinary integer. ODS is the open, ISO-standardized destination for that, native to LibreOffice.
CSV to XLS
This is the conversion where two formats disagree about size. A CSV can be any length at all; the legacy .xls stops at 65,536 rows per sheet. Most data files people convert are far below that and nothing goes wrong, but a log export or a database dump can exceed it easily, and the failure is truncation rather than an error.
CSV to XLSX
Every cell in a CSV is text. Every cell in a workbook has a type. The conversion therefore has to guess, and guessing is where reference numbers lose their leading zeros and where 03/04 becomes a date in whichever order the locale prefers. Knowing that in advance is most of what you need to convert a CSV safely.
ODS to CSV
An OpenDocument spreadsheet holds sheets, formulas and locale-aware formatting. A CSV holds rows of text. The conversion resolves formulas to values and exports the first sheet, and the detail worth knowing is the decimal separator: a locale that displays 3,14 writes 3.14 into the file, because a comma is the field delimiter.
ODS to HTML
Publishing a sheet turns a live document into a fixed one. Formulas become the numbers they had produced, because a browser has no calculation engine, and the first sheet becomes the table because a page has no tabs. What you get is a snapshot that has to be republished whenever the workbook moves on.
ODS to PDF
Convert an ODS spreadsheet to PDF when the recipient needs a fixed report rather than an editable workbook. ODS is the OpenDocument format used by LibreOffice Calc and other office suites, and the server opens the file with LibreOffice to export its printable pages. The PDF is a delivery copy: formulas, filters, pivot tables and cell structure stay behind in the original ODS, while page settings, fonts and print areas decide what a reader sees.
ODS to XLS
This conversion travels in two unhelpful directions at the same time: from an open standard to a proprietary binary, and from a current format to one with a 65,536-row ceiling. It is worth doing only when a specific destination refuses everything else, and it is worth checking the row count before you rely on the result.
ODS to XLSX
This conversion is almost always about the person receiving the file. A LibreOffice user hands a workbook to an organization standardized on Excel, and although Excel can read ODS, a file arriving in the format everyone expects avoids a conversation. Data, formulas and multiple sheets all make the trip.
XLS to CSV
A .xls is an opaque binary that needs Excel or a library to read at all, which makes it a poor place for data that a pipeline has to consume. CSV is the opposite. The two things worth knowing before you rely on the output are that the first sheet is the only one exported, and that files written in the 1990s frequently used a regional code page rather than Unicode.
XLS to HTML
Old spreadsheets were laid out by hand. Before anyone had a design system, people built headings by merging cells, made columns by leaving one empty, and drew borders to fake a table inside a table. All of that comes through as markup, which is why publishing a legacy sheet usually needs a pass of tidying that a modern one does not.
XLS to ODS
The argument for this conversion is longevity. A .xls is a compound binary whose specification was reverse-engineered for years before it was published, and reading one in twenty years means finding software that still implements it. An ODS is a ZIP of XML against a published ISO standard, which anybody can open and inspect with ordinary tools.
XLS to PDF
XLS is the older Excel workbook format still found in archived finance files, inventory exports, and inherited reports. Converting it to PDF gives recipients a fixed page layout without requiring the original spreadsheet application. LibreOffice opens the workbook and exports a real PDF on the server. The result is a delivery copy, not an editable replacement: formulas, print areas, hidden sheets, fonts, and page breaks should be reviewed before the original XLS is archived or sent.
XLS to XLSX
The .xls format is Excel's binary from before 2007, and it carries two limits worth escaping: 65,536 rows per sheet and 256 columns. It is also an opaque compound file that can hold macros, which is why mail filters treat it with suspicion. Converting to .xlsx removes all three problems and keeps the data, the formulas and the formatting.
Excel to CSV
A CSV is rows of text separated by commas and nothing else. An XLSX is a workbook: many sheets, formulas, number formats, merged cells, charts. Converting means keeping the first of those and discarding the rest, and the three things people are surprised by are that formulas arrive as values, that only one sheet comes out, and that a number formatted as currency arrives as a bare number.
Excel to HTML
Publishing a sheet means answering one question the spreadsheet never had to: what does a formula look like on a web page. The answer is its value, because nothing on the page will recalculate. The first sheet becomes a table, the cell formatting comes across as markup, and everything interactive about a workbook is left behind.
Excel to ODS
ODS is the spreadsheet half of OpenDocument: an ISO-standardized, inspectable ZIP of XML, native to LibreOffice and readable by Excel. Converting into it is usually about a requirement rather than a preference, and the data and formulas make the trip intact. The place to look afterwards is functions, because the two formula libraries overlap without matching exactly.
XLSX to PDF
Convert a modern Excel XLSX workbook into a fixed PDF when someone needs to read, print, or upload the result without editing the spreadsheet. LibreOffice performs the server-side export and returns a real PDF rather than changing the filename. A workbook can contain multiple sheets, formulas, charts, print areas, and hidden content, so this page treats visual review as part of the job and tells you when keeping the original XLSX is safer.
XLSX to XLS
This conversion goes backwards, and it is done under duress: an old machine, a piece of industrial software, an upload form written two decades ago. The important thing to check before you send the result is the row count, because the legacy format stops at 65,536 rows per sheet and going over that ceiling loses data rather than raising an error.
XML to CSV
XML to CSV is for the moment when a hierarchical document needs to become a table that a spreadsheet, reporting tool, or batch import can read. The built-in transform looks for ordinary repeated record-like elements, turns those records into rows, and flattens nested values into column paths that can be scanned or filtered. Attributes are treated as data rather than decoration, which helps preserve identifiers, status fields, units, and other metadata attached to a record. CSV is deliberately simpler than XML, so the output is not a perfect mirror of an arbitrary document. Deeply uneven branches, mixed text and child elements, repeated fields inside one record, namespaces, and order-sensitive content can produce columns that need review. This is a pure-code conversion of the XML file you upload. It does not run an XSLT stylesheet, query a database, fetch external entities, or infer business rules such as totals and date formats. Use it for ordinary repeated data, then inspect headers and a few rows before sharing or loading the CSV into a system that expects a fixed schema.
Presentation converters
PPT, PPTX and ODP, either to another editable deck or to a fixed format that will look the same on somebody else’s machine.
ODP to HTML
Sharing an Impress deck with people who do not run LibreOffice usually ends in a format argument. A web page ends it instead: the reader needs a browser and nothing else, every slide is there, and the text stays real text that can be searched and read aloud rather than becoming a picture.
ODP to JPG
Most Impress slides should not be JPGs. The format compresses photographs well and flat color badly, so a text slide gains visible haloes while a full-bleed image slide compresses cleanly into a much smaller file. This page exists for the second case, and says so plainly rather than presenting JPG as a neutral choice.
ODP to PDF
ODP is the OpenDocument presentation format used by LibreOffice Impress and other open office suites. Convert it to PDF when you need a fixed slide deck for review, printing, or a document upload. LibreOffice performs the export on the conversion worker. The result keeps the visible slide pages, but it cannot remain an editable presentation with animations, speaker notes, media controls, or theme-level editing.
ODP to PNG
Getting a picture of a slide usually means opening the deck in something. This route needs nothing installed: an OpenDocument presentation goes in and a PNG of its first slide comes out, losslessly, at the slide's own dimensions. It is the straightforward way to produce a thumbnail or a preview from an Impress file.
ODP to PPT
This conversion travels in two unhelpful directions at once: from a published open standard to a proprietary binary, and from a current container to one that predates 2007. The file gets bigger, harder to inspect and more likely to be quarantined by a mail filter. Do it when a specific old machine demands it, and not otherwise.
ODP to PPTX
This conversion is about the room you are presenting in. PowerPoint can open an ODP, but the laptop plugged into the projector belongs to somebody else, and a file in the expected format removes a conversation you do not want to have two minutes before you start. Slides and content transfer; the motion is what to check.
PPT to HTML
An old .ppt is difficult to open, awkward to circulate and invisible to search. Converting it to a page fixes all three at once: anyone with a browser can read it, the text becomes findable, and a file that depended on software from two decades ago becomes markup that will still render in twenty more.
PPT to JPG
Two things make this different from exporting a modern deck. A JPG holds one image, so only the first slide comes out. And a legacy deck was laid out around fonts that may no longer exist, so what gets rendered is not necessarily what the author saw — and unlike an editable format, an image gives you no way to fix it afterwards.
PPT to ODP
A .ppt is a compound binary whose specification was reverse-engineered for years before it was published. Reading one in twenty years means finding software that still implements it. An ODP is a ZIP of XML against an ISO standard, which is why archives and public bodies increasingly ask for it and why an old deck worth keeping is worth converting.
PPT to PDF
Old PPT presentations can be difficult to open on a modern device, especially when the original PowerPoint installation or font set is gone. Convert a legacy presentation to PDF for a fixed slide deck that is easier to preview, email, print, and upload. LibreOffice renders the slides on the server. PDF preserves the visual delivery, not the editable animation timeline, speaker notes, transitions, or presentation controls.
PPT to PNG
Decks from the .ppt era are almost entirely flat fills, hard-edged shapes and text — the exact content a lossless format handles perfectly and a lossy one smears. PNG is therefore the right target for an old slide, with one caveat that has nothing to do with compression: if the deck's fonts are gone, the render will not match what its author saw.
PPT to PPTX
The .ppt format is PowerPoint's binary from before 2007. It is large, opaque, and treated with suspicion by mail systems because of its long association with macro-borne malware. Converting to .pptx keeps the slides and the formatting while making the file smaller, inspectable and far easier to send.
PowerPoint to HTML
A deck in a browser is a document, not a presentation. Every slide is there and the text is real text that can be searched, selected and read by assistive software, which a picture of a slide never allows. What does not survive is the performance: the transitions, the builds and the timing that made it a talk rather than a handout.
PowerPoint to JPG
JPG is the wrong default for a slide and the right choice for a specific kind of slide. Its compression was designed for photographs, so a full-bleed image slide compresses beautifully, while a slide of text and flat color picks up haloes around every letter. The first slide is the one exported, because one image file holds one image.
PowerPoint to ODP
A deck is more than its slides: it carries masters, layouts, transitions, animations and embedded media, and the two formats express those with different vocabularies. Text, images, shapes and slide order come across dependably. Motion is the part that needs checking, because a transition one suite defines may have no counterpart in the other.
PowerPoint to PDF
Convert a modern PowerPoint PPTX deck into a PDF when your audience needs fixed pages instead of an editable presentation. The server uses LibreOffice to render the slides and returns a downloadable document. This is useful for approval packets, handouts, print jobs, and portals that accept PDF. It does not preserve animation, transitions, speaker controls, or the full editable slide model, so keep the original PPTX.
PowerPoint to PNG
A PNG holds one picture, so a deck of twenty slides cannot become one PNG without choosing. This exports the first slide, which is the one people usually want: a title card for a thumbnail, a preview image, or a single diagram lifted out of a deck. If you need all of the slides, PDF is the format that carries a sequence.
PPTX to PPT
This goes backwards on purpose. The legacy binary is bigger, opaque, and routinely quarantined by mail filters, so nobody chooses it without a reason. The reason is always a specific destination: a meeting room machine that was never updated, a kiosk, or a system that accepts one extension and nothing else.
Image converters
Every pairing between the common raster formats, plus the legacy ones a camera or an old archive still produces.
AI to JPG
JPG is what you reach for when the file has to be small and ordinary — a listing, an email, a form that accepts nothing else. For Illustrator artwork it involves two lossy steps rather than one, and both are described here rather than left to be discovered.
AI to PDF
This is the one conversion on this page that loses nothing. An Illustrator file and a PDF are close relatives — both describe drawings as geometry — so the artwork is rewritten rather than rendered. Nothing becomes pixels, and the result is as sharp at poster size as it is on a phone.
AI to PNG
An Illustrator file has no pixels. It has instructions — lines, curves, fills — and a size measured in points, so converting one is really a question of what resolution to draw it at. Ask at 72 dpi, the default almost everywhere, and a poster comes back the size of a postage stamp. This renders at 150.
AI to TIFF
This conversion is asked for far more often than it is the right answer, so the page says both things. It produces a proper lossless TIFF, LZW compressed and around 270 times smaller than the uncompressed one most tools give you — and it fixes the resolution of artwork that had none, which for a print job is usually a step backwards from /ai-to-pdf.
AI to WebP
This is the conversion for artwork whose destination is a web page and nowhere else. WebP keeps the transparency Illustrator work usually depends on and is a fraction of the size of the PNG you would otherwise reach for — at the cost of fixing, permanently, a resolution the source never had.
AVIF to BMP
AVIF is designed to make modern images small, while BMP is designed to make pixel data straightforward for old readers. Converting AVIF to BMP is useful when a scanner utility, embedded display, or desktop program refuses the efficient source format. The result is a compatibility copy: it keeps the decoded dimensions and visible picture, but trades AVIF compression for a much larger bitmap.
AVIF to GIF
AVIF is efficient because it can describe modern, full-color images compactly; GIF is useful because almost everything recognizes it. Moving from one to the other is therefore a compatibility concession. The AVIF is decoded, its colors are reduced to a GIF palette, and one static GIF is written. Choose this route for an old upload form or embedded system, not as a quality upgrade.
AVIF to HEIC
AVIF and HEIC are both modern, compact image formats, yet they belong to different codec families and are not interchangeable by renaming a file. AVIF usually carries AV1 image data, while HEIC commonly carries HEVC data inside a HEIF container. Converting between them makes sense when an Apple photo library, device importer, or HEIF-aware application accepts one and rejects the other. It also means decoding one lossy image and encoding a new one.
AVIF to JPG
AVIF is the format you end up with after saving an image from a modern website, and then discover that Photoshop, Word or your photo viewer refuses it. This converts it to JPG. Your browser is very likely the only piece of software on your machine that reads AVIF at all, which is exactly why the file is stuck.
AVIF to PDF
AVIF is excellent at making a modern image small, but it is an awkward handoff when a recipient, print desk, or upload form expects a document. This conversion decodes the AVIF into ordinary raster pixels, places the still on one A4 page, and exports a PDF that more systems can open. It changes the delivery wrapper and page layout; it does not create text, add resolution, or repair a low-quality source.
AVIF to PNG
If you are here, something refused to open an AVIF — Photoshop, a printer's upload form, a colleague's laptop. PNG is the format nothing refuses. The trade is size: expect the PNG to be several times larger, because that is what lossless costs.
AVIF to TIFF
AVIF is efficient because it uses the AV1 image codec; TIFF is useful because editors, scanners, and preservation systems know how to work with its imaging container. Converting AVIF to TIFF is a bridge between those worlds. The server must decode the modern codec first, then store the resulting pixels in TIFF. That can make an AVIF usable in a legacy workflow, but it cannot restore detail that an earlier lossy AVIF export removed.
AVIF to WebP
AVIF is often the smaller and newer choice, but it is not always the safest file to hand to a mixed audience. WebP gives a web team a broad, predictable delivery format while keeping modern compression and transparency. This is a real decode and re-encode, not a filename change, so keep the AVIF master and inspect the WebP before replacing it.
BMP to AVIF
BMP is a useful historical interchange format but a poor default for byte-sensitive delivery. AVIF can represent the same canvas with modern compression, often making a large bitmap dramatically easier to store or send. This conversion is aimed at that upgrade: the server decodes BMP, encodes AVIF at a lossy quality setting, and leaves the dimensions unchanged. The result can be excellent for photographs, yet AVIF support in every decoder should be confirmed before the old file is replaced.
BMP to GIF
A BMP stores every pixel at full color depth and pays for it in bytes. GIF stores an index into a palette of at most 256 colors, which is why it collapses a flat diagram and mangles a photograph. This converter builds the palette from the colors your bitmap actually uses, so a screenshot with nine colors keeps all nine and a sunset does not.
BMP to JPG
BMP is easy for old software to write but expensive to move because it commonly stores pixels with little compression. JPG offers a much smaller handoff for photographs, scans, and ordinary illustrations that need a familiar web, office, or upload format. The saving is not free: this route writes a lossy JPG at quality 82, flattens transparent areas onto white, and can introduce ringing, softened text, or block-like detail around hard edges.
BMP to PDF
BMP is easy for old applications to write and unusually expensive to carry around. PDF is the more useful handoff when the bitmap has become a scan, diagram, receipt, or attachment that must print and open like a document. This conversion reads the legacy bitmap, places the pixels on a fixed A4 page, and keeps the whole image in view. It does not reduce the source resolution or make the picture's text editable.
BMP to PNG
A BMP stores every pixel at full size with no compression whatsoever, which is why a modest screenshot can be twenty megabytes. PNG stores exactly the same pixels and compresses them. This conversion is unusual in having no downside worth discussing: the image is identical and the file is a fraction of the size.
BMP to TIFF
BMP and TIFF can both carry raster pixels, but they belong to different generations of imaging work. BMP is simple and familiar to older software; TIFF is more at home in editing, scanning, print, and archival workflows. Converting BMP to TIFF creates a lossless TIFF representation of the decoded bitmap, which can make the handoff easier for modern imaging tools. It does not guarantee a smaller file, restore missing information, or automatically satisfy a specialized archive profile.
BMP to WebP
BMP is straightforward for old software and expensive for storage. WebP is built to carry the same visible image in far fewer bytes, which makes this a useful escape route for screenshots, scans, and artwork trapped in a legacy bitmap workflow. The saving comes with a real choice: this page writes lossy WebP, so fine text and hard edges deserve a visual check before the BMP is discarded.
EPS to JPG
Almost nobody chooses JPG for a logo. They choose it because a supplier portal, a job application or a marketplace listing rejects everything else, and the file they were given is an EPS that will not open at all. This turns one into the other, and is honest about the two things it costs.
EPS to PDF
This conversion loses nothing. PostScript and PDF are the same idea a generation apart — both describe a drawing as geometry — so the artwork is translated rather than photographed. The result is sharp at any size, and the page is cropped to the drawing rather than dropped in the middle of a sheet of letter paper.
EPS to PNG
EPS is what logos arrived as for twenty years, and it is the format most likely to be sitting in a brand pack that nothing on your computer will open. It contains PostScript — drawing instructions, not pixels — so converting it means choosing a resolution to draw at, and the usual default is far too low.
EPS to TIFF
Two formats from the same era, meeting a workflow that still runs on both. An EPS holds drawing instructions; a TIFF holds pixels; and a surprising number of print, imaging and archival systems built in the 1990s expect exactly this handoff. The output is losslessly compressed, which is the part most converters get wrong.
EPS to WebP
An EPS is a PostScript program from an era when the destination was a printing press. A WebP is a codec built for a browser to download quickly. This conversion crosses about twenty-five years of assumptions in one step, and the interesting part is which of them survive.
GIF to AVIF
AVIF is an efficient still-image format for the modern web, while GIF is often used as a tiny animation format despite its old compression model. Those strengths do not line up perfectly. This page turns a GIF into a compact AVIF still and deliberately keeps the first frame only. That can be exactly right for a poster, preview, or thumbnail, but it is the wrong choice if the movement is the content.
GIF to BMP
GIF is convenient for simple graphics and animation, while BMP remains useful to legacy Windows programs, instruments, and embedded readers that expect a plain bitmap. This route extracts one static frame and writes it as a broadly readable BMP. An animated source therefore becomes a deliberate snapshot, not a frozen copy of its whole timeline. The conversion also moves the decoded pixels beyond GIF's 256-color palette, although it cannot recover color detail that the GIF already discarded.
GIF to JPG
A GIF stores at most 256 chosen colors and possibly hundreds of frames. A JPEG stores millions of colors and exactly one frame. Going from one to the other is not a format change so much as two conversions in opposite directions, and both of them lose something.
GIF to PDF
PDF is a page description format, and a page does not animate. So the useful thing to know before converting is what happens to a GIF that has frames: the first one becomes the page, and the rest are not carried. For a static GIF that is no loss at all, and the result is a document you can email, print or file where an image would have been refused.
GIF to PNG
GIF is limited to 256 colors and a one-bit transparency mask, which is why gradients band and edges look jagged. PNG has neither limit. Converting fixes the transparency and stops the color loss getting worse — but if the GIF is animated, you are left with one frame.
GIF to TIFF
GIF is a compact, palette-based format that is often chosen for motion or simple web graphics. TIFF belongs to a different workflow: it is a flexible container used by editors, scanners, print desks, and preservation systems. Converting GIF to TIFF makes sense when that workflow requires a still TIFF, not when it can restore a higher-quality source. Animated GIFs are explicitly represented by their first frame, while the output provides a fuller color storage path and a much larger file.
GIF to WebP
Animated GIF is a 1987 format doing a job nobody designed it for, and it does that job about four times more expensively than it needs to. WebP holds the same animation with real compression behind it, and every browser has displayed it for years.
HEIC to AVIF
These two formats are siblings. Same container, same generation of compression, similar results on the same photograph. What separates them is not engineering — it is that one carries patent licensing and the other does not, and that single difference decided which one the web adopted.
HEIC to BMP
HEIC is a sensible camera-library format and a frustrating input for software that was built around Windows bitmaps. Converting HEIC to BMP gives an old editor, instrument, or upload form a simple raster file, but it also strips away the parts of a camera package that BMP cannot represent. Expect a large RGB bitmap containing the primary rendered photo, not a replacement for the original library asset.
HEIC to GIF
A phone camera can produce a perfectly ordinary-looking photo inside a HEIC file that an old forum, badge system, or desktop application cannot read. GIF is a compatibility escape hatch, but it is a severe one for photographs: the primary camera image is flattened into a single frame and its colors are fitted to GIF's 256-color limit. Use it when the receiving system leaves no better option.
HEIC to JPG
HEIC is what an iPhone saves when "High Efficiency" is switched on, and it is the reason a photo that looks fine on the phone refuses to open on a work laptop. This converts it to JPG at full resolution. The interesting question is not whether the pixels survive — they do — but what happens to the parts of a HEIC file that JPG has no way to store.
HEIC to PDF
HEIC is an efficient phone-photo format, but it is a poor handoff when the next person needs a document, a predictable print page, or an upload that accepts PDF and refuses unfamiliar images. This conversion decodes the HEVC image on the server, places the visible still on an A4 page, and gives you a static file that is easier to send and file. It does not turn photo pixels into selectable text.
HEIC to PNG
PNG is the right target when the photo is going to be edited, layered, or submitted somewhere that specifies a lossless format. If you just want the iPhone photo to open on a laptop, JPG produces a file a tenth of the size that opens in the same places — and this page will keep saying so.
HEIC to TIFF
HEIC is efficient for a phone library, but editing and archival systems often ask for TIFF instead. This route decodes the HEVC-backed image on the server and writes a TIFF copy with the same dimensions. It is a practical handoff, not a time machine: TIFF can protect the decoded pixels from another lossy save, but it cannot restore detail already removed by the HEIC encoder.
HEIC to WebP
This is the conversion for publishing rather than for sharing. If a photo is going onto a web page, WebP is the format that keeps the file small and still renders in every browser — which is precisely the combination HEIC fails to offer despite being the better codec.
ICO to BMP
An .ico is not one image. It is a small archive holding several sizes of the same artwork, and the images inside it are already bitmaps — so this is closer to unpacking a folder than to converting a photograph.
ICO to GIF
An ICO is not one image. It is a container holding the same artwork at several sizes so Windows can pick the right one for a taskbar, a title bar or a desktop. Converting to GIF means choosing, and this route takes the largest stored size because that is the one with detail to lose. GIF's transparency is one bit, so a soft icon edge becomes a hard one.
ICO to JPG
An ICO is a bundle of small images, not a single photograph waiting for a new extension. This conversion measures its frames and chooses the one with the most pixels, then writes one JPG. Transparent corners are flattened to white, because JPG has no alpha channel and an icon-to-photo conversion is an unusual compromise.
ICO to PNG
An .ico is not one image. It is a small archive holding the same artwork at 16, 32 and 48 pixels, sometimes more, and the interesting question is not how to decode it but which one you get. Most converters hand you whichever frame came first. This takes the largest.
ICO to SVG
Convert an ICO into an SVG path drawing by selecting the largest icon frame and tracing its visible regions. This is useful when a favicon is the only surviving copy of a simple mark. It does not combine every size in the container, restore the original vector, or preserve the pixel-perfect appearance of a tiny favicon.
ICO to TIFF
TIFF is the format that print shops, scanners and archives agree on, and it is one of the few common raster formats that discards nothing. Converting an icon into it is unusual but sensible when the artwork has to enter a print or document-management workflow that will not look at an ICO. The largest image inside the container is used, and its color is carried across intact.
ICO to WebP
An ICO is a container that can hold several sizes of the same icon, while WebP is one modern image file intended for efficient delivery. This conversion inspects the frames and selects the one with the largest pixel area, rather than trusting whichever entry happens to come first. WebP can keep ordinary alpha transparency, so the result remains flexible for a page. If a downstream system needs a fixed color background, flatten that copy deliberately instead of losing the original.
Image to Text (OCR)
Reads printed text out of a photograph, screenshot, or scan using optical character recognition that runs on your own device rather than a server. The engine is about nine megabytes and is downloaded only when you press the button, then cached — so the first run is slow and every one after it is not. A confidence score comes back with the text, so you know how carefully to check it.
JP2 to JPG
JPEG 2000 was designed to replace JPEG and did not, except in the places that adopted it early and never left — archives, cinema, medical imaging and some scanners. If a file like that has landed on your desk, almost nothing on a normal computer will open it. This turns it into a JPG that everything will.
JP2 to PNG
If the JPEG 2000 file came from an archive, a scanner or a medical device, there is a good chance it is lossless — and converting it to JPG would be the first time anything in its life was thrown away. PNG is the target that does not do that.
JP2 to WebP
Two formats that were both meant to succeed JPEG, twenty years apart. One won the archives and the other won the browsers, and this conversion is the bridge between those two worlds — for when a collection that was digitised properly needs to go on a website.
JPG to AVIF
Re-encoding a JPG as AVIF typically halves it, sometimes better, at a quality difference you will not see. The catch is that a JPG has already been through one lossy encoder, so this is compression applied to compression — and the right way to think about that is different from converting a PNG.
JPG to BMP
JPG and BMP are built for opposite priorities. JPG makes photographs small by approximating their pixels, while BMP makes pixels easy for old software to read by storing them with little or no compression. Converting a JPG to BMP can solve a real compatibility problem, but it cannot restore detail and it can make the file dramatically larger.
JPG to GIF
JPG and GIF solve different problems. JPG is built for continuous-tone photographs, while GIF is built around a small indexed palette and broad support for simple animation. This conversion is useful when an old uploader insists on GIF, but it cannot make a photograph fit GIF's color model without visible compromises.
JPG to HEIC
Nearly everyone arriving here is going the other way, and for good reason. This page exists for the narrow case where the destination is Apple's world and the saving is worth it — and it will spend most of its time explaining when that is not true.
JPG to ICO
Two things go wrong when a favicon starts life as a JPEG, and both are worth knowing before you look at the result. The corners will be opaque, because JPEG cannot describe transparency. And a photograph at sixteen pixels is a colored smudge.
JPG to PDF
Combine photos, scans, or screenshots into a single PDF with one image per page, arranged in the order you choose. Page sizes are real physical sizes — A4, Letter, or matched to the image — because a PDF is measured in inches rather than pixels, and getting that conversion wrong is what produces documents that print across four sheets.
JPG to PNG
Convert JPG files to PNG. This page is also honest about something most converters leave out: PNG is lossless from the moment of conversion onward, but it cannot undo compression that has already happened. Knowing that in advance saves disappointment when the result looks identical and weighs four times more.
JPG to SVG
Convert a JPG into an SVG made from paths rather than hiding the JPG inside a file with a different extension. The result can be useful for a high-contrast mark, signature, stamp, or pen drawing. It cannot recover clean vector geometry from a photograph, because the pixels never contained that geometry to begin with.
JPG to TIFF
Almost nobody converts to TIFF by choice. People do it because a print shop, a journal or a government archive specified TIFF and will not accept anything else. This does that conversion, and is clear that it improves nothing — it changes the wrapper, not the picture.
JPG to WebP
WebP reaches the same visual quality as JPEG in noticeably fewer bytes, which is why it has become the default format for image-heavy websites. This converts your JPGs in batches inside the browser, with a quality control set by default to the point where the size saving is real and the difference is not visible.
OCR Table Extractor
Turn a screenshot, scan, or photograph of a printed table into reviewable rows and a CSV download. OCR runs with Tesseract, then nearby word boxes are grouped into rows and cells. This is a useful starting point for receipts, schedules, and simple reports, but it is not a perfect grid reconstruction: merged cells, borders, formulas, rotated text, and irregular columns still need checking.
PDF to JPG
Render any page of a PDF as an image at the resolution you need — 72 DPI for a quick preview, 300 for print. You pick which pages, the output format, and the quality. The rendering engine runs inside this browser tab with its worker served from this site rather than a third-party CDN, so your document is never transmitted anywhere.
PDF to PNG
PDF to PNG renders the first page of your PDF as a PNG image. It is a useful short route when you need a cover, a title page, a thumbnail, or a single page to place in an application that accepts images but not PDF files. This server converter is deliberately limited: it reads page one only, writes one PNG, and does not silently turn a 200-page document into a large image set. The page is rasterized, so text and vector artwork become pixels at the renderer's output resolution. If you need several pages, use the existing multi-page PDF-to-JPG browser tool, which can render selected or all pages and offers PNG output at the resolution you choose.
PDF to TIFF
PDF to TIFF turns the first page of a PDF into one TIFF image for workflows that still expect a tagged image file. TIFF is common in scanning, print, records, and older imaging software because it can carry high-quality raster data and metadata that ordinary web formats do not. This server converter does one focused job: it uploads the PDF, renders page one, and returns a single TIFF. It does not create a multi-page TIFF from every page of the source. If you need page selection or a whole document rendered in the browser, the existing multi-page PDF-to-JPG browser tool can render selected or all pages, although its image choices are JPG, PNG, and WebP rather than TIFF.
PNG to AVIF
AVIF usually lands a PNG somewhere between a fifth and a tenth of its original size, which is a bigger saving than any other format switch available on the web today. It is also lossy by default and unsupported in a few places that still matter, so this page is as much about when not to use it as how.
PNG to BMP
This is the only conversion here that trades a good format for an obsolete one, and there is exactly one reason to do it: something downstream reads nothing else. Embedded displays, laboratory instruments, industrial control panels, software from 2003. For them, BMP's simplicity is the feature.
PNG to GIF
A GIF can hold 256 distinct colors. A PNG holds sixteen million. Everything that happens in this conversion follows from that one number, and whether the result looks fine or ruined depends entirely on how many colors your image was actually using.
PNG to HEIC
HEIC was designed for one thing — photographs coming off a phone camera — and it is very good at it. Whether this conversion helps you depends almost entirely on whether your PNG is a photograph, and most PNGs are not.
PNG to ICO
Convert a PNG into a Windows ICO that carries 16, 32 and 48 pixel entries inside one file. An ICO is not an image format so much as a small archive holding several sizes of the same icon, and the operating system picks whichever it needs. Most converters ignore that and write a single image with an .ico extension, which is a PNG wearing the wrong name.
PNG to JPG
Drop PNG files in and get JPGs out, with control over the one thing this conversion always has to decide: what color goes where the transparency used to be. A folder of screenshots converts as fast as your laptop can encode them and none of them are uploaded to anyone.
PNG to PDF
Most people converting an image to PDF are not doing it for the format — they are doing it because something upstream refuses to accept a .png. A visa portal, a bank, a university application. This wraps the image in a document container so it goes through.
PNG to SVG
This traces the shapes in a PNG and writes them as SVG paths. That is a real conversion and it is genuinely useful on a logo, an icon, or a scanned signature. It is not a way to turn a photograph into a vector illustration, and no tool anywhere does that — the difference matters enough to lead with.
PNG to TIFF
PNG and TIFF can both store exact pixels, but they belong to different working habits. PNG is the convenient exchange format for screens and graphics; TIFF is the roomy, well-documented container that scanners, archives, and image editors have trusted for decades. This conversion changes the container without adding detail, and that distinction matters when a TIFF requirement is really a request for a durable editing master.
PNG to WebP
WebP is the safe modern format. It is smaller than PNG, keeps transparency, and opens in things AVIF does not — email clients, older phones, desktop software. If you want one format that works everywhere and is meaningfully smaller than what you started with, this is it.
PSD to JPG
JPG is the right answer when the file is going somewhere that wants a small, ordinary photograph — an email, a marketplace listing, a form that rejects everything else. It is the wrong answer if the artwork has transparent areas, because JPG cannot hold them, and this page tells you what happens to them instead of quietly deciding.
PSD to PDF
PDF is what you send when the other person must see it exactly as you made it, on any device, without owning your software. A PSD becomes a one-page PDF holding the flattened composite — a raster page, which is what a Photoshop document honestly is, rather than a claim of vectors that were never there.
PSD to PNG
A PSD is not one image. It is the finished picture plus every layer that was used to build it, each a full-size image in its own right — which is why a careless converter hands back a single layer and calls it your artwork. This reads the composite, the flattened version Photoshop shows you, and writes it as a PNG with transparency intact.
PSD to TIFF
TIFF is what print shops, archives and scanning workflows ask for, and it is the one raster format that has never lost a pixel to compression. The output here is LZW-compressed, which is lossless — the pixel checksum matches the source exactly — and roughly a hundred times smaller than the uncompressed TIFF most converters hand back.
PSD to WebP
WebP is the format that ended a twenty-year compromise. Before it, putting a design on a web page meant choosing between a small file and a transparent one. WebP is both, and every browser has read it since 2020 — so for artwork that is going on a website, this is usually the right conversion rather than the clever one.
SVG to BMP
SVG is a set of scalable drawing instructions, while BMP is a fixed grid of color samples. Converting SVG to BMP is therefore a rendering choice: the vector must be painted onto a pixel canvas before a bitmap can be written. This is useful for an old editor, embedded display, or instrument that cannot load SVG, but the output has fixed dimensions and cannot scale like the source. Keep the SVG as the editable master.
SVG to GIF
An SVG is instructions, not pixels: paths, fills and text that a renderer draws at whatever size you ask for. A GIF is a grid of palette indices at one fixed size. Converting means committing to a resolution and to at most 256 colors, and once committed there is no scaling back up. Flat vector art survives this well; a gradient-heavy illustration does not.
SVG to JPG
An SVG is a set of drawing instructions with no size of its own — it is as sharp as whatever renders it. A JPG is a fixed grid of pixels. Converting means choosing a size and living with it, so the only real question on this page is what resolution you need.
SVG to PNG
An SVG has no pixels until something draws it, so converting one is really a question of what size to render at. Choose a multiple of its own size, a fixed width, or exact dimensions, and the file is rendered fresh at that resolution by your browser's own vector engine. Transparency is kept unless you ask for a background.
SVG to TIFF
SVG stores instructions for drawing shapes; TIFF stores pixels and workflow metadata. SVG to TIFF is therefore a rasterization step with a file-format step attached. The renderer paints the SVG at its intrinsic canvas size, then the server writes one TIFF image that an editor, print application, or document workflow can import. The output is useful when a raster handoff is required, but the original SVG remains the editable and resolution-independent master.
SVG to WEBP
SVG is a description of shapes and WEBP is a grid of pixels. Converting between them is therefore a rendering decision before it is an encoding decision: the SVG viewport and dimensions determine how much of the drawing is rasterized, while the WebP output fixes that result at one size. WebP is useful for delivery, but a vector source should remain SVG whenever the consumer can use it.
TGA to JPG
A TGA is uncompressed pixels with an alpha channel; a JPG is compressed pixels with none. This conversion is worth doing when a form, an upload or an old piece of software will take nothing else — and worth avoiding when the file is a texture or a render you will use again.
TGA to PNG
Targa is a 1984 format that refuses to die, because it does one thing very well: store pixels and an alpha channel with almost no cleverness in between. Game engines, 3D renderers and texture pipelines still write it. Almost nothing else opens it. PNG does the same job and is read by everything.
TGA to WebP
A TGA on a web page is a file nobody can see — no browser has ever read the format. WebP is the opposite end of the same problem: built for browsers, aggressively small, and one of the few lossy formats that keeps an alpha channel. For putting renders and texture previews online, it is the right target.
TIFF to AVIF
TIFF is a flexible home for scans, print images, and high-quality production data, but it is a heavy web or interchange asset. AVIF can make a modern delivery copy much smaller while retaining convincing photographic detail. This conversion is intentionally a derivative workflow: AVIF uses a lossy quality setting here, and a multi-page TIFF contributes only its first page because one AVIF result contains one raster image.
TIFF to BMP
TIFF is built for flexible imaging workflows, while BMP is still encountered in older Windows applications, control panels, and devices with a minimal decoder. This conversion is for that concrete compatibility requirement. It decodes the first image in the TIFF and writes a static 24-bit BMP, so a multi-page scan becomes page one only. The result is intentionally larger and less expressive than many TIFFs, but its predictable bitmap layout can be exactly what a legacy consumer expects.
TIFF to GIF
TIFF is an archival container: it can hold many pages, sixteen bits per channel, and a color profile. GIF holds one frame, eight bits of palette index and nothing else. This conversion is therefore a deliberate narrowing, and it is worth knowing which parts are dropped before you rely on the result.
TIFF to JPG
TIFF is what scanners, microscopes and archives write when nobody has told them to economise. The files are enormous and open in almost nothing outside a photo editor, which is why this conversion exists — you are trading an archival master for something you can actually send.
TIFF to PNG
TIFF comes from scanning and print, and it is less a format than a family of them — a container that can hold almost any kind of image data, which is exactly why no browser will open one. PNG is the lossless format browsers do read, so this conversion loses no image quality at all. What it can lose is everything around the image.
TIFF to WebP
TIFF is excellent at holding scans and production images, but it is a poor thing to send to a browser. WebP turns the first image in a TIFF into a compact web asset that browsers can display, with the expected cost of lossy compression. This is a delivery derivative, not an archive replacement, and a multi-page TIFF needs special attention because only its first page becomes the WebP.
WebP to AVIF
Both formats are modern, both compress well, and both are supported by every current browser. AVIF is usually the smaller of the two, but the margin is narrow enough that this is the one conversion on this site where the honest answer is often "leave it alone" — and the page explains when it is not.
WebP to BMP
WebP is efficient and modern, but a surprising amount of established software still expects a bitmap. BMP is a practical escape hatch for a vintage editor, a label printer, a hardware utility, or an import dialog that only understands familiar Windows image formats. The trade is substantial: decoding a lossy WebP and writing an uncompressed or lightly compressed BMP can make the output huge.
WebP to GIF
This is a downgrade, performed on purpose. WebP is better than GIF by every technical measure, and none of that helps when the upload form rejects it. The animation survives; the file size does not.
WebP to HEIC
WebP is the practical web format and HEIC is the practical camera format for much of Apple's ecosystem. Moving between them is not automatically an upgrade: the destination may fit an Apple library better, but the source has already been encoded and a lossy HEIC export makes another approximation. This page is for a real device or library requirement, not for chasing a newer extension.
WebP to ICO
WebP is a good source image, but it is not an icon container. A favicon needs several small drawings so a browser or operating system can choose a sensible one. This conversion rasterizes your WebP separately at 16, 32 and 48 pixels, then packages those images as one ICO file instead of merely changing a suffix.
WebP to JPG
You saved an image from a website and got a file ending in .webp that your photo editor, your printing service, or the form you are filling in refuses to accept. This converts it to an ordinary JPG, in batches. It also explains where WebP files come from, because knowing that makes them much less annoying.
WebP to PNG
Converts WebP files to PNG while keeping the transparency intact, which is the reason to choose PNG over JPG as the destination. Useful for logos, icons, stickers and product cutouts saved from the web that need to sit on a colored background rather than a white rectangle.
WebP to SVG
Turn a WebP into an SVG of traced paths when the source is a simple icon, badge, or drawing. This is a raster-to-vector trace, not a magic recovery of the design file. WebP compression, color, shading, and transparent pixels are reduced to a thresholded shape before the scalable outline is written.
WebP to TIFF
WebP is a delivery format; TIFF is a working-file format. Converting between them makes sense when an editor, print workflow, or archive intake form insists on TIFF, not because TIFF can recover detail that WebP already discarded. The output stores the decoded pixels without another lossy WebP-style pass, and that safety comes with a much larger file in many cases.
Document and PDF converters
Word, OpenDocument, RTF, HTML, Markdown, plain text and PDF. The hard direction is out of PDF, and each page here says how well it goes.
CHM to HTML
Converting CHM to HTML is useful when the text of an old help system needs to enter a browser editor, documentation repository, or content migration. It is also easy to misunderstand: a CHM normally contains many HTML topics plus stylesheets, images, navigation data, and other resources, while a download named HTML is one document. This route extracts a readable HTML topic as a practical starting point. It does not promise to merge an entire help system into one website, repair every relative link, carry every CSS rule, or include every asset beside the returned file. The source must already be accessible; no DRM is removed, decrypted, or bypassed.
CHM to PDF
A CHM file is a compiled help collection, not a stack of PDF pages waiting for a different extension. It usually contains HTML topics, a table of contents, style sheets, images, and an index packed into Microsoft's help container. Converting CHM to PDF is useful when you need a print copy, a citation-friendly archive, or a file that opens on a machine without a CHM viewer. The result is a new fixed-layout rendering. It can preserve readable topics and ordinary images, but it cannot promise that every browser-era style, script, link, or asset will look exactly as it did in the original help application. Use a readable file that you are allowed to convert.
CHM to TXT
Plain TXT is a useful destination when the goal is search, indexing, quotation, or long-term text inspection rather than visual reproduction. A CHM help file has richer ingredients: HTML topics, headings, links, CSS, images, tables, and a navigation hierarchy. Converting it to TXT keeps the readable words while intentionally dropping most presentation. The route is therefore a text extraction aid, not a way to preserve a manual's appearance. It first reads an accessible CHM, extracts HTML, and converts the selected content to plain text. No DRM is removed or bypassed, and no guarantee is made that every topic, asset, or viewer-generated label will appear in one output file.
CSV to PDF
A CSV has no page. A PDF is nothing but pages, so the conversion has to decide where the rows break and what happens to columns that do not fit the width. Narrow files come out looking like a report; a file with thirty columns needs a landscape page or a smaller subset before it is worth printing.
DOC to DOCX
The jump from .doc to .docx in 2007 was not a version bump. It replaced a binary format nobody outside Microsoft fully understood with a zip archive of XML that anyone can read, and files from the old era are now old enough that opening them at all is becoming a question.
DOC to HTML
Turning a legacy .doc into HTML is a migration of content, not a one-click website launch. The old binary file can contain headings, paragraphs, tables, lists, links, and images that a browser can represent as elements. It also contains page margins, print headers, floating boxes, and theme decisions that belong to a word processor. The export gives a web-shaped starting point; your site's CSS, asset pipeline, and accessibility review still own the finished page.
DOC to ODT
A DOC file can be perfectly readable and still be a poor long-term handoff. It belongs to Word's older binary document era, while ODT is an openly specified format designed for editable interchange among LibreOffice, OpenOffice, and other office suites. Converting is a practical way to move an inherited memo, minutes file, or community document into an open workflow. It is a translation, not a promise that every old drawing or page break has an identical twin.
DOC to PDF
A DOC file belongs to Word's older binary era, but the reason to convert it is the same as with any finished document: PDF gives the recipient pages instead of a set of layout instructions. That is especially useful for inherited forms, archived reports, old invoices, and attachments that must look stable outside Word. The converter reads the binary Word input with LibreOffice and exports a real PDF. It does not repair obsolete macros, recreate missing fonts, or turn a fixed copy back into an editable master, so retain the original while checking the rendered pages.
DOC to RTF
A .doc file is an opaque binary from the pre-2007 era, and that opacity is its problem: it can hold macros, it cannot be inspected without Word, and a damaged one gives up nothing. RTF holds the same formatting as readable text. Converting is how a document leaves a format nobody wants to keep depending on.
DOC to TXT
A .doc file contains much more than the sentences you can see: fonts, paragraph rules, page geometry, pictures, fields, comments, and binary-era layout instructions. TXT has room for characters and line breaks only. DOC to TXT is therefore a deliberate act of removal, useful when a search index, script, or archive needs the words and nothing that describes their appearance.
DOCX to DOC
DOCX to DOC is a compatibility export, not a simpler way to save the same file. DOCX is an Open XML package designed around modern Word features; DOC is the older binary compound format used by Word 97 through 2003. The conversion can make a file usable by an old reader, but the old vocabulary cannot express every thing the newer document contains.
Word to HTML
DOCX to HTML is best understood as a content extraction route, not a way to reproduce a Word page in a browser. A Word file has headings, paragraphs, lists, tables, links, and emphasis that can become useful HTML elements. Its page margins, theme rules, floating layout, and embedded document assumptions belong to a different presentation system. The result gives you editable web structure to style in your own site, while CSS and image delivery remain work you must inspect or rebuild.
DOCX to JPG
DOCX is designed for editing and document exchange; JPG is designed for broad image compatibility. This converter bridges those jobs by opening the DOCX with LibreOffice, exporting an intermediate PDF, and rendering only the first page as a JPEG. It is useful for an email preview, listing image, approval card, or form that refuses Office files. The result is one flattened picture, not a JPEG set for the whole document. Later pages are intentionally omitted. JPEG compression can soften small type and thin lines, and the layout can differ from a Microsoft Word screen when fonts or floating objects are interpreted by LibreOffice. Keep the original DOCX or a PDF when the source needs to remain editable, searchable, or complete.
Word to ODT
DOCX is the format most closely associated with Microsoft Word; ODT is the open document format used by LibreOffice, OpenOffice, and many standards-minded workflows. Moving between them is useful when a team wants an editable file that is not tied to one office suite, but the formats do not describe every feature in the same way. The conversion preserves the ordinary document structure and makes the boundaries visible where Word-specific behavior has no direct ODT equivalent.
Word to PDF
A Word file is a set of instructions for laying out text; a PDF is the finished page. Converting fixes the layout so it looks the same everywhere, which is why anything being sent outward — a CV, an invoice, a contract — should go as PDF. One thing genuinely moves during that conversion, and it is worth knowing which.
Word to PNG
A DOCX is an editable Office package, but many upload fields and preview cards accept only an image. This converter makes that handoff by opening the DOCX with LibreOffice, exporting an intermediate PDF, and rasterizing the first PDF page as a PNG. The result shows the page as a flat picture, which is useful for a cover, thumbnail, approval preview, or image-only form. It is intentionally a first-page converter: a document with twenty pages still returns one PNG for page one. Text is no longer selectable in the image, and fonts, floating objects, and unusual Office features can render differently from Microsoft Word. Keep the DOCX when editability or later pages matter.
Word to RTF
RTF is not a modern replacement for DOCX. It is a deliberately broad handoff format: many old editors, mail programs, records systems, and word processors can read it without understanding Microsoft's newer package format. That reach comes with a visible tradeoff. A DOCX can carry a large style system, floating objects, revisions, fields, and application-specific features; RTF represents a smaller common vocabulary. Use this conversion when opening the text matters more than preserving every design instruction, and keep the DOCX as the editable master.
Word to TXT
This conversion is deliberately destructive. A .docx is a zip full of XML describing fonts, styles, revision history and layout; a .txt is a sequence of characters. Everything in the first that is not a character is discarded, and that is the entire point.
EPUB to PDF
An EPUB has no pages. Text reflows to whatever screen it lands on, which is why it reads well on a phone and why "page 47" means nothing in one. Converting to PDF freezes that text onto a fixed page — useful for printing or annotating, and a downgrade for reading on anything small.
HTML to DOC
The .doc format is Word's binary format from before 2007, and almost nobody chooses it any more. What keeps it alive is systems that were built around it and never updated: old case management, some government upload forms, and templates nobody dares touch. This conversion exists for those, and the honest framing is compatibility rather than quality.
HTML to Word
HTML and a Word document describe the same things in different vocabularies — headings, paragraphs, tables, lists, emphasis. That correspondence is why this conversion works well. What has no counterpart is everything a stylesheet says, and that is why the result arrives looking nothing like the page.
HTML to Markdown
HTML to Markdown is for turning a document tree into source that a person can read and edit. Instead of preserving angle-bracket tags, the result uses familiar Markdown markers for basic headings, paragraphs, emphasis, links, lists, and simple code. That makes a page easier to move into a README, issue tracker, documentation repository, or version-controlled writing workflow. The conversion is a pure-code text transformation, so it works on the HTML file supplied rather than visiting a URL or reconstructing a complete website. It does not have the page's CSS, browser state, remote images, scripts, custom components, or site-specific Markdown plugin. Basic constructs have the clearest mapping; complex tables, layout wrappers, embedded widgets, and decorative navigation deserve a source review. Treat the result as an editable Markdown draft and keep the original HTML when exact rendering or later reconciliation matters.
HTML to ODT
ODT is the text document format of the OpenDocument standard, native to LibreOffice and readable by Word. Its appeal is that it is a documented, ISO-registered ZIP of XML rather than a vendor's binary, which is why public bodies and archives often prefer it. Converting HTML into it produces an editable document rather than a fixed page.
HTML to PDF
HTML is written for a viewport that can reflow; PDF is delivered as pages that cannot. Converting HTML to PDF is useful for a saved report, invoice, article, or documentation page that needs a stable attachment or print handoff. The result aims at a web-shaped reading experience, with the markup laid out by LibreOffice and exported into fixed pages, but it is not a pixel-for-pixel browser screenshot. The input is a file upload, not a live URL, and the converter cannot reach a folder of local images, a stylesheet sitting beside the page, or external web assets that were not included. Basic structure and some styling may survive; complex CSS, scripts, responsive behavior, and missing resources deserve a visual check on the actual PDF.
HTML to RTF
RTF is unusual among document formats in being plain text you can open in a text editor and read. Bold is a visible control word, not a byte in a binary structure. That transparency is why it survives as the interchange format of last resort: mail clients, ancient word processors, legal document systems and clipboard exchanges all understand it when they understand nothing else.
HTML to TXT
HTML to TXT is a semantic extraction task, not a screenshot flattened into characters. The source describes a document tree with headings, paragraphs, lists, links, tables, and other elements. The plain-text result keeps the words and a useful reading sequence while dropping tags, styling, and browser behavior. That makes it a practical handoff for search indexes, command-line review, data imports, accessibility checks, and archives that need readable text instead of a page shell. A pure-code transformation does not browse to a URL or fetch a page's remote dependencies: it works from the HTML file supplied to it. Basic HTML is the reliable boundary. Review unusual table markup, hidden content, embedded data, and whitespace-sensitive code after conversion, because plain text cannot carry every visual or semantic distinction that a browser can render.
Markdown to DOC
Markdown is written for review and version control; .doc is read by systems built before either mattered. Converting between them usually means a document that lives in a repository has to be submitted somewhere that accepts only the old binary Word format. The structure transfers cleanly, because everything Markdown can express has a Word equivalent.
Markdown to Word
Markdown is written by people who like plain text and read by people who want a document. This conversion is the handover — and it is a real one, in that a `##` becomes a Word Heading 2 rather than a line that happens to be larger.
Markdown to HTML
Markdown to HTML turns an easy-to-edit text source into a browser-readable document structure. It is useful for README previews, release notes, documentation drafts, static publishing pipelines, and small pages that do not need a full site generator. The transformation is deliberately lightweight: common headings, paragraphs, emphasis, links, lists, and code become basic HTML, while source text is escaped so characters that resemble tags do not become unexpected browser instructions. This is a pure-code operation on the Markdown file you upload. It does not fetch remote images, execute embedded scripts, import a theme, or reproduce a framework's component system. Basic Markdown is the dependable input; flavor-specific directives, raw HTML, complex tables, front matter, and asset paths require a review. The output is a static structural handoff, not a complete deployed website. Add your own CSS, metadata, accessibility decisions, and vetted assets when the HTML is ready for a real publishing destination.
Markdown to ODT
Markdown carries structure and no presentation, and OpenDocument separates structure from presentation by design. That makes them an unusually good match: the headings, lists and tables land as real document constructs, and the appearance comes from the template rather than from anything the Markdown tried to specify.
Markdown to PDF
Markdown is comfortable to write, review, and store beside code, but it does not contain a paper size or a final page break. PDF is useful when that same content needs to become a handout, release note, approval attachment, or print-ready reference. This conversion parses ordinary Markdown into a document and exports fixed pages, so headings, emphasis, lists, links, tables, and fenced code can be handled as document content instead of leaving punctuation on the page. It is still a parser and layout conversion, not a screenshot of a rendered documentation site. Flavor-specific syntax, relative images, custom themes, unavailable fonts, very wide tables, and long code lines can lose meaning or move across pages. Keep the .md source, inspect the PDF at its intended size, and fix the source before regenerating a final copy.
Markdown to RTF
Markdown and RTF solve different problems. Markdown is a lightweight notation that stays readable in a text editor and works well in version control; RTF is an older, richer interchange format that many office programs and legacy mail or form systems can still open. Converting Markdown to RTF is a practical bridge when the recipient needs an editable rich-text file rather than source markup. Recognized headings, emphasis, lists, links, tables, and code can become document content, but the result is not a copy of a Markdown website's theme. Flavor-specific directives, relative images, syntax colors, metadata, and carefully authored layout may be lost or simplified. Keep the .md file as the maintainable original, use the RTF as the receiving application's handoff, and apply final formatting where the older workflow actually understands its audience.
Markdown to TXT
Markdown to TXT is a cleanup step for systems that need words rather than authoring syntax. It turns familiar markers such as heading hashes, emphasis delimiters, link punctuation, and list prefixes into a readable plain-text sequence. That is useful for search indexes, previews, text-only exports, import feeds, transcripts, and small programs that should not need a Markdown parser. The operation is a pure-code transformation of the Markdown file you supply. It does not resolve a repository, visit a linked page, download an image, execute a fenced script, or infer the visual design of a documentation site. Basic Markdown is the reliable input, while tables, raw HTML, task syntax, footnotes, front matter, and flavor-specific directives may need inspection. Keep a copy of the original source when the document may be edited later: TXT is a useful derivative for plain-data consumers, but it cannot preserve the full outline, link destination, code styling, or image meaning on its own.
OCR PDF
Make a scanned PDF searchable by rendering each page locally, recognizing printed text with Tesseract, and adding an invisible text layer over the original page image. The visual scan is retained, while browser search, text selection, screen readers, and downstream PDF text extraction have a text layer to use. You can also copy or download the OCR text. The first run loads the OCR engine and English model. Accuracy depends on resolution, lighting, skew, language, layout, and handwriting; this is a reviewable convenience conversion, not a promise that every character or table is correct.
ODT to DOC
ODT is an open, structured standard; DOC is the older binary format associated with Word 97-2003. Converting from the first to the second is usually an interoperability concession: a department, upload portal, or old desktop application accepts DOC and rejects the open format. LibreOffice can translate the common document model, but the destination cannot express every ODT feature. Keep the ODT master and inspect the binary handoff before sending it as if nothing changed.
ODT to DOCX
Nothing is wrong with your file. ODT is an international standard and Word can even open it. The problem is social rather than technical: the person you are sending it to opens attachments by double-clicking, and an unfamiliar extension turns a document into a support request.
ODT to HTML
ODT to HTML is a useful bridge when an OpenDocument Text file contains material that needs to become a web article, knowledge-base entry, or editable CMS draft. The conversion can expose headings, paragraphs, lists, tables, links, and ordinary images as web-shaped content. It cannot know your site's CSS, responsive breakpoints, asset URLs, accessibility rules, or component vocabulary. That makes the result a structured starting point rather than a finished publication. Preserve the ODT as the authoring source, then review the generated markup where it enters the web stack.
ODT to PDF
ODT is an open, editable document format; PDF is a fixed-page delivery format. Converting between them is useful when a LibreOffice or OpenOffice document needs to leave the editing workflow for a print queue, an application portal, a client, or a long-term record. The export keeps the visible document content while making page decisions explicit. It still deserves a review: fonts, page styles, fields, anchored objects, and layout engine differences can move a break even when the source is standards-based. Keep the ODT as the master if anyone may need to edit it.
ODT to RTF
ODT is the better format and RTF is the more accepted one. That tension is the whole reason for this conversion: a document written in LibreOffice sometimes has to reach someone whose software predates OpenDocument entirely, or a system that lists RTF among four formats it will take. The document survives the trip; a handful of OpenDocument-specific features do not.
ODT to TXT
ODT is open and structured, but a search index or preservation script may still need something simpler than a ZIP package of XML. ODT to TXT produces a linear text copy for indexing, comparison, and long-lived retrieval. It deliberately leaves behind styles, page geometry, pictures, and other presentation signals. That makes the derivative easier to search and harder to mistake for a faithful visual record.
PDF to DOC
PDF to DOC is a practical bridge for a team that still receives work in the older Word format. It can turn selectable words from a report, letter, or policy into an editable DOC that a compatible office suite can open. The route is intentionally narrower than a visual reconstruction: PDF text is extracted first, so layout and graphics are not preserved. Page coordinates, font choices, photographs, annotations, columns, and many table relationships are left behind before the DOC writer sees the content. A searchable PDF is the right input; a scan without a text layer may produce a sparse file. Use the result as an editing draft, keep the original PDF, and compare important wording before the DOC becomes a controlled record.
PDF to Word
PDF to DOCX gives the text layer of a PDF a new home in an editable Word document. It is useful for revising ordinary prose, searching a contract, or handing a text-heavy report to someone who works in Word. It is not a faithful PDF reconstruction. This server route extracts text first, then asks the document converter to write that text as DOCX. The intermediate text step means the original page geometry, fonts, images, annotations, columns, headers, and table structure are not preserved as a designed page. A scanned PDF may yield an empty or sparse document because extraction is not OCR. Treat the result as an editing starting point and compare it with the source before publishing or signing anything.
PDF to HTML
PDF to HTML is for moving words from a finished document into a web editing or indexing workflow. It can make selectable text available inside HTML paragraphs and give a content team something easier to search, sanitize, and place in a CMS than a PDF attachment. It is not a PDF viewer and it does not create a finished web page. PDF text is extracted first, so layout and graphics are not preserved. The output does not know your CSS, responsive breakpoints, image storage, navigation, or accessibility rules. A searchable article can be a useful starting point; a scan, brochure, form, or visually exact publication needs OCR or a different migration method. Keep the PDF as the visual reference while you shape the HTML for its destination.
PDF to ODT
PDF to ODT suits an open-document workflow that needs to continue editing words in LibreOffice, OpenOffice, Collabora, or another compatible suite. It can turn ordinary selectable text into an ODT package with paragraphs and editable document defaults. The source is still a finished page description, not an ODT outline waiting to be unpacked: PDF text is extracted first, so layout and graphics are not preserved. That means page margins, photos, charts, floating frames, exact columns, annotations, and complex table geometry require separate work. Searchable letters and reports are better candidates than scans or designed forms. Keep the PDF as the reference, inspect the ODT in the suite that will own the next edit, and apply intentional styles before sharing it.
PDF to PowerPoint
PDF to PPTX creates a one-slide presentation from extracted PDF text. It is useful when a presenter needs a quick text brief, a discussion prompt, or a temporary container for words copied from a report. The worker reads the PDF text layer and places the resulting lines into one simple slide; it does not create a slide deck that mirrors the source document. Original tables, page layout, images, and charts are not reconstructed. A multi-page report therefore does not become one slide per page, and a designed presentation PDF does not become editable shapes with the same positions or styling. Scans without a text layer need OCR first, and OCR can introduce errors. Review the slide against the PDF, shorten or reorganize the material for the audience, and add approved visuals manually before presenting it as more than a rough text outline.
PDF to RTF
RTF is a useful middle ground when the recipient needs editable rich text without committing to one modern office package. PDF to RTF can move selectable prose into a file that many editors and document systems understand. Its boundary is important: PDF text is extracted first, so layout and graphics are not preserved. The generated RTF can hold text and basic document formatting, but it does not receive the original page's artwork, exact columns, positioned objects, annotations, or reliable table grid. A searchable memo or meeting record is a reasonable input; a scan, designed form, or illustrated catalog is not. Keep the PDF beside the RTF and use the result as a portable draft that still needs a human reading pass.
PDF to SVG
Convert the first page of a PDF into an SVG made from traced paths. The server renders that page to a bitmap, thresholds it, and follows the resulting regions; it does not extract the PDF's original text, fonts, or vector commands. This can help with a simple black-and-white diagram, but it is intentionally not sold as a lossless PDF-to-SVG export.
PDF to TXT
PDF to TXT turns the readable text layer of a PDF into an ordinary text file. That is useful when you need to search a report with command-line tools, paste its contents into a script, or keep a lightweight copy for indexing. It is not OCR and it is not a design-preserving export. The server uses a PDF text extractor with a layout-aware mode, then writes the result as plain text. A scanned PDF may have no characters at all, even when its pages look full, because a photograph of a page is not a text layer. Columns, tables, headers, and reading order also deserve a quick review before the TXT file becomes the authoritative copy.
PDF to XLSX
PDF to XLSX is a text handoff for spreadsheet users, not an automatic table-recognition service. The worker extracts characters from the PDF and writes each non-empty extracted line into a simple worksheet, one line per row in a single column. That can give an analyst searchable text to sort, copy, annotate, or use as a starting point for a real model. It does not reconstruct the original tables, layout, images, or charts. A PDF that looks like a grid still supplies a visual page description rather than dependable spreadsheet cells. Scanned pages need OCR before this route can see their words, and even OCR cannot restore the source's intended columns or formulas. Keep the PDF open beside the XLSX, validate important numbers, and treat the workbook as an extraction draft rather than a finished financial or operational spreadsheet.
RTF to DOC
RTF already exists as a broad interchange format, so converting it to legacy DOC is mainly about satisfying the next system's age or upload rule. Word 97-2003 binary DOC may still be required by an old portal, a line-of-business application, or a desktop installation that cannot accept DOCX or does not handle RTF reliably. LibreOffice can translate common rich text into that older document model. The target has stricter limits, however: newer styles, modern controls, unusual fields, and precise object placement may simplify or change. Keep the RTF source and test the DOC in the actual receiving workflow before calling the compatibility copy complete.
RTF to Word
RTF is a practical interchange language for moving readable formatting between many generations of software. DOCX is a packaged, modern editing format with stronger structures for styles, relationships, tables, comments, and current Word workflows. Converting RTF to DOCX can turn an old attachment, mail-merge result, or records export into a document people can continue editing comfortably. It is not a promise that an RTF-specific quirk or every visual position will gain a perfect modern equivalent. Use the DOCX as a new working copy, compare the parts that matter, and retain the RTF when its source history or broad compatibility still has value.
RTF to HTML
RTF can carry enough meaning for an old document to become a useful web draft, but it does not carry your website. Converting RTF to HTML can expose paragraphs, headings, lists, links, tables, and common images as elements that an editor or CMS can revise. The exported file does not know your CSS framework, content model, URL scheme, accessibility standards, or responsive breakpoints. It may also refer to images or use inline styles that are unsuitable for production. Treat the result as a structure-and-content handoff: inspect the markup, move companion assets into the destination pipeline, apply the site's design system, and preserve the RTF until the web version has been reviewed.
RTF to ODT
RTF is useful as a broad interchange format, especially when a file has passed through older editors or a mixed software estate. ODT is an open-standard document package built for continued editing in LibreOffice, OpenOffice, Collabora, and other compatible tools. Converting RTF to ODT is a sensible way to put an inherited document into an open authoring workflow without keeping its old control-word vocabulary as the active source. The result is an editable document, not a visual photocopy: straightforward text, emphasis, lists, and tables usually have good destinations, while application-specific fields, floating objects, and exact page tricks need inspection. Keep the original RTF beside the new ODT when provenance or a fallback reader matters.
RTF to PDF
RTF is designed to carry editable rich text between programs; PDF is designed to show a settled page to a reader. Converting RTF to PDF is therefore a practical last step for email attachments, approval packets, invoices, print queues, and records that should look consistent on different screens. Paragraphs, emphasis, lists, tables, and ordinary images usually have clear rendering paths. Fonts, page breaks, headers, fields, and older RTF constructs can still affect the final pages. Review the PDF as a reader will see it, and keep the RTF when future edits or content extraction remain possible.
RTF to TXT
RTF is a text-based interchange format, but its visible words are surrounded by control words describing fonts, colors, paragraphs, pictures, fields, and layout. TXT removes that surrounding document vocabulary and leaves a stream of characters. That is destructive by design. The result is often exactly what a search index, command-line tool, diff, or text pipeline needs, because those systems should not have to understand an office document just to find a phrase. It is also a poor substitute for the original when page position, emphasis, images, signatures, or editing structure matter. Keep the RTF and use the TXT as a searchable derivative whose limits are visible rather than as a claim that the document was preserved.
SVG to PDF
Almost every conversion on this site loses something. This one mostly does not. SVG and PDF are both page description languages built on the same primitives — paths, fills, transforms — so the translation is between dialects rather than between kinds of thing.
TIFF to PDF
Document scanners have written multi-page TIFF for decades, and almost nothing a recipient owns will open one. PDF is what a scanned document is supposed to be — same pages, same order, one file, opens everywhere.
TXT to DOC
TXT to DOC exists for the receiving system that still asks for the older Word binary format. A TXT file has almost no document model beyond characters and line breaks, while DOC is a compound binary format designed for Word 97 through 2003 and the software that followed it. LibreOffice can place the plain content into that legacy container, giving an old office suite, records import, or compatibility workflow a file it can open. This is not a way to recover Word styling that was never in the TXT. The output gets a DOC document shell and its default settings; it does not gain trustworthy headings, page design, bold text, tables, or lists by inference. Use the conversion when binary compatibility is a real requirement, and keep the TXT as the authoritative source for exact text and future exports.
TXT to DOCX
TXT to DOCX is a change of container, not an automatic document-design service. A plain text file supplies characters, line endings, and perhaps indentation; it does not say which line is a title, whether a blank line means a new section, or which font and margins a reader expects. The conversion places that material in an editable Word document so it can be reviewed, annotated, and handed to someone who works in DOCX. It deliberately does not infer styling from capitalization, punctuation, or spacing. That restraint keeps a log, transcript, source excerpt, or notes file from being decorated with guesses that look authoritative but were never in the source.
TXT to HTML
TXT to HTML is useful when plain text needs to enter a web workflow, but the result should be understood as a structural publishing draft rather than a finished website. TXT supplies characters and line boundaries. HTML supplies elements, escaping rules, and a document tree that a browser can display. The conversion can place the text into that tree and represent its line structure, while keeping characters that resemble tags or entities as text instead of allowing them to become accidental markup. It cannot know which line is a heading, whether indentation is code, or which CSS belongs to your site. Review the generated HTML, apply your own styles and sanitization policy, and keep the TXT source when exact text and easy regeneration matter.
TXT to ODT
TXT is a good source format when the content needs to stay simple, searchable, and easy to process. ODT is useful when that content now needs an open, editable document with page settings, paragraph styles, and a file that LibreOffice, OpenOffice, and other compatible suites can open. Converting TXT to ODT makes that change of workspace without pretending that the source contained a finished design. The words and explicit line flow can move into an editable document, but plain text does not say which line is a title, which phrase is bold, or where an image belongs. Treat the result as a clean document starting point: review its spacing and page layout, then apply intentional styles in the editor while keeping the original TXT as the exact source.
TXT to PDF
A TXT file is intentionally unconcerned with paper. It stores characters and line breaks, while a PDF must decide what fits across a page, which font draws each character, and where a page ends. Converting TXT to PDF is useful when a log, transcript, README, code sample, or plain report needs a stable attachment or print handoff. The converter turns the text into a real fixed-page document, not a screenshot of one screen. That stability comes with choices: long lines may wrap, preserved newlines may create deliberate blank space, and a proportional font may change the alignment of columns or code. Review the pages at their intended size and keep the original TXT for searching, editing, and regenerating the PDF after corrections.
TXT to RTF
TXT to RTF wraps plain characters in a format that many word processors, mail tools, and older editors can exchange. That can be useful when the receiving application accepts RTF but does not have a comfortable plain-text import. The important limitation is that RTF can describe rich text, while the TXT source does not contain rich formatting to preserve. The conversion can create the RTF control vocabulary and a basic editable document, but it cannot know which words should be bold, which line should be a heading, or where a table and image belonged. Think of the result as an interoperable text handoff with a richer container, not as a designed document. Keep the TXT for exact comparison and add intentional formatting in the application that owns the content.
WebP to PDF
Nobody sets out to have a WebP. It is the format the web hands you when you save a picture, and the trouble starts the moment that picture has to go somewhere that is not a browser — an email, a print shop, a form that wants a document.
XML to HTML
XML to HTML turns a structured XML file into a document that is easier for a person to read in a browser. It is useful for inspecting a supplier feed, reviewing an export before mapping it, sharing a compact diagnostic artifact, or making nested records understandable to someone who does not want to scan angle brackets. The built-in transform handles ordinary nested elements and attributes, presenting hierarchy and repeated data in readable HTML structures such as labeled blocks, lists, or table-like record views where the input shape supports them. The result is an inspection document, not a branded web page or a stylesheet-driven publishing system. It does not run XSLT, execute scripts, fetch external CSS or images, validate an XML schema, or know which business fields deserve special formatting. Mixed content, namespaces, deep irregular branches, and very large feeds may still need source-level review. Upload the XML file itself, download the generated HTML, and open it locally or in a controlled preview. Keep the source beside the result when the exact machine-readable document remains authoritative.
XML to JSON
XML to JSON is a useful bridge when a structured document needs to enter an API, a JavaScript application, a configuration review, or a data-processing script. The converter reads ordinary XML nesting and produces a JSON representation that is easier to inspect with modern tooling. Repeated sibling elements are treated as collection-like data, while element attributes remain available in the resulting structure instead of disappearing with the angle-bracket markup. That makes this tool more useful than simply stripping tags, but it does not make XML and JSON identical models. Mixed text and child elements, namespaces, comments, processing instructions, schemas, and unusual vendor conventions may need a careful look after conversion. The built-in transform is a practical parser for ordinary nested elements and attributes, not an XSLT engine. It does not apply stylesheet templates, run XPath programs, validate an external schema, or fetch remote entities. Upload the XML you want to transform, inspect the JSON shape, and keep the original when a downstream system needs exact document fidelity.
XML to TXT
XML to TXT removes the document syntax so the words inside an XML file can be read, searched, diffed, or passed to a plain-text workflow. It is a useful derivative for logs, quick review, indexing, notes, and systems that need text rather than a tree of elements. The built-in transform walks ordinary nested elements, extracts their text in document order, and drops markup such as opening tags, closing tags, and attribute syntax. That last point is important: attributes describe data but are not normally text content, so identifiers, flags, and units may not appear in the TXT output unless their values are also written as element text. This is not an XML canonicalizer, schema validator, or XSLT engine. It does not preserve hierarchy, namespaces, comments, processing instructions, or visual table boundaries as faithfully as the source. It also does not fetch external entities or execute anything in the uploaded file. Use the plain output when readability is more important than structure, and retain the XML when a later consumer needs attributes, repeated-record relationships, exact order, or machine validation.
XPS to JPG
XPS was designed to preserve a printed page, not to be a convenient attachment in 2026. This converter turns the first page into a JPG for a ticketing system, email, listing, or preview field that accepts common images and rejects XPS. The server calls the libgxps JPEG renderer at its default 150 PPI setting and emits one image. That first-page limitation is important: a multi-page XPS does not become a complete image archive here. JPG is compact and widely accepted, but it is lossy, so retain the original when the page is an archive master.
XPS to PDF
XPS was Microsoft's answer to PDF, and it lost. What remains is a long tail of files produced by the virtual printer that shipped in Windows for a decade, sitting in archives and shared drives, increasingly hard to open on the machines that made them.
XPS to PNG
XPS is a fixed-page document format that can be perfectly clear in theory and almost impossible to use in practice. This converter renders page one as a PNG image so it can go into a thumbnail slot, an image-only form, a slide, or a message that refuses document files. It is deliberately a first-page server converter: a 40-page XPS produces one PNG, not 40 downloads. The page is rasterized at the renderer's default 150 PPI, so text and vector artwork become pixels. Keep the XPS when you need selectable text or later editing.
XPS Viewer
Open an XPS or OXPS file here and read it, page by page, without installing anything. Windows dropped XPS Viewer from its default install in 2018, so a file that used to open on a double-click now presents as something the computer does not recognize — which is a problem about a missing viewer rather than about a broken file. The document is intact; nothing on the machine will show it to you.
Video converters
Containers and codecs — MP4, MOV, MKV, AVI, WebM and the rest. Each page says whether the pair repackages the existing streams untouched or re-encodes them, because that is the difference between no quality change and some.
3GP to MP4
Convert a 3GP recording into an MP4 that plays on a modern phone or computer. 3GP was the video format of mobile phones before smartphones — built to be small enough to send in a picture message over a 2G network, which is why the clips are tiny, low-resolution, and frequently the only surviving footage of something from the mid-2000s.
AVI to GIF
Turn a clip from an old AVI into a looping GIF. This pair works better than most, for an unexpected reason: AVI footage is nearly always standard definition and already heavily compressed, so the limits a GIF imposes — 480 pixels wide, twelve frames a second, 256 colors — take away much less than they would from modern video.
AVI to MKV
Move an old AVI into an MKV container without re-encoding anything. The video and audio streams are copied straight across, so the result is bit-for-bit the same picture and sound and it finishes in seconds. This does not modernize the codecs inside — it puts them in a container that can carry subtitles, several audio tracks and proper timing, which AVI cannot.
AVI to MP3
Pull the soundtrack out of an AVI as an MP3. The picture is discarded rather than converted, which is why this finishes in seconds on a file that would take minutes to convert as video. AVI has one quirk worth knowing before you start: its audio is very often already an MP3 sitting inside the container, so what you are doing is frequently a re-encode of something that was already the format you asked for.
AVI to MP4
Convert an AVI into an MP4 that a phone, a browser or a smart TV will play. AVI is a Microsoft container from 1992, and the files that survive are usually old camcorder footage, ripped discs or downloads from an era when DivX and Xvid were the codecs everybody used. Those codecs are the actual problem: modern devices dropped support for them long before they dropped support for the container.
AVI to WebM
Re-encode an old AVI as a WebM a browser will play. Two problems are being solved at once here: no browser plays the AVI container, and the DivX or Xvid video inside it is a codec modern hardware dropped support for years ago. VP9 fixes both, and old standard-definition footage encodes small and quickly because there is not much of it to encode.
FLV to MP3
Get the audio out of a Flash video as an MP3. Flash was switched off at the end of 2020 and browsers removed the plug-in entirely, so FLV files have no player left — but the recording inside is usually intact, and if what you wanted was a talk, a lecture or a piece of music, the audio is the part worth rescuing.
FLV to MP4
Convert a Flash video into an MP4 you can actually watch. FLV files were made to be played by the Flash plug-in inside a web page, and Adobe switched Flash off at the end of 2020 — browsers removed it entirely, so the player these files were built for no longer exists anywhere. The video inside is usually intact and often already H.264; what has gone is the thing that used to open it.
M4V to MP4
Convert an M4V into a plain MP4 that players and upload forms will accept. M4V is Apple's variant of MP4, used by iTunes and by Apple devices, and the two are close enough that the difference is usually just the extension — which is exactly why the conversion is worth doing, because a great deal of software decides what a file is by reading its name rather than its contents.
MKV to GIF
Turn a clip from an MKV into a looping GIF. There is a practical obstacle with this pair that the others do not have: MKV is the container people use for long, high-quality video, so the file on your disk is frequently a whole episode or film measured in gigabytes. Trim the seconds you actually want before you upload anything.
MKV to M4A
Pull the audio out of an MKV as an M4A. What happens next depends on what is inside, and it is worth knowing which case you are in: an MKV holding AAC — which most web-sourced files do — has its track copied out untouched, bit for bit. One holding AC-3 or DTS, which most films do, is decoded and re-encoded, and its surround channels are folded to stereo.
MKV to MP3
Extract the soundtrack from an MKV and get an MP3. The picture is discarded rather than converted, which is why a two-gigabyte video becomes a few megabytes of audio in seconds. MKV is worth knowing about here for one reason the other video formats do not share: its audio is very often five or six channels of AC-3 or DTS rather than ordinary stereo, and turning that into an MP3 means mixing it down.
MKV to MP4
Matroska is a container, not a codec, and an MKV very often holds exactly the H.264 and AAC an MP4 holds. When that is true the conversion is a repackage: the same streams are written into a different box, with no decoding, no re-encoding and no loss at all. That is why this is one of the fastest conversions here.
MKV to WAV
Extract uncompressed audio from an MKV as a WAV. Two things make this pair different from the other video-to-WAV conversions: MKV usually carries five or six channels of AC-3 or DTS rather than stereo, so the audio is mixed down on the way out, and MKV files are typically long, so the result can be very large indeed.
MKV to WebM
Re-encode an MKV as a WebM that a browser will play. No browser plays MKV — it is a desktop and media-server format — so anything destined for a web page has to change container and usually codec too. This is a full re-encode to VP9 and Opus, which takes real time, and the MKV is very likely too long to upload without trimming first.
MOV to GIF
Turn the first ten seconds of a MOV into a looping GIF. MOV is what an iPhone records and what a Mac screen recording produces, which makes this conversion two quite different jobs wearing the same name — a screen recording becomes an excellent GIF, and phone footage of the real world becomes a mediocre one, for reasons worth knowing before you start.
MOV to M4A
Take the audio out of a QuickTime MOV as an M4A without re-encoding it. An iPhone records AAC inside a MOV, and an M4A is an MP4 container holding an AAC track — so the audio moves across untouched. For a voice memo filmed as video, or an interview recorded on a phone, this gives you exactly what the microphone captured.
MOV to MKV
Move a QuickTime MOV into an MKV container without re-encoding anything. The video and audio streams are copied across untouched, so the result is bit-for-bit the same picture and sound and the conversion finishes in seconds. This takes a file out of Apple's container and into one that desktop players and media servers handle better.
MOV to MP3
Get the audio out of a QuickTime MOV as an MP3. The picture is discarded rather than converted, so an iPhone video of an interview, a lecture or a rehearsal becomes a small audio file in a second or two. This is the commonest thing anyone actually wants from phone video that was never really about the pictures.
MOV to MP4
Convert a QuickTime MOV into an MP4 that Windows, Android and almost every upload form will accept. MOV is Apple's container, and it is what an iPhone and a Mac screen recording produce by default — so the file is usually perfectly good and simply arrives wrapped in something the other machine will not open. The picture and sound inside are often already H.264 and AAC, which is exactly what MP4 carries.
MOV to WAV
Extract uncompressed audio from a QuickTime MOV as a WAV. This is almost always a phone recording on its way into something that will not accept compressed audio — a transcription engine, an older editor, an analysis tool. The picture is discarded and the AAC soundtrack is decoded to raw samples, which is what those tools are asking for.
MOV to WebM
Re-encode a QuickTime MOV to WebM with VP9 video and Opus audio. MOV is what a Mac screen recording and an iPhone produce, and WebM is what you want to be serving from a web page — so this conversion sits at the point where something recorded on Apple hardware becomes something a website delivers, which is a very common path for product demos and documentation.
MP4 to GIF
Turn the first ten seconds of an MP4 into a GIF that plays by itself in chat, in email and in a document. A GIF is not a better video — it is a worse one that needs no player, which is exactly why it survives. Anywhere that will not embed a video will still show an animation, and that is the entire reason to make one.
MP4 to M4A
Pull the audio out of an MP4 as an M4A without re-encoding it. An MP4 almost always holds AAC already, and an M4A is an MP4 container holding an AAC track — so the audio can simply be lifted from one to the other. What you get is bit-for-bit identical to what was recorded, and it takes about as long as copying the file.
MP4 to MKV
Convert an MP4 into an MKV without re-encoding anything. This is the rare video conversion that costs nothing: the existing video and audio streams are copied straight into the new container, so what comes out is bit-for-bit the same picture and sound. Only the wrapper changes, and it finishes in seconds regardless of how long the video is.
MP4 to MP3
Pulling the audio out of a video is not really a conversion of the video at all — the picture is dropped and only the soundtrack is re-encoded. That is why a 36 MB clip becomes a 300 KB MP3 in a fraction of a second, while converting the same clip to another video format takes seconds. If you want the sound of something, this is the cheapest thing you can ask for.
MP4 to WAV
Pull the audio out of an MP4 as an uncompressed WAV. The picture is discarded and the sound is decoded to raw samples, which is what audio editors, transcription engines and analysis tools generally want. It will not sound better than the MP4 did — nothing recovers what an encoder discarded — but it will open in software that refuses compressed audio.
MP4 to WebM
Convert an MP4 into a WebM encoded with VP9 and Opus. This is a conversion for people serving video from their own site rather than for people trying to play a file: WebM is royalty-free and usually smaller than H.264 at the same visible quality, which matters when you are paying for the bandwidth and the visitor is waiting for it to load.
MPEG to MKV
Move an MPEG into an MKV container without re-encoding anything. The video and audio are copied straight across, so the picture is bit-for-bit what it was and the conversion finishes in seconds. For anything ripped from a disc this is the right first move: it preserves the original exactly while putting it somewhere that can hold subtitles and several audio tracks.
MPEG to MP4
Convert an MPEG into an MP4 that a phone or a browser will play. The problem is the codec rather than the container: MPEG-2 dates from 1994, it was designed for DVDs and digital television, and no phone, browser or smart TV ships a decoder for it. Re-encoding to H.264 is what makes the footage watchable on anything made this century.
Subtitle Converter
Convert between SubRip (`.srt`) and WebVTT (`.vtt`) without uploading the subtitle file. The browser validates cue timestamps, preserves cue text and line breaks, writes the target format's timestamp separator, and regenerates SRT numbering. It does not translate dialog, fix overlaps, or promise to preserve every player-specific styling extension, so preview the result in the target media player before publishing.
TS to MP4
Convert a recorded transport stream into an MP4 that plays and seeks properly. A `.ts` file is what a DVR, a TV tuner or a stream downloader produces, and it was designed for broadcasting rather than for storage — which is why players often refuse it, and why the ones that accept it frequently cannot scrub to the middle.
WebM to GIF
Convert a WebM clip into a GIF for software that will not display WebM. This one deserves a warning label, because it goes backwards on purpose: WebM is smaller, smoother, full color and supports sound, and GIF is none of those. You do it because a 1987 image format is understood by things a 2010 video format is not.
WebM to MKV
Move a WebM into an MKV container without re-encoding anything. These two are closer than any other pair on this site: WebM is Matroska with a restricted set of codecs, so this is less a conversion than removing a restriction. The streams are copied across untouched and it finishes in seconds.
WebM to MP3
Take the audio out of a WebM and get an MP3 that plays anywhere. WebM is the web's own video format, which is why almost anything saved from a browser arrives as one — and its audio is Opus or Vorbis, two codecs that are technically excellent and supported by very little outside a browser. That mismatch is the whole reason this conversion exists.
WebM to MP4
WebM was designed for browsers and it does that job well. Everywhere else it is awkward: video editors often refuse it, older phones cannot decode VP9, and plenty of upload forms do not list it. Converting to MP4 re-encodes the picture as H.264, which is the one video codec you can assume anything will play.
WebM to WAV
Decode the audio in a WebM into an uncompressed WAV. WebM carries Opus or Vorbis, two codecs browsers handle well and audio software often does not, so this is usually a recording saved from a browser on its way into an editor or a transcription tool that wants raw samples rather than a codec it has never heard of.
WMV to MP3
Take the audio out of a Windows Media video and get an MP3. The picture is discarded rather than converted, so this is quick — but WMV has a particular reason for existing: the sound inside is almost always WMA, which is as tied to Windows as the video is. Extracting it as MP3 frees the audio from the platform, not just from the video.
WMV to MP4
Convert a Windows Media video into an MP4 that works away from Windows. WMV was Microsoft's answer to streaming video in the early 2000s, and it was designed to work beautifully inside the Windows ecosystem and nowhere else — which is exactly the problem when the file needs to reach a Mac, a phone, a browser or a video platform that has never supported it.
Audio converters
MP3, WAV, FLAC, AAC and the others. Several of these pages recommend not converting: encoding one lossy format as another costs quality twice, and where the destination reads the original the honest answer is to leave it alone.
AAC to MP3
Convert an AAC file to MP3 for a device that will not read AAC. Be clear about what this is: AAC is the newer and better codec, so this is a downgrade taken deliberately in exchange for compatibility. It is the right trade when the destination is a car stereo, an old player or a piece of software with a fixed list of formats, and the wrong one otherwise.
AAC to WAV
Decode an AAC file into an uncompressed WAV. A bare `.aac` file is a raw audio stream with no container around it, which is why some software will not touch it even though it handles AAC perfectly well inside an M4A or an MP4 — the codec is familiar and the wrapper is missing. Converting to WAV removes the question entirely.
FLAC to M4A
Turn a FLAC into an M4A that an iPhone or a Mac will play. Apple has never supported FLAC on the device side, so a lossless library is invisible to the phone it is meant to be listened on. Because FLAC is lossless, the AAC encoder works from the original audio — this is a first-generation encode, not a copy of a copy.
FLAC to MP3
Turn a FLAC into an MP3 that plays on a phone, in a car or on an older player. FLAC is lossless — it compresses without discarding anything, so it is the format people rip collections to when they want the archive to be exact. The trouble is that being exact makes files large and support patchy, and this conversion trades both away deliberately.
FLAC to WAV
Convert a FLAC into a WAV with no loss whatsoever. This is one of very few conversions on this site where nothing is given up: FLAC compresses losslessly, so decoding it produces exactly the samples that were encoded, and a WAV stores exactly those samples. The audio in the file you get is bit-for-bit identical to the audio in the file you had.
M4A to MP3
M4A is the better format and MP3 is the more accepted one. An M4A holds AAC, which sounds better than MP3 at the same bitrate, so converting is a step down in quality taken to gain compatibility — with an old car stereo, a DAP, a voice recorder, or software that was written when MP3 was the only thing that mattered.
M4A to WAV
Convert an M4A into an uncompressed WAV that any audio editor will import. M4A is what an iPhone voice memo is saved as and what iTunes ripped to for years, so this is usually a recording of somebody talking on its way into transcription software or an editing session. The file grows about tenfold and sounds the same — the reason to do it is that the software at the other end insists.
MP3 to M4A
Convert an MP3 into an M4A for software that expects Apple's format. Understand what this does first: both are lossy, so the audio is decoded and encoded again, and the result is slightly worse than the MP3 rather than better. Do it when something requires M4A, and not in the belief that AAC will improve a file that is already an MP3.
MP3 to WAV
Convert an MP3 into an uncompressed WAV for software that will not accept anything else. Be clear about what this does and does not do: the file gets roughly ten times larger and sounds exactly the same. Nothing the MP3 encoder discarded comes back, because it is not stored anywhere to come back from.
OGG to MP3
Convert an Ogg Vorbis file to MP3 so it plays on hardware that never supported Ogg. Vorbis is a good codec with an unusual history — it exists because MP3 was patented and Ogg was not, and by the time those patents expired in 2017 the compatibility gap had already been set. Converting closes it.
WAV to AIFF
Convert an uncompressed WAV into an uncompressed AIFF. Nothing is lost, because there is nothing to lose: both formats store raw samples and differ mainly in which company defined them and which way round they write their bytes. This is a compatibility step for Mac audio software, not a quality decision.
WAV to FLAC
Compress an uncompressed WAV into a FLAC at roughly half the size, losing nothing. This is not the same trade as converting to MP3: FLAC's compression is mathematically reversible, so decoding a FLAC returns exactly the samples that went into it. You get the same audio in half the space, and you can get the WAV back whenever you want it.
WAV to M4A
Encode an uncompressed WAV as an M4A, which holds AAC audio. This is the best case for the format: nothing has been discarded before now, so the encoder is working from the original samples rather than from something another encoder already picked over. At the same file size this beats an MP3 made the same way, particularly at lower bitrates.
WAV to MP3
Turn an uncompressed WAV into an MP3 roughly a tenth the size. WAV stores audio as raw samples with no compression at all, which is why a ten-minute recording runs to a hundred megabytes and will not attach to an email. This is also the one audio conversion where nothing has been lost before you start, so the MP3 you get is a first-generation encode — as good as an MP3 is capable of being.
WMA to MP3
Convert a Windows Media Audio file to MP3 so it plays somewhere other than Windows. WMA files are usually the remains of a music library ripped in Windows Media Player, which used the format by default for years — so people who ripped their CDs on a PC in the 2000s often have entire collections that a phone or a Mac will not read.
Other converters
Formats that do not sit in any of the families above.
CSV Delimiter Changer
Change a CSV file's separator without breaking commas inside quoted descriptions, addresses, or notes. Choose the input delimiter, choose a new comma, semicolon, tab, or pipe delimiter, and the browser parses the table before writing it back with correct quoting. This is useful when a regional spreadsheet expects semicolon CSV, a command-line import requires tabs, or a data warehouse accepts pipes. The tool changes separators only: it does not sort rows, rename headers, coerce types, remove duplicate records, or change character encoding.
CSV Splitter
Split a CSV table into smaller row-based parts. Choose how many data rows belong in each file and the tool repeats the header in every downloaded chunk, which makes each part independently readable by a spreadsheet or import job. Quoted commas, line breaks, and escaped quotes are parsed before splitting, so a separator inside a description does not create a fake row. This is a practical chunker for manageable browser-sized exports; it does not sort records, deduplicate data, compress files, or split on a semantic key such as customer or date.
CSV to HTML
Turning a data file into a web table by hand is where the ampersands and the angle brackets get you. This conversion parses the CSV properly, so a field containing a comma stays one cell, and escapes the characters that would otherwise close a tag early or render as markup.
CSV to JSON
Turn a comma-separated table into a JSON array of objects without sending the rows to a server. The parser understands quoted commas, quoted line breaks, escaped quotation marks, alternate delimiters, and uneven rows. The first row becomes the field names and every later row becomes one JSON object, so the result is ready for an API fixture, a script, or a small data import. Values remain strings deliberately: converting an account number into a number can remove leading zeroes, while converting a status such as "001" changes data.
CSV Transpose
Switch CSV rows and columns when a report is laid out in the wrong orientation. The first input row participates in the transpose just like every other row, so a header row becomes the first output column and the first input column becomes the output header. Quoted commas, embedded line breaks, and escaped quotes are parsed before the table is rotated. This is a literal matrix transpose, not a pivot table: it does not group values, calculate totals, infer categories, or aggregate duplicate labels. Review the result before using it in a spreadsheet or import.
JSON to CSV
Convert a JSON array of objects into a spreadsheet-friendly CSV, keeping the payload. The converter builds a union of keys across all records, keeps the first-seen field order, quotes commas and line breaks correctly, and serializes nested arrays or objects as JSON text inside a cell. It is designed for API responses, fixtures, exports, and quick inspection. A flat array of records is required because CSV has rows and columns but no native representation for an arbitrary JSON tree.
SVG to ICO
A favicon is the smallest thing you will ever ship and the least forgiving. Starting from a vector is what makes the small sizes clean, because each frame can be drawn at its own resolution instead of shrunk down from someone else's.