Two icons, one id — and one of them breaks.

Paste SVG or drop your icon files below — find every duplicate id, every broken url(#...) reference and every cross-file collision, then fix them all with one click. Checked entirely on your device.

  • Your file data never leaves the device
  • Duplicates, dangling refs & cross-file collisions
  • One-click fix with safe prefixing
  • Up to 10 files, no account

Paste SVG or add your files

Paste one icon, several icons together, or a whole HTML page with inline SVG. The checker reads id attributes and references wherever they appear in the text.

Try a sample:

Drag & drop SVG or HTML files here

or browse your files

Checked in your browser — every id is listed with its element and line, duplicates and dangling references are flagged, and the fix rewrites ids and references together. Nothing is uploaded.

Letters, numbers, underscores and hyphens; must start with a letter or underscore.
Duplicates-only leaves clean ids untouched.
Up to 10 files, 2 MB each. Pasted markup and files are checked together.
    No SVG pasted or added yet. Everything stays on this device. Fixed files download instantly.

    Privacy you can verify, not just trust

    Most online SVG checkers send your markup to their server first — the best-known validators process pasted code through a remote endpoint, and the optimisers that fix ids need a build step or an editor extension. This one can't: your markup and files are scanned entirely in your browser. Your file data never leaves the device — the only third-party requests are the site's own analytics, which count page views — and it uploads nothing, ever. There is no file fetched after load for the check itself. Don't take our word for it:

    New cross-origin requests during use: 0
    1. Press F12 to open developer tools, then the Network tab.
    2. Check some SVG above. Watch: apart from the site's analytics, nothing new is requested — no uploads, and no file data ever leaves your device.
    3. Extra credit: disconnect your internet after this page loads — checking and fixing still work.

    How to find duplicate SVG IDs before they break your icons

    An icon that looks perfect on its own can break the moment it shares a page with another icon. The cause is almost always the same: both icons define the same id — paint0_linear, clip0, filter0 — and the browser resolves every url(#...) reference to the first definition it finds. One icon quietly borrows the other's gradient, and if the first icon is hidden inside a closed menu, the second can vanish completely.

    This tool finds the collision where the icons already are: on your own device. When you paste markup or drop files here, your browser:

    1. Lists every id — with the element it belongs to and its line number — and flags any id defined more than once, in one file or across the whole batch.
    2. Maps every reference — url(#...) in fill, clip-path, mask and filter attributes and in style blocks, href and xlink:href, aria-labelledby and aria-describedby, and #id selectors in style blocks — and names any reference that points at an id nothing defines.
    3. Fixes it with one prefix — every id becomes prefix-id, every reference is rewritten to match, and a second definition of the same id becomes prefix-id-2, so the fixed file has no duplicates left and renders exactly as the original did alone.

    What makes this checker different

    The pages that top the results for this search are guides that tell you to paste a snippet into the browser console, a build-time optimiser plugin, or an editor extension that only works inside one program — and the one generic checker that exists takes a plain list of ids, one per line, so it cannot see SVG markup, references, or cross-file collisions at all. This page is the only free, fully client-side dedicated SVG duplicate-id checker we found that parses the markup itself: ids with elements and line numbers, every reference mapped, dangling references named, several icons checked together for the Figma-export failure, and a one-click fix that downloads the corrected file — with no daily limits, no account and no upload — plus a live network-request counter so you can verify the privacy claim yourself. It runs entirely in your browser — there is no server to upload to.

    When is checking the right choice — and when is it the wrong one?

    Checking is right whenever SVG markup is about to be inlined: icons pasted into HTML, a component library, a design-system sprite, or several Figma exports landing on the same page. It is the wrong choice for an SVG that will only ever load through an img tag — each img is its own document, so ids there can never collide — and for a file you never inline, where the ids are namespaced by the file itself. If your icons already live in a sprite with unique ids, this check will simply come back clean.

    Honest limitations

    A text scan, not a validator

    This tool reads ids and references as text. It cannot certify that your markup is well-formed XML — a broken tag elsewhere in the file is outside what it checks.

    External references are out of scope

    A url(#id) that points into another file, or an href to a different document, cannot be resolved from the text you paste. Those references are listed, not verified.

    SMIL event references are flagged, not fixed

    References such as begin="id.click" are animation triggers, not id lookups in the usual sense. The checker warns you when it sees one instead of rewriting it.

    References resolve to the first definition

    When an id is defined twice, the fix points every reference at the first definition and renames the second one. If your second definition was the intended target, rename it by hand instead.

    It never changes your file

    This tool only reports and downloads a fixed copy. Your original file is never modified — the fix is a new download, and the preview shows the icon as it renders.

    Not an optimiser

    Fixing ids does not minify, clean up, or shrink your SVG. Run an SVG optimiser after fixing the ids if you want the file smaller as well as correct.

    Frequently asked questions

    Do my SVG files upload anywhere?

    No. Your markup and files are analysed entirely in your browser — your file data never leaves the device, and the only third-party requests are the site's own analytics, which count page views. You can verify it yourself with the network-request counter in the privacy section below the checker.

    Why do duplicate IDs break my icons?

    IDs must be unique in a document, and SVG references such as url(#paint0_linear) resolve to the first element with that id on the whole page. When two inlined icons both define paint0_linear, the second icon borrows the first icon's gradient, mask or clip path — and if the first icon is hidden, the second can lose its fill or disappear entirely. Exported icons from Figma commonly reuse names like paint0_linear and clip0, so the collision is easy to hit and hard to spot.

    What exactly does the checker look at?

    Every id attribute in your markup, with its element and line number; every reference to an id — url(#id) in fill, clip-path, mask and filter attributes and in style blocks, href and xlink:href, aria-labelledby and aria-describedby, and #id selectors in style blocks. It flags ids defined more than once, references that point at an id nothing defines, and ids that nothing references. A combined check across several files flags the same id defined in two different icons.

    How does the one-click fix work?

    Type a short prefix, such as the icon's name, and press Fix. Every id gets the prefix — hero-grad instead of grad — and every reference is rewritten to match, including url(#...), href and style-block selectors. If one id is defined twice, the second definition becomes hero-grad-2 so the fixed file has no duplicates left. Comments are left untouched, and colours, shapes and geometry are never changed, so the fixed icon renders exactly as the original did on its own.

    My two Figma icons both use paint0_linear — can it check them together?

    Yes. Add both files, or paste both icons, and press Check IDs. The combined check lists every id defined in more than one source, so you see the cross-file collision before it breaks a page. Fix each file with its own prefix — icon-a for one, icon-b for the other — and the two can then live on the same page safely.

    Will the fixed SVG look any different?

    No. The fix only renames ids and the references that point at them. Colours, shapes, sizes and positions are untouched, and the preview under each result shows the icon as it renders. The only visible change is in the markup itself: longer id names.

    Can I check inline SVG inside an HTML file?

    Yes. Drop an HTML file or paste the markup — the checker scans id attributes and references wherever they appear in the text, so inline SVG in a page is checked the same way as a standalone .svg file. The fix rewrites the ids and references in the pasted text, and you download the fixed file.

    What does this tool NOT do?

    It is a text scan, not an XML validator or an optimiser. It cannot certify that your markup is well-formed XML, resolve references that point into another file, or rewrite SMIL event references such as begin="id.click" — those are flagged as a warning instead. It also does not minify or optimise your SVG; for that, use an SVG optimiser after fixing the ids.