Completely free
No paywalls for core features. Donations support development but are optional.
Free & open source · Windows
ShareX
Capture. Record.
Automate.
ShareX is a powerful screenshot and screen-recording utility trusted by creators, developers, and support teams. This page explains what it does, how people use it day to day, and how to fix common issues—so you can get work done faster.
- No ads
- Custom workflows
- 80+ upload destinations
Why ShareX stands out
The ShareX project highlights these strengths—and they match what long-time users report in community discussions and issue threads.
Open source
Auditable code on GitHub—verify behavior or contribute.
Lightweight
Starts fast and stays out of the way.
Years of polish
Edge cases and QoL details add up over time.
Power workflows
Hotkeys & after-capture tasks for real pipelines.
Feature highlights
A practical map of what ShareX can do. For more detail, explore the sections on this page.
Capture
Flexible screen capture
Fullscreen, active window, monitors, menus, regions (including transparent and “light” modes), last region repeat, scrolling capture, auto capture, and screen recording—including GIF.
- After capture: beautify, effects, editor, pin to screen, OCR, QR scan, print, save, upload.
- Scrolling capture: slow the scroll or narrow the region if stitching drifts—see Capture in depth.
Upload
Uploads that match your stack
Share files, folders, clipboard images, text, and URLs. After upload: shorten URL, copy link, QR, or custom actions.
Configure custom uploaders, Amazon S3, Cloudflare R2, and more under Destinations in ShareX.
Productivity
Built-in tools
Color picker, ruler, image editor, effects, combiner/splitter, thumbnailers, video tools, OCR, QR, hash checker, clipboard viewer, and more—without leaving the app.
Capture in depth
Choosing the right mode saves time. Common patterns from forums and documentation.
Region vs fullscreen
Region for tight crops in tickets; fullscreen when you need every pixel as arranged.
Scrolling capture
Slow the scroll or narrow the region if stitching drifts.
GIF recording
Keep clips short; trim externally for polished loops.
Annotation
Blur, pixelate, steps, arrows—ideal for support screenshots.
Uploads & destinations
Teams often pick one destination per environment—public host for casual sharing, private bucket for tickets.
| Scenario | Typical approach |
|---|---|
| Quick share | Image host; copy URL after capture. |
| Privacy-first | S3 / R2 / GCS or custom uploader. |
| Developers | POST to your API with auth headers. |
| Clipboard-only | Skip upload; copy path or image. |
Tools beside capture
Utilities that keep you in flow—paired with real UI from the app.
- OCR — available from the Tools menu and after capture.
- Hotkeys — set in ShareX under Hotkey settings.
- Hash checker — verify downloads
- Image combiner — before/after
- Clipboard viewer — debug uploads
- Effects — see screenshot above
Real-world workflows
Typical setups—not guaranteed for every machine, but strong starting points.
IT support: one hotkey, one URL
Region → blur → upload → paste link into tickets.
Developers: GIF regressions
Short GIFs in GitHub issues beat long repro paragraphs.
Creators: scrolling threads
One image for long pages—mind privacy and ToS.
Students: OCR from slides
When PDF export is unavailable—respect copyright.
Troubleshooting & fixes
Quick checks first; then narrow down with logs and community channels.
- Hotkeys clash
- Rebind with modifiers in Hotkey settings (see screenshot).
- Upload fails
- Check credentials, quotas, firewall; try another host.
- Scrolling misaligned
- Slower scroll, narrower region, disable layout extensions.
- AV quarantine
- Use the Download section on this page for the installer or portable build, or get official builds from GitHub releases to verify checksums and reduce the risk of tampered installers.
Download ShareX
Use the download options below and pick the build that matches your PC. Release numbers change over time.
Glossary
Quick definitions for ShareX-related terms you will see in menus, forums, and guides.
- After capture task
- Actions that run right after a capture—save, copy, upload, open editor, and more.
- After upload task
- Steps triggered once a file reaches a host—shorten URL, copy link, show QR, etc.
- Destination
- A configured output target for uploads—image host, storage bucket, or custom script.
- Custom uploader
- A user-defined HTTP request template for posting captures to private APIs.
- Workflow
- A saved chain of capture method + tasks + destination you can trigger with one action.
- Hotkey profile
- Bindings that launch specific workflows without opening the main window.
- Region capture
- Selecting a rectangle, ellipse, or freehand area instead of the full screen.
- Scrolling capture
- Stitching a tall document by auto-scrolling and merging slices.
- OCR
- Optical character recognition—turning pixels of text into selectable characters.
- Beautify
- Automatic touch-ups applied to screenshots before saving or sharing.
- Pin to screen
- Keeping a floating reference image on top while you work in other apps.
- History
- A log of recent captures and uploads for quick re-open or re-copy.
How ShareX fits common needs
Not a vendor scorecard—just practical angles people care about when picking a capture stack on Windows.
| Need | Typical approach in ShareX | Watch-outs |
|---|---|---|
| Fast ticket screenshots | Region capture → blur → copy link or file path | Confirm company policy on cloud uploads. |
| UI documentation | Scrolling capture + numbered steps in the editor | Very long pages may need multiple passes. |
| Short motion demos | GIF recorder with modest duration | Large GIFs are slow in email—prefer link hosting. |
| Private archives | Save to disk only; disable upload tasks | Encrypt disks if screenshots contain secrets. |
| Color sampling | Screen color picker from Tools | HDR displays can shift perceived values—verify in design app. |
First-hour checklist
A practical order of operations for a clean setup before you rely on ShareX in production.
- Pick a default workflow. Decide whether every capture should upload, only save locally, or prompt you each time.
- Set conservative hotkeys. Avoid clashes with IDEs and games; prefer modifiers (Ctrl+Alt+…) for rare actions.
- Test one destination. Validate credentials with a tiny test image before you wire it into daily use.
- Choose a file naming pattern. Predictable names make search and tickets easier weeks later.
- Turn on history if you need auditability. Useful for “what did I upload ten minutes ago?” moments.
- Rehearse redaction. Practice blur and pixelate on fake data so muscle memory exists before real incidents.
Privacy & security habits
- ●Minimize accidental uploads. Disable “upload after capture” until your destination is tested; use dry runs on non-sensitive windows.
- ●Separate work and personal profiles. If you must, use different Windows users or distinct ShareX settings folders—never mix regulated data casually.
- ●Review clipboard after OCR. OCR can place sensitive text on the clipboard—clear it before screen sharing.
- ●Watch for EXIF and window titles. Some captures include metadata; confirm what your pipeline strips before publishing.
Formats you will see most often
PNG
Lossless, great for UI and diagrams. Larger files than JPEG for photos.
JPEG
Smaller for photographic content; unsuitable when you need pixel-perfect text.
GIF
Short motion clips and simple animations—mind palette limits and file size.
WebP
Modern balance of size and quality—support varies in older viewers.
Myths vs reality
Myth: “One hotkey should do everything.”
Reality: Different jobs need different workflows—fullscreen recording is not interchangeable with a tiny region snip.
Myth: “Scrolling capture works on any page.”
Reality: Infinite scroll, sticky headers, and canvas-based sites can confuse stitching—adjust region or capture in chunks.
Myth: “Upload failures are always ShareX bugs.”
Reality: Tokens expire, hosts rate-limit, and corporate proxies intercept HTTPS—always verify network and credentials.
Extended questions
Expand any row for a concise answer—topics are independent of each other.
Why does my capture look darker or lighter than the real screen?
Windows display scaling, HDR, and night-light filters change how colors are interpreted. Capture from the same color profile context you use for design work, and avoid mixing HDR screenshots with SDR documentation without noting the difference.
Can I run captures on a schedule?
Auto capture supports timed intervals—ideal for monitoring slow UI changes. Pair with a dedicated output folder and periodic cleanup so disk usage stays predictable.
How do I keep filenames unique across teams?
Use a pattern that includes date, ticket ID, or a short slug. Avoid spaces in automated pipelines; underscores or hyphens reduce surprises in scripts.
What if my second monitor uses a different scale?
Per-monitor DPI means captures may have mixed pixel densities in one session. Prefer capturing per monitor rather than stitching mismatched regions unless you normalize later.
Is screen recording safe for confidential apps?
Treat recordings like live broadcasts—anything visible on screen can be captured. Use policy-approved tooling and avoid recording when classified overlays appear.
How do I reduce GIF size for email?
Shorten duration, lower frame area, reduce colors, and prefer hosting a link instead of attaching multi-megabyte files.
Why do QR codes fail after upload?
Heavy compression or downscaling can damage modules. Test with PNG, ensure margin around the code, and verify the scanner app is not applying its own filters.
What about accessibility in screenshots?
Add captions or alt text in your destination platform; ShareX captures pixels, not semantic structure—supplement with written context for screen reader users consuming your docs.
Playbooks by role
Designers
Pin reference shots beside Figma, capture at 1× when documenting components, and keep a consistent naming scheme per project so handoffs stay searchable.
Developers
Pair GIFs with issue templates, capture console logs in region mode, and avoid leaking tokens—blur aggressively before any upload task runs.
Support leads
Standardize a three-step visual: environment, repro, expected vs actual. Store originals in a controlled folder when regulations require retention.
Performance notes
- Close unnecessary after-capture effects on low-end laptops—beautify and heavy filters add latency.
- Store outputs on fast local SSDs when recording long sessions to avoid frame drops.
- Restart weekly if you leave ShareX running 24/7—long sessions can accumulate large histories in memory.
- Limit parallel uploads when bandwidth is shared with video calls.
When a different tool might be better
ShareX is versatile, but honesty saves time: professional video editing suites handle timelines better; dedicated OCR suites may beat quick extractions for bulk document conversion; enterprise DLP tools enforce policy in ways a capture app cannot replace.
Closing tips
Document your own defaults in a short internal note: hotkeys, destination, naming pattern, and what to do when uploads fail. That single habit turns ShareX from a utility into a dependable part of your workflow—without relying on memory when you are under pressure.
This extended section is independent reference material for readers who want depth beyond the primary guide. It does not replace in-app help or release notes for the ShareX application itself.
Automation & repeatability
ShareX shines when the same capture story happens daily. Think in pipelines: trigger → output → destination → audit trail.
Stable inputs
Use fixed hotkeys per workflow, not ad-hoc clicks. Predictable inputs survive busy weeks and new hires.
Stable outputs
One folder pattern per project, one naming rule per team. Chaos in filenames becomes chaos in tickets.
Multi-monitor & mixed DPI
- Capture per display when scales differ (125% laptop + 100% external). Mixing regions across mismatched DPI in one bitmap surprises viewers.
- Align documentation with the display you expect readers to use; color and sharpness vary by panel technology.
- Fullscreen on the wrong monitor usually means the active window lived there—verify focus before blaming the tool.
Clipboard hygiene
- After OCR or copy-to-clipboard steps, assume secrets can sit in clipboard history—clear before demos.
- Large images on the clipboard can steal RAM from other apps; save to disk for huge captures when possible.
- Paste into the target app within seconds when doing live support—delayed pastes sometimes pick up newer clipboard entries.
Annotation style for support
| Element | Use when | Avoid when |
|---|---|---|
| Arrows | Pointing to a single control | The UI is already obvious |
| Numbered steps | Sequences longer than two actions | Order does not matter |
| Blur / pixelate | PII or internal IDs appear | You still need the text readable for the fix |
| Crop | Noise around the relevant widget | Context (URL bar, app title) is required for diagnosis |
GIF vs static image
Prefer GIF / short video
Hover states, animations, reordering lists, drag-and-drop, anything where time order matters.
Prefer PNG / JPEG
Error text, configuration panels, pixel-perfect layout bugs, anything reviewers will zoom into.
Retention & cleanup
Screenshots age badly: paths change, secrets expire, disk fills. Pair capture folders with a simple policy.
- Rotate weekly or monthly archives for high-volume teams.
- Separate “throwaway” snips from “legal hold” evidence folders.
- Compress old PNG batches if cold storage is required—label archives with date range.
Pre-send QA checklist
Readable text at 100% zoom
Correct window in focus
No stray notifications
Redaction complete
Filename matches ticket ID
Adoption curve (typical)
Week 1
Exploration: default hotkeys, one destination, occasional wrong-window captures.
Month 1
Stabilization: named workflows, trusted upload path, fewer retakes.
Quarter 1
Muscle memory: batch habits, team conventions, predictable artifact quality.
Seven mistakes teams make
- Sharing fullscreen shots when a 200×200 region would do—extra pixels leak context.
- Uploading before verifying the destination account—wrong tenant, wrong bucket.
- Using the same hotkey in games and in ShareX—rebind aggressively.
- Ignoring history until audit day—turn it on early if compliance matters.
- Skipping version notes in handoffs—“works on my machine” screenshots without build numbers.
- Over-editing: heavy filters that hide the actual defect.
- Under-editing: raw captures with patient data in the taskbar clock region.
Sync vs async communication
Synchronous
Live calls benefit from quick region snips pasted into chat—optimize for speed and clarity, not polish.
Asynchronous
Tickets and email benefit from numbered steps, cropped context, and filenames that search engines and humans can find later.
Environment & edge cases
More situations that confuse first-time capture setups—each answer stands alone.
VPN or corporate proxy changed—uploads suddenly fail
TLS interception and split tunneling alter which routes reach public hosts. Test the same upload on and off VPN; ask network admins for allowlists if you must use a specific host.
Laptop sleep during long scrolling capture
Power settings can pause the foreground app mid-scroll. Plug in AC, extend sleep timers temporarily, or capture in shorter vertical chunks.
Remote desktop (RDP) sessions look blurry
RDP compresses video. Capture on the session host when possible, or increase client display quality settings—still expect softer edges than local glass.
Virtual machine fullscreen vs windowed
Guest tools change resolution and scaling. Document whether the shot is from host or guest OS to avoid “wrong resolution” debates.
Battery saver mode and recording FPS
OS throttling can drop capture frame rates. For demos that must look smooth, plug in and switch to high performance plan briefly.
Antivirus “safe” folder exclusions
Some suites scan every write to output folders, adding latency. A controlled exclusion for your capture directory can help—only with security review.
Unicode paths and scripts that post-process files
Automation that assumes ASCII paths breaks on localized usernames. Prefer output roots without exotic characters when wiring scripts.
Audio routing during screen recording
Default devices change when headsets connect. Verify system default input/output before narrating a walkthrough.
Knowledge-base article skeleton
Paste this outline into your internal wiki when documenting a ShareX-based procedure.
Title: [Action] using ShareX on Windows Audience: [role] Prerequisites: OS build, app version, permissions Steps: 1. Trigger: [hotkey / menu path] 2. Capture: [region / scroll / record] 3. Edit: [blur / crop / steps] 4. Output: [path pattern / upload off] Verify: [expected file name / checksum optional] Rollback: [how to undo or delete artifacts]
English UI vocabulary (for mixed-language teams)
When your OS is English but discussions happen in another language, align on these terms so handoffs stay unambiguous.
Capture — taking an image or recording from the screen
Workflow — saved chain of actions
Destination — where uploads go
Task settings — per-workflow options
After capture task — post-processing step
History — recent items log