slack-export-viewer turns a Slack export into something browsable
A Slack Export archive viewer that allows you to easily view and share your Slack team's export
At a glance
- What is it?
- slack-export-viewer is a Flask application that opens a Slack workspace export in a browser instead of leaving you to pick through JSON files, and it can run three ways: locally, as a shared server, or as static HTML for a hosted site. It is aimed at small teams who hit the free plan's message limit, and it reads exports from Slack or from slackdump.
- Who is it for?
- slack-export-viewer suits a small team that needs to search and read a workspace export it already has, or a team that wants to publish an archive as a static site, and it is a good fit for compliance and legal discovery work where a readable rendering of a chat export is the deliverable. It is the wrong tool if you need live data, because it reads an archive rather than an API.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 61 days ago.
- What is it written in?
- Mainly Python, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on October 22, 2026, and from our analysis. They are not legal advice.
Editorial analysis
The problem is a directory of JSON files
A Slack export is a zip file containing one JSON document per channel per day. Reading one is unpleasant work, and the tool's whole purpose is to remove it.
The project describes itself as a Slack Export archive viewer that lets you view and share a Slack team's export instead of having to dive into hundreds of JSON files. The stated audience is small teams on a free Slack plan, which is limited to 10,000 messages, who overrun their budget and occasionally need a nice interface to refer back to previous messages.
That framing is narrower than it might first appear, and it is worth sitting with. The tool is not a Slack client and it is not a way to search your live workspace. It works on an archive you already have, and the archive exists for a reason, either because the workspace hit the free plan limit, or because someone exported it deliberately, for a legal hold, for an internal investigation, or because the workspace is being wound down.
The implementation is a Flask application in Python. The package is on PyPI as `slack-export-viewer`, the current version is 4.0.0, and the licence is MIT. The dependencies are a small set: `click` for the command line, `Flask` and `Werkzeug` at version 3 or newer, `markdown2` for rendering message text, `emoji` for the emoji shortcodes Slack uses, and `frozen-flask`, which is what lets the same app serve static HTML with the routes frozen in place.
Python 3.12 or newer is required, and the project is built with Poetry, with two console scripts registered: `slack-export-viewer` and `slack-export-viewer-cli`.
Three ways to run it, and they suit different reasons
The overview section describes three uses, and the choice between them is really a choice about who is allowed to see the content and where it lives.
The first is local. You run it on your own machine for yourself to explore an export, and it opens a browser showing the general channel. The second is a headless server. Because it is a Flask web app, you can run it on a server and serve the content to the rest of your team, which is what you want when several people need to read the same archive. The third is static output, where it writes HTML files that you deploy as a static website, with no server involved at any point after the build.
That third mode is the one that gets overlooked and it is the most useful for the sharing case. A Slack export is a directory of JSON, which is not something you can hand to a non-technical colleague. A static HTML export is a set of files you can put behind any web server, or even open from disk, and the content is exactly what the server mode would have shown.
The static mode is also the one with the least operational risk, because there is no long running process holding an archive of private conversations on a port. The trade is that you lose the search and the interactive navigation that the server provides.
The reader should also notice what the tool is not doing. It is not uploading anything, it is not calling the Slack API, and it is not talking to the workspace. It reads files you point it at. For a tool whose input is a copy of a company's private messages, that is the right default.
Every option has an environment variable twin
The option list is long, and the design detail that makes it manageable is that essentially every flag has a matching environment variable.
The core options are the port to serve on, with `-p, --port` and the environment variable `SEV_PORT` defaulting to 5000; the path to the archive, `-z, --archive` with `SEV_ARCHIVE`, which is the only required option; and the host IP, `-I, --ip` with `SEV_IP` defaulting to localhost.
The output options are `-o, --output-dir` with `SEV_OUTPUT_DIR` defaulting to `html_output`, and `--html-only` with `SEV_HTML_ONLY`. The display options are `--no-sidebar` with `SEV_NO_SIDEBAR`, `--no-external-references` with `SEV_NO_EXTERNAL_REFERENCES`, `--channels` with `SEV_CHANNELS` for a comma separated list of channels to parse, `--hide-channels` with `SEV_HIDE_CHANNELS`, `--show-dms` and `--no-show-dms` with `SEV_SHOW_DMS` defaulting to false, and `--thread-note` and `--no-thread-note` with `SEV_THREAD_NOTE` defaulting to true, which controls whether a Thread Reply marker is added to threaded messages.
Two of these are worth singling out. `--no-external-references` removes all references to external css, js and images, which is what you want when the output has to be self-contained, and `--since [%Y-%m-%d]` limits the messages shown to those after a given date, which is how you narrow a large export down to a period of interest.
The `--test` flag is the one to know before anything else. It runs in test mode, which does an archive extract but does not start the server and immediately quits. That is a dry run that tells you whether the archive parses, without opening a port or launching a browser.
Getting the export: Slack's own download or slackdump
The usage section offers two ways to obtain the archive.
The first is the official Slack export. You visit the export page at my.slack.com/services/export, create an export, wait for it to complete, then refresh the page and download the zip file into whatever directory you want.
The second is slackdump, from the rusq/slackdump project. You download it, set up authentication as the slackdump documentation describes, and run it to export messages in the Standard format, either as a directory or as a zip file. The documentation also notes that slack-export-viewer can use the directory directly without a zip file.
That second point matters for one practical reason. A Slack export is organised by channel and by day, and for a large workspace the number of files is exactly the problem this tool is solving. A directory from slackdump in Standard format is the same shape of data, and the viewer accepts it without a repackaging step.
Either way, the pointer to the archive is the same command.
slack-export-viewer -z /path/to/export/zipIf everything went well, the archive has been extracted and processed, and a browser window opens showing the general channel from the export. If the `html-only` flag was set, the HTML files are in the `html-output` directory, or in whatever directory was specified.
The installation is the other half of the setup, and the project recommends pipx for an isolated install.
pipx install slack-export-viewerThe plain pip route works as well, and the documentation leaves it open.
pip install slack-export-viewerEither way the tool is installed as an entry point, so it can be run from anywhere.
The second command line produces one printable file
There is a separate CLI, `slack-export-viewer-cli`, and it currently has two commands.
$ slack-export-viewer-cli --help
Usage: cli.py [OPTIONS] COMMAND [ARGS]...
Options:
--help Show this message and exit.
Commands:
clean Cleans up any temporary files (including cached output by...
export Generates a single-file printable export for an archive file or...The `clean` command clears the cache that the viewer leaves in the temporary directory, and given what the tool does, that cache is a copy of private conversations sitting on disk, so it is worth knowing the command exists.
The `export` command generates a single-file printable export for an archive file or directory. That is a different artefact from the static site mode, and the difference is a good one to understand. The static mode produces a set of pages you host and browse. The export command produces one file, which is what you want when the destination is a PDF pipeline, an email attachment, an evidence bundle or a print job.
The export command takes the same display options as the main tool, `--show-dms`, `--thread-note`, `--since`, `--skip-channel-member-change`, and it adds `--template FILENAME` with the environment variable `SEV_TEMPLATE` and a default of `export_single.html`. Being able to point it at your own template is the extension point for a team that needs a specific layout, for example one with a cover page or a particular footer.
The repository layout matches the two entry points. `slackviewer/` holds the package with `main` and `cli` modules, `app.py` and `cli.py` sit at the root, `tests/` holds the test suite, and there is a `poetry.lock`, a `RELEASE.md` and a `screenshot.png`.
Where an archive viewer stops
The limitations are not surprising once the scope is clear, but they are worth stating because the name invites a wrong assumption.
The first is that it reads an archive, not a workspace. Everything the tool shows was true at the moment the export was taken. If the team kept talking afterwards, the viewer shows the old state and nothing indicates that. For a legal or compliance use that is exactly right, because the export is the evidence. For a team trying to use it as a search tool for the present, it is the wrong shape.
The second is the size of the input. The stated use case is a free plan workspace limited to 10,000 messages. The tool processes an archive into HTML, and a large export means a large number of files and a large working set during the extract. The documentation does not describe a streaming or incremental mode, so a very large archive is the case where you would want to test first with `--test` and see.
The third is the sharing model. The server mode serves the content over HTTP with no authentication described in the option list, and the default host IP is localhost, which is the safe default. Pointing it at a real interface means anyone who can reach the port can read the archive. For a headless server shared with a team that is a deliberate act, but it is worth noticing that the tool does not describe any access control of its own, so a reverse proxy with authentication is the missing piece you have to supply.
The alternative to consider, and the difference in approach, is a purpose built archive format. Some tools read a Slack export and index it into a database, which gives full text search across years of history at the cost of an import step and a storage format of your own. slack-export-viewer takes the other path, treating the export as a document to be rendered, which is why it can produce a single printable file and a static site from the same code and why it needs no index.
Editorial conclusion
slack-export-viewer suits a small team that needs to search and read a workspace export it already has, or a team that wants to publish an archive as a static site, and it is a good fit for compliance and legal discovery work where a readable rendering of a chat export is the deliverable. It is the wrong tool if you need live data, because it reads an archive rather than an API. Check first the Python version, which is 3.12 or newer, and run the tool with `--test` before serving anything, since that mode extracts and processes the archive and quits without opening a port.
Frequently asked questions
What does slack-export-viewer do?
It opens a Slack workspace export in a web interface so you can scroll through the channels instead of reading individual JSON files. It can run locally, as a headless Flask server for a team, or it can output static HTML for deployment as a website.
How do I install slack-export-viewer?
The project recommends `pipx install slack-export-viewer` for an isolated install, and `pip install slack-export-viewer` works as well. Python 3.12 or newer is required, and the tool is installed as a console script that can be run from anywhere.
How do I point slack-export-viewer at an export?
With `slack-export-viewer -z /path/to/export/zip`. The archive can be a zip file or a directory, and the tool extracts and processes it, then opens a browser on the general channel. The `--test` flag performs the extract and processing and quits without starting the server.
Can I publish a Slack export as a static site?
Yes. The `--html-only` flag writes static HTML files to the output directory, `html_output` by default and configurable with `-o, --output-dir`. The separate `slack-export-viewer-cli export` command goes further and produces a single printable file, with a custom template supported through the `--template` option.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/hfaran-slack-export-viewer)Was this useful?