Flask JSONDash: JSON-Configured Dashboards for Flask Apps
:snake: :bar_chart: :chart_with_upwards_trend: Build complex dashboards without any front-end code. Use your own endpoints. JSON config only. Ready to go.
At a glance
- What is it?
- Flask JSONDash is a Flask blueprint that builds chart dashboards from JSON config and your own endpoints. It is a fit for internal Python tooling, and a poor fit for anyone expecting a maintained analytics product.
- Who is it for?
- Adopt Flask JSONDash if you already run Flask and MongoDB and want a chart dashboard described by JSON rather than by a React codebase; the example_app plus docker-compose.yml gets you a working instance quickly. Do not adopt it if you need a maintained product with a release cadence, since the newest release listed is 6.2.3 from 2017-06-13, or if you cannot run MongoDB, because the quickstart treats it as the storage backend.
- 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 148 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 November 21, 2026, and from our analysis. They are not legal advice.
Star history
- christabor/flask_jsondash3,279 ★ · -2
| Repository | 2026-09-24 | 2026-11-21 |
|---|---|---|
| christabor/flask_jsondash | 3.3k | 3.3k |
-2 Stars in the last 58 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
The problem Flask JSONDash solves, and for whom
A team has data behind HTTP endpoints and wants a page of charts. The usual answer is a separate front-end project, a build step, and a component library. Flask JSONDash takes the opposite route: the dashboard is a JSON document, and the blueprint renders it. The README describes the project as a Flask blueprint that lets you create dashboards "without writing any front end (or backend) code", with everything powered through JSON configurations.
The intended reader is a Python developer who already has Flask and does not want to learn a charting stack. Layout, chart types and data sources all live in config. The README lists drag-and-drop layout, bootstrap grid or freeform positioning, templates and iframes, and data utilities for reshaping payloads. That is a tool for internal operations pages, not for a customer-facing product surface.
The scope is narrower than the feature list suggests. The blueprint supplies the shell and the config plumbing; the actual rendering is delegated to C3.js, D3.js, Plotly and similar libraries, and the README says the power is "leveraged by the various charting libraries that flask-jsondash defers to". If a chart type is not in the supported set, this project does not give you a way to invent it.
How a JSON module becomes a rendered chart
The unit of configuration is a module inside a modules array. Each module carries a type, a name, width, height, a dataSource URL and an order. The blueprint reads that array, and for each entry it fetches the dataSource and hands the payload to the chart library named by type. The README is explicit that any JSON endpoint works "so long as the payload format is correct", and points at docs/schemas.md for the per-chart shapes.
Because the browser fetches dataSource directly, that URL has to be reachable from the client, not just from the Flask process. The README's own examples use http://localhost:5001/test1 and http://127.0.0.1:5004/custom-inputs, which is fine for a local demo and a real constraint once the dashboard is served from a different host.
From version 4.0 the module schema also accepts an inputs object. Each option declares a type, a name, a label and help text, and the README states these map to query parameters, with entries=10 as the example, so the endpoint can filter or reshape what it returns. The same README notes that the order of inputs in the JSON determines their order in the HTML. Persistence is separate from rendering: dashboards are saved through the CHARTS_DB_* settings, which default to a MongoDB instance on localhost, database charts, collection views.
Installing Flask JSONDash and loading a first dashboard
The README gives a clone-and-run path for the bundled example app. It creates a virtualenv, installs the package from source, and starts the test app, which is the fastest way to see whether the blueprint behaves as you expect before touching your own application.
git clone https://github.com/christabor/flask_jsondash.git
cd flask_jsondash
virtualenv env
source env/bin/activate
python setup.py install
cd example_app
python app.pyBefore that app will save anything, MongoDB has to be running. The README says to start it however you like, usually with mongod, and warns that the collection must exist in your Mongo instance and be named by CHARTS_DB_TABLE, with the database named by CHARTS_DB_NAME. The relevant variables are CHARTS_DB_HOST (default localhost), CHARTS_DB_PORT (default 27017), CHARTS_DB_NAME (default charts), CHARTS_DB_TABLE (default views) and CHARTS_ACTIVE_DB, whose only documented option is mongo.
There is also a Docker path. The Makefile's dockerize target builds the base image and brings up the Compose stack. The example publishes MongoDB on port 27017, the endpoints app on 5004, and the dashboard on 8080. Before running it, remove the database's host port mapping if only the containers need it, restrict the web ports to trusted access, and configure authentication and network controls appropriate to the deployment.
make dockerizeTo see charts in action, the README says to run endpoints.py alongside your main app, create a dashboard, choose the edit raw json option, and paste in one of the files from example_app/examples/config. It notes this has been tested using mongodb. A minimal module looks like the README's own example: a timeseries type, a dataSource URL, a width and height, and an order value. If a widget does not render, check the endpoint response, browser errors and the expected schema for that chart type.
Where Flask JSONDash stops being the right tool
The release history is the first limitation. The newest release listed is 6.2.3 from 2017-06-13, with 5.0.0 and 4.0.0 before it in 2016. The repository is not archived and the last push was on 2026-06-26, so the code is not frozen, but setup.py still declares version 6.3.3 while the release list stops at 6.2.3, and the classifiers still name Python 2.7. Anyone who needs a published release cadence, a changelog they can rely on, or a documented support policy will not find one here.
The storage requirement is the second. The quickstart treats MongoDB as the place dashboards are saved, CHARTS_ACTIVE_DB documents mongo as the only option, and the README's demo note says the setup has been tested using mongodb. If your stack is Postgres or SQLite, this is not a drop-in; you are adding a database to run a dashboard.
The third limitation is the schema contract. The project does not normalize your data. Whatever your endpoint returns has to match the shape expected for the chosen chart type, and the README sends you to docs/schemas.md and then to each charting library's own documentation. Debugging a blank chart means working backwards through three layers: your endpoint, the schema, and the library. There is also no documented rollback or migration story for saved dashboards, and the README does not describe what happens to existing records when the config format changes between major versions.
Flask JSONDash against a general-purpose dashboard stack
The natural comparison is Grafana, which most teams reach for when they want charts over time-series data. The difference is where the configuration lives. Grafana keeps dashboards in its own database and queries data sources through connectors it maintains; you build panels in its UI. Flask JSONDash keeps dashboards as JSON documents you can paste into an editor, and it does not query your data itself. It fetches a URL and renders what comes back.
That makes Flask JSONDash better suited to a Flask app whose endpoints already return chart-ready JSON, and worse suited to anything where you want alerting, user management or a query language. The trade is control for capability: you own the endpoint, the payload and the deployment, and in exchange you also own the schema mismatch when a chart library changes its expected input.
A lighter alternative is to skip the blueprint and render the same C3.js or Plotly charts directly in a Flask template with a few Jinja loops. You lose drag-and-drop layout, the saved-dashboard store and the inputs system, but you also drop MongoDB and a dependency whose published releases stopped in 2017. For a single fixed dashboard that is often the smaller commitment.
Maintenance, licence and upgrade cost
The licence is MIT, stated in setup.py and in the repository's LICENSE file. That permits commercial use and modification, with the usual requirement to keep the copyright notice. Note the mismatch inside setup.py itself: the license field says MIT while the classifiers list "License :: OSI Approved :: BSD License". If licence precision matters for your review process, read the LICENSE file rather than the classifier.
Upgrade cost is dominated by the gap between published releases and the working tree. The release list ends at 6.2.3 in 2017 while setup.py declares 6.3.3, so pinning to a PyPI version and pinning to the repository are not the same thing. The dependency list is small (click, Flask, cerberus, pymongo) but pinned: pymongo is fixed at 4.6.3 and click at 7.0, which will conflict with applications that need different versions of either. The Makefile provides the maintenance surface you would use: tests runs tox, coverage produces an HTML report, fixtures loads the example dashboards, dropall deletes them, and fixturize dumps existing records into a fixtures directory. That last target is the closest thing to a backup mechanism the repository offers.
Editorial conclusion
Adopt Flask JSONDash if you already run Flask and MongoDB and want a chart dashboard described by JSON rather than by a React codebase; the example_app plus docker-compose.yml gets you a working instance quickly. Do not adopt it if you need a maintained product with a release cadence, since the newest release listed is 6.2.3 from 2017-06-13, or if you cannot run MongoDB, because the quickstart treats it as the storage backend. Verify first that your endpoint payloads match the schemas in docs/schemas.md, and check the CHARTS_DB_* environment variables against your own MongoDB instance before wiring the blueprint into an existing app.
Frequently asked questions
What is Flask JSONDash used for?
It builds chart dashboards from JSON configuration inside a Flask app. The README describes it as a Flask blueprint that creates dashboards without writing front-end or back-end code, using your own JSON endpoints as data sources.
How do I install Flask JSONDash?
The README's quickstart clones the repository, creates a virtualenv, runs python setup.py install, and starts example_app/app.py. The Makefile also has a dockerize target that builds the base image and brings up the docker-compose stack.
Does Flask JSONDash need MongoDB?
The quickstart documents MongoDB as the storage backend, with CHARTS_ACTIVE_DB listing mongo as the only option and CHARTS_DB_HOST, CHARTS_DB_PORT, CHARTS_DB_NAME and CHARTS_DB_TABLE controlling the connection. The README notes the demo has been tested using mongodb.
What format does the data endpoint need to return?
The README says any JSON endpoint works as long as the payload format is correct, and points to docs/schemas.md for the per-chart-type shapes. Each chart type defers to a different library, so the expected payload varies.
Can a chart be interactive?
Yes, from version 4.0 the module config accepts an inputs object whose options map to query parameters on the dataSource URL. The README uses entries=10 as the example, and notes that the order of inputs in the JSON determines their order in the HTML.
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/christabor-flask-jsondash)Star history chart for your README
[](https://hysenlabs.com/projects/christabor-flask-jsondash)Was this useful?