AnyTool
Your files never leave your device. All processing happens locally in your browser.

How do I make an org chart online for free without uploading anything?

Open the Org Chart Maker, click a card and press Tab to add a report or Enter to add a peer, then edit the name, title, colour and an optional photo in the inspector (F2 or double‑click jumps straight there). Drag any card onto another to re‑parent it — the tidy top‑down layout re‑flows automatically so cards never overlap. Collapse a manager to focus, switch elbow or straight connectors, and Fit to frame it. Build from pasted CSV or indented text, then export a crisp PNG, an editable SVG or JSON — everything runs 100% in your browser and nothing, avatars included, is uploaded.

  • Tab = add report, Enter = add peer, F2 / double‑click = edit fields, Delete = remove a person and their reports
  • Drag a card onto another to re‑parent; a tidy top‑down auto‑layout re‑runs on every change
  • Per‑person colour and an optional local avatar; collapse / expand, pan, zoom and fit‑to‑view
  • Import name,title,manager CSV or indented text, and copy the chart back out the same way
  • Export PNG (2×) and editable SVG, plus JSON save / load / import — nothing uploaded

What is

Org chart maker

An org chart maker is a tool for drawing an organisational hierarchy as a top‑down tree of person cards — a leader at the top with reports branching below, each person linked to exactly one manager. You add reports and peers, edit names, titles, colours and optional avatars, drag a card to re‑parent it, and a tidy auto‑layout keeps the tree readable and non‑overlapping. A 100% client‑side maker holds the tree in memory, renders it on an in‑browser SVG, and exports PNG / SVG / JSON (and CSV / text) on‑device, so nothing is uploaded.

Design

Related terms

org chartorganizational chartreporting structurehierarchyorg treecompany structurenode editormanagerdirect reportauto-layoutSVG export

Frequently Asked Questions

No. The whole chart is a tree of plain objects in the page and drawn on an in‑browser SVG; avatars are downscaled and embedded locally, PNG export is a local canvas render, SVG / JSON / CSV are built in memory, and “Save” writes only to this browser’s localStorage. There is no server or CDN in the path.

The Org Chart Maker is 100% client‑side. Every person — name, title, colour and optional photo — is a small typed object in a single tree held in the page, and a pure engine (orgChartEngine.ts) computes the tidy layout and connector paths. A photo you add is read with FileReader, downscaled on a local <canvas> and stored as a data URI inside that node; it is never sent anywhere. The chart you see is a live React <svg>; the PNG export serialises the same geometry to an SVG string (native <text> and <image>, deliberately no <foreignObject>) and draws it onto a local <canvas> with canvas.toBlob, the SVG export is that string saved as a file, and JSON / CSV / text are built in memory. “Save to this browser” uses localStorage on your own device only. Nothing is fetched, uploaded, logged or stored on a server, there is no CDN in the processing path, and fonts are your device’s system fonts. The only optional network use is consent‑gated ads. It works offline once cached.

It uses a tidy top‑down tree layout: each leaf claims one column and every manager is centred over their reports, so cards never overlap, and it re‑runs on every change. You re‑arrange by structure — drag a card onto a new manager to re‑parent it, or collapse a branch — rather than nudging cards freely.

Positions are computed, not stored: a pure “leaf‑slot” pass (a compact, guaranteed‑non‑overlapping variant of the Reingold–Tilford idea) walks the tree, gives every leaf or collapsed node one horizontal slot, and centres each parent over the span of its children, while depth maps to the vertical axis. Because a parent never extends beyond its children’s span and each leaf owns a distinct slot, subtrees can never collide, and the layout re‑runs after every edit so the chart always stays tidy. Since positions are derived from structure, you change the shape rather than the pixels: drag a card onto another to re‑parent it (dropping onto its own descendant is blocked, so you can’t create a cycle), add reports and peers, or collapse a manager to hide a whole team. You can also switch between elbow and straight connectors, and pan, zoom and fit‑to‑view to explore.

Yes. Open the Data panel and paste either a name,title,manager CSV or indented text (“Name, Title” with tabs or spaces for reporting lines) and click Build. You can also copy the current chart back out as CSV or indented text, or save it as JSON.

The Data panel accepts two quick formats. CSV expects one person per row as name,title,manager: a blank or unknown manager becomes a top‑level person, and everyone else attaches under the manager named in the third column (matched by name, case‑insensitive; self‑loops and cycles are dropped). Indented text expects one person per line as “Name, Title”, where indenting with spaces or a tab makes that line a report of the line above — the outdented line is the top of the chart. If several people end up without a manager, they are wrapped under a synthetic “Organization” root. One click builds the chart, and the same panel copies the current chart back out as CSV or as indented text. For a full round‑trip that also keeps colours and photos, use JSON save / download / import.

Yes. Export a 2× PNG for sharing or an editable SVG for professional design tools / Illustrator / Inkscape, and save or download the whole chart as JSON to reload later or move between devices. All exports are generated locally — nothing is uploaded.

You can export in several formats, all produced on‑device. PNG renders the exact geometry you see — cards, connectors and composited avatars — onto a local canvas at 2× on a white background, ideal for slides, docs or chat. SVG saves the chart as a clean vector with real <text> and <image> nodes (avatars embedded as base64), so you can keep editing it in professional design tools, Illustrator or Inkscape. JSON captures the full tree (names, titles, colours, photos and collapse state); “Save” keeps it in this browser’s localStorage, “JSON” downloads a file, and Import loads one back — the reliable way to move a chart between devices since there is no account or cloud sync. You can also copy the structure out as CSV or indented text. Because everything lives in memory (and optionally localStorage), export or save before you close the tab.

Detailed Explanation

How It Works

Org Chart Maker — A Real, Private Top-Down Hierarchy Editor

The Org Chart Maker is a 100% client-side hierarchy editor — a free, private, watermark-free way to draw a company or team org chart. A leader sits at the top and reports branch downward as clean person cards (name, title, a department colour and an optional local photo), each linked to exactly one manager by an elbow or straight connector. You add reports and peers, edit fields in place, recolour, drop an avatar, drag a card onto another to re-parent it, and collapse a manager to hide their team — and a tidy top-down auto-layout re-flows on every change so cards never overlap. The chart is drawn on an in-browser SVG and exported on-device as a crisp PNG, an editable SVG, JSON, or CSV / indented text; nothing is ever uploaded.

  • Top-down tree of person cards: name, title, department colour, optional local avatar
  • Add report / peer, edit fields, re-parent by drag, collapse / expand a team
  • Tidy leaf-slot auto-layout re-runs on every change; cards never overlap
  • Elbow or straight connectors; pan, zoom, fit-to-view on an SVG surface
  • Export 2× PNG, editable SVG, JSON and CSV / text — 100% in the browser, nothing uploaded
Methodology

Method: Structure-Driven Tidy Top-Down Layout

Unlike a free-form diagram, an org chart’s positions are COMPUTED from structure, not stored — so the chart always stays tidy. Every render, a pure “leaf-slot” pass (a compact, guaranteed-non-overlapping variant of the classic Reingold–Tilford tidy-tree idea) walks the tree: each leaf or collapsed node claims one fixed-width horizontal slot, an internal node is centred over the span of its children, and depth maps linearly to the vertical axis. Because a parent never extends beyond its children’s span and every leaf owns a distinct slot, subtrees can never collide. Connectors are drawn from a parent’s bottom-centre to each child’s top-centre, either as a right-angle ELBOW through a shared horizontal bus or as a STRAIGHT line. Since layout is derived from the tree, you re-arrange by changing structure — drag a card onto a new manager to re-parent it (blocked when the target is inside its own subtree, so no cycles), add reports and peers, or collapse a branch.

  • Positions are computed from structure every render — the chart stays tidy automatically
  • Leaf-slot tidy tree: one slot per leaf, parent centred over its reports, depth = row
  • Guaranteed non-overlap: a parent never exceeds its children’s span
  • Elbow (shared bus) or straight connectors, parent bottom to child top
  • Re-parent by drag with cycle prevention; collapse to hide a subtree
Technical Details

Rendering, Avatars and Export Internals

A pure engine (orgChartEngine.ts) is fully typed and browser-safe: it holds the tree of OrgNode people with immutable mutators (addReport, addPeer, updateNode, removeNode, reparent, toggleCollapse), runs the tidy layout to produce positioned cards, edges and union bounds, and serialises the chart to JSON, CSV and an SVG string. The page renders that model as a live React <svg> whose viewBox drives pan and zoom, aspect-locked to its container so screen pixels map linearly to SVG units for hit-testing and drag. Pointer events convert client coordinates into SVG coordinates via getBoundingClientRect; a drag past a small threshold enters re-parent mode, hit-tests the card under the cursor and highlights a valid drop target, while dragging empty canvas pans and a non-passive wheel listener zooms around the cursor. Avatars are read with FileReader, drawn centre-cropped onto a 96px <canvas> and stored as a compact JPEG data URI on the node. Export builds an SVG string using native <text> and <image> (avatars embedded as base64) — deliberately no <foreignObject>, which many canvas rasterisers drop — so the same string both downloads as a vector and draws onto a local <canvas> at 2× for a PNG via canvas.toBlob.

  • Engine: typed OrgNode tree, immutable mutators, tidy layout, JSON / CSV / SVG serialisers
  • Live React <svg> with a viewBox for pan / zoom; aspect locked to the container
  • Pointer→SVG mapping for drag-to-reparent with drop-target hit-testing
  • Avatars centre-cropped to a 96px canvas and stored as a compact JPEG data URI
  • Export SVG uses native <text> + <image> (no foreignObject) → rasterises cleanly to a 2× PNG
Use Cases

When to Reach for This

Use it to sketch a company or team structure fast, privately and without an account, subscription or watermark: onboarding docs, a reorg proposal, a headcount or hiring plan, a project team map, or a slide for a board or all-hands. Because you can paste a name,title,manager CSV exported from an HR system or a spreadsheet — or type an indented outline — and build the whole chart in one click, it’s quick to go from a list to a diagram, and you can copy the structure back out as CSV or text. Add photos to make a face-to-name team page, colour by department, collapse the parts you’re not presenting, then export a PNG for slides, an SVG to keep refining in professional design tools or Illustrator, or JSON to save the chart and reopen it later or move it between devices.

  • Great for onboarding, reorgs, headcount / hiring plans and team maps
  • Paste name,title,manager CSV or an indented outline → build in one click
  • Colour by department and add local photos for a face-to-name page
  • Collapse branches to present just one team; no account or watermark
  • Export PNG for slides, SVG for editing, JSON / CSV to save and round-trip
Limitations

Honest Limitations

This is a STRICT hierarchy: every person has exactly one manager, so there are no dotted-line, matrix or many-to-many reporting relationships (a person can be re-parented to a single new manager, not shared between two). The auto-layout is a tidy, non-overlapping tree but not the fully-compact Reingold–Tilford algorithm, so a wide sub-team occupies proportionally wide space and very large charts scroll horizontally — collapse branches to focus. Cards are a FIXED width and long names or titles are trimmed with an ellipsis, and text is measured with the device’s SYSTEM fonts, so metrics can shift a hair between machines. The PNG is rendered on a white background from the same geometry, while the SVG stays editable but embeds any avatars as base64, which enlarges the file. CSV / text import is deliberately simple — one person per row or line, matched to a manager by name — so duplicate names or unknown managers become extra top-level people, and cycles are dropped. Saving is localStorage-only with everything else held in memory, so export or save (JSON) before closing the tab, and to move a chart between devices.

  • Strict tree: one manager per person — no dotted-line / matrix / many-to-many links
  • Tidy but not fully-compact layout; wide teams take wide space (collapse to focus)
  • Fixed-width cards, ellipsis-trimmed text, system fonts → metrics vary slightly
  • PNG on a white background; SVG editable but embeds avatars as base64
  • Simple CSV / text import (name→manager); unknown managers become top-level; cycles dropped
Privacy & Security

Private by Design

Everything happens on your device. Each person is a small object — name, title, colour, an optional avatar and collapse state — in a single tree held in the page, and the engine computes the layout and draws the chart on an in-browser SVG. Photos you add are read locally, downscaled on a canvas and embedded as a data URI on the node; they are never sent anywhere. The PNG export serialises the same geometry to an SVG string and draws it onto a local canvas with canvas.toBlob, the SVG export is that string saved as a file, and JSON / CSV / text are built in memory — all produced locally. “Save to this browser” writes only to localStorage on your own device. There is no server and no CDN in the editing or export path, fonts are your device’s system fonts so nothing is fetched, and the only optional network use is consent-gated ads. The tool works offline once cached, keeps no accounts and sets no tracking; close the tab and unsaved work is gone.

  • The chart is a tree of local objects drawn on an in-page SVG
  • Avatars are downscaled and embedded locally — never uploaded
  • PNG = local canvas.toBlob of the same geometry; SVG / JSON / CSV built in memory
  • “Save” writes only to this browser’s localStorage — no cloud, no account
  • No server or CDN; system fonts only; optional consent-gated ads; works offline
Ways to make an org chart
ApproachHow it worksTrade-offUsed here
This client-side editorBuild a top-down tree on an in-browser SVG; tidy auto-layout; import CSV / text; export PNG / SVG / JSONPrivate + free + no watermark; a strict single-manager hierarchyYes
Cloud org-chart tool (e.g. Lucidchart, Organimi)Charts stored and rendered on their servers, often synced from HR systemsCollaboration and HR sync, but uploads your people data and often paywalls exportNo
Spreadsheet / slides (Excel, PowerPoint)Draw boxes by hand or via a SmartArt-style helperEverywhere already, but manual, hard to re-layout and no real tree modelNo
draw.io / diagrams.netFree-form shapes and connectors, can run locallyVery capable and free, but heavier and not org-chart-focusedAlternative

Everything here runs in the browser; charts and photos are never uploaded. Layout is a tidy leaf-slot tree (a compact Reingold–Tilford variant). As of July 2026.