<!doctype html>
<html lang="en" dir="ltr" class="docs-wrapper docs-doc-page docs-version-current plugin-docs plugin-id-default docs-doc-id-creating-charts-dashboards/creating-your-first-dashboard" data-has-hydrated="false">
<head>
<meta charset="UTF-8">
<meta name="generator" content="Docusaurus v2.4.3">
<title data-rh="true">Creating Your First Dashboard | Superset</title><meta data-rh="true" name="viewport" content="width=device-width,initial-scale=1"><meta data-rh="true" name="twitter:card" content="summary_large_image"><meta data-rh="true" property="og:url" content="https://superset.apache.org/docs/creating-charts-dashboards/creating-your-first-dashboard"><meta data-rh="true" name="docusaurus_locale" content="en"><meta data-rh="true" name="docsearch:language" content="en"><meta data-rh="true" name="docusaurus_version" content="current"><meta data-rh="true" name="docusaurus_tag" content="docs-default-current"><meta data-rh="true" name="docsearch:version" content="current"><meta data-rh="true" name="docsearch:docusaurus_tag" content="docs-default-current"><meta data-rh="true" property="og:title" content="Creating Your First Dashboard | Superset"><meta data-rh="true" name="description" content="Creating Your First Dashboard"><meta data-rh="true" property="og:description" content="Creating Your First Dashboard"><link data-rh="true" rel="icon" href="/img/favicon.ico"><link data-rh="true" rel="canonical" href="https://superset.apache.org/docs/creating-charts-dashboards/creating-your-first-dashboard"><link data-rh="true" rel="alternate" href="https://superset.apache.org/docs/creating-charts-dashboards/creating-your-first-dashboard" hreflang="en"><link data-rh="true" rel="alternate" href="https://superset.apache.org/docs/creating-charts-dashboards/creating-your-first-dashboard" hreflang="x-default"><link data-rh="true" rel="preconnect" href="https://WR5FASX5ED-dsn.algolia.net" crossorigin="anonymous"><link rel="preconnect" href="https://www.google-analytics.com">
<script>window.ga=window.ga||function(){(ga.q=ga.q||[]).push(arguments)},ga.l=+new Date,ga("create","G-133LHD3B3N","auto"),ga("set","anonymizeIp",!0),ga("send","pageview")</script>
<script async src="https://www.google-analytics.com/analytics.js"></script>
<link rel="preconnect" href="https://www.google-analytics.com">
<link rel="preconnect" href="https://www.googletagmanager.com">
<script async src="https://www.googletagmanager.com/gtag/js?id=G-133LHD3B3N"></script>
<script>function gtag(){dataLayer.push(arguments)}window.dataLayer=window.dataLayer||[],gtag("js",new Date),gtag("config","G-133LHD3B3N",{anonymize_ip:!0})</script>


<link rel="search" type="application/opensearchdescription+xml" title="Superset" href="/opensearch.xml">



<script src="/script/matomo.js"></script>
<script src="https://www.bugherd.com/sidebarv2.js?apikey=enilpiu7bgexxsnoqfjtxa" async></script><link rel="stylesheet" href="/assets/css/styles.686b4caa.css">
<link rel="preload" href="/assets/js/runtime~main.29a1022f.js" as="script">
<link rel="preload" href="/assets/js/main.ecd8e30e.js" as="script">
</head>
<body class="navigation-with-keyboard">
<script>!function(){function t(t){document.documentElement.setAttribute("data-theme",t)}var e=function(){var t=null;try{t=new URLSearchParams(window.location.search).get("docusaurus-theme")}catch(t){}return t}()||function(){var t=null;try{t=localStorage.getItem("theme")}catch(t){}return t}();t(null!==e?e:"light")}()</script><div id="__docusaurus">
<div role="region" aria-label="Skip to main content"><a class="skipToContent_fXgn" href="#__docusaurus_skipToContent_fallback">Skip to main content</a></div><nav aria-label="Main" class="navbar navbar--fixed-top"><div class="navbar__inner"><div class="navbar__items"><button aria-label="Toggle navigation bar" aria-expanded="false" class="navbar__toggle clean-btn" type="button"><svg width="30" height="30" viewBox="0 0 30 30" aria-hidden="true"><path stroke="currentColor" stroke-linecap="round" stroke-miterlimit="10" stroke-width="2" d="M4 7h22M4 15h22M4 23h22"></path></svg></button><a class="navbar__brand" href="/"><div class="navbar__logo"><img src="/img/superset-logo-horiz.svg" alt="Superset Logo" class="themedImage_ToTc themedImage--light_HNdA"><img src="/img/superset-logo-horiz-dark.svg" alt="Superset Logo" class="themedImage_ToTc themedImage--dark_i4oU"></div></a><div class="navbar__item dropdown dropdown--hoverable"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">Documentation</a><ul class="dropdown__menu"><li><a class="dropdown__link" href="/docs/intro">Getting Started</a></li><li><a class="dropdown__link" href="/docs/frequently-asked-questions">FAQ</a></li></ul></div><div class="navbar__item dropdown dropdown--hoverable"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">Community</a><ul class="dropdown__menu"><li><a class="dropdown__link" href="/community">Resources</a></li><li><a href="https://github.com/apache/superset" target="_blank" rel="noopener noreferrer" class="dropdown__link">GitHub<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a href="http://bit.ly/join-superset-slack" target="_blank" rel="noopener noreferrer" class="dropdown__link">Slack<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a href="https://lists.apache.org/list.html?dev@superset.apache.org" target="_blank" rel="noopener noreferrer" class="dropdown__link">Mailing List<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a href="https://stackoverflow.com/questions/tagged/apache-superset" target="_blank" rel="noopener noreferrer" class="dropdown__link">Stack Overflow<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li></ul></div></div><div class="navbar__items navbar__items--right"><a class="navbar__item navbar__link default-button-theme get-started-button" href="/docs/intro">Get Started</a><a href="https://github.com/apache/superset" target="_blank" rel="noopener noreferrer" class="navbar__item navbar__link github-button"></a><div class="searchBox_ZlJk"><button type="button" class="DocSearch DocSearch-Button" aria-label="Search"><span class="DocSearch-Button-Container"><svg width="20" height="20" class="DocSearch-Search-Icon" viewBox="0 0 20 20"><path d="M14.386 14.386l4.0877 4.0877-4.0877-4.0877c-2.9418 2.9419-7.7115 2.9419-10.6533 0-2.9419-2.9418-2.9419-7.7115 0-10.6533 2.9418-2.9419 7.7115-2.9419 10.6533 0 2.9419 2.9418 2.9419 7.7115 0 10.6533z" stroke="currentColor" fill="none" fill-rule="evenodd" stroke-linecap="round" stroke-linejoin="round"></path></svg><span class="DocSearch-Button-Placeholder">Search</span></span><span class="DocSearch-Button-Keys"></span></button></div></div></div><div role="presentation" class="navbar-sidebar__backdrop"></div></nav><div id="__docusaurus_skipToContent_fallback" class="main-wrapper mainWrapper_z2l0 docsWrapper_BCFX"><button aria-label="Scroll back to top" class="clean-btn theme-back-to-top-button backToTopButton_sjWU" type="button"></button><div class="docPage__5DB"><aside class="theme-doc-sidebar-container docSidebarContainer_b6E3"><div class="sidebarViewport_Xe31"><div class="sidebar_njMd"><nav aria-label="Docs sidebar" class="menu thin-scrollbar menu_SIkG"><ul class="theme-doc-sidebar-menu menu__list"><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-1 menu__list-item"><a class="menu__link" href="/docs/intro">Introduction</a></li><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-1 menu__list-item"><a class="menu__link" href="/docs/quickstart">Quickstart</a></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a class="menu__link menu__link--sublist menu__link--sublist-caret" aria-expanded="false" href="/docs/installation/installing-superset-using-docker-compose">Installation and Configuration</a></div></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item"><div class="menu__list-item-collapsible"><a class="menu__link menu__link--sublist menu__link--sublist-caret menu__link--active" aria-expanded="true" href="/docs/creating-charts-dashboards/creating-your-first-dashboard">Creating Charts and Dashboards</a></div><ul style="display:block;overflow:visible;height:auto" class="menu__list"><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class="menu__link menu__link--active" aria-current="page" tabindex="0" href="/docs/creating-charts-dashboards/creating-your-first-dashboard">Creating Your First Dashboard</a></li><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class="menu__link" tabindex="0" href="/docs/creating-charts-dashboards/exploring-data">Exploring Data in Superset</a></li></ul></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a class="menu__link menu__link--sublist menu__link--sublist-caret" aria-expanded="false" href="/docs/databases/installing-database-drivers">Connecting to Databases</a></div></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a class="menu__link menu__link--sublist menu__link--sublist-caret" aria-expanded="false" href="/docs/miscellaneous/country-map-tools">Miscellaneous</a></div></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a class="menu__link menu__link--sublist menu__link--sublist-caret" aria-expanded="false" href="/docs/contributing/contributing-page">Contributing</a></div></li><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-1 menu__list-item"><a class="menu__link" href="/docs/frequently-asked-questions">Frequently Asked Questions</a></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a class="menu__link menu__link--sublist" aria-expanded="false" href="/docs/security/">Security</a><button aria-label="Toggle the collapsible sidebar category &#x27;Security&#x27;" type="button" class="clean-btn menu__caret"></button></div></li><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-1 menu__list-item"><a class="menu__link" href="/docs/api">API</a></li></ul></nav></div></div></aside><main class="docMainContainer_gTbr"><div class="container padding-top--md padding-bottom--lg"><style data-emotion-css="dhwkje">.css-dhwkje{position:fixed;bottom:20px;right:20px;padding:1rem;padding-left:4rem;background-color:#444;border-radius:10px;z-index:9999;background-image:url('/img/github-dark.png');background-size:2rem;background-position:1rem center;background-repeat:no-repeat;-webkit-transition:background-color 0.3s;transition:background-color 0.3s;bpx-shadow:0 0 0 0 rgba(0,0,0,0);scale:.9;-webkit-transition:all 0.3s;transition:all 0.3s;}.css-dhwkje:hover{background-color:#333;box-shadow:5px 5px 10px 0 rgba(0,0,0,0.3);scale:1;}</style><a href="https://github.com/apache/superset/edit/master/docs/docs/creating-charts-dashboards/creating-your-first-dashboard.mdx" target="_blank" rel="noopener noreferrer" class="css-dhwkje">Edit this page on GitHub</a><div class="row"><div class="col docItemCol_VOVn"><div class="docItemContainer_Djhp"><article><nav class="theme-doc-breadcrumbs breadcrumbsContainer_Z_bl" aria-label="Breadcrumbs"><ul class="breadcrumbs" itemscope="" itemtype="https://schema.org/BreadcrumbList"><li class="breadcrumbs__item"><a aria-label="Home page" class="breadcrumbs__link" href="/"><svg viewBox="0 0 24 24" class="breadcrumbHomeIcon_YNFT"><path d="M10 19v-5h4v5c0 .55.45 1 1 1h3c.55 0 1-.45 1-1v-7h1.7c.46 0 .68-.57.33-.87L12.67 3.6c-.38-.34-.96-.34-1.34 0l-8.36 7.53c-.34.3-.13.87.33.87H5v7c0 .55.45 1 1 1h3c.55 0 1-.45 1-1z" fill="currentColor"></path></svg></a></li><li class="breadcrumbs__item"><span class="breadcrumbs__link">Creating Charts and Dashboards</span><meta itemprop="position" content="1"></li><li itemscope="" itemprop="itemListElement" itemtype="https://schema.org/ListItem" class="breadcrumbs__item breadcrumbs__item--active"><span class="breadcrumbs__link" itemprop="name">Creating Your First Dashboard</span><meta itemprop="position" content="2"></li></ul></nav><div class="tocCollapsible_ETCw theme-doc-toc-mobile tocMobile_ITEo"><button type="button" class="clean-btn tocCollapsibleButton_TO0P">On this page</button></div><div class="theme-doc-markdown markdown"><h2 class="anchor anchorWithStickyNavbar_LWe7" id="creating-your-first-dashboard">Creating Your First Dashboard<a href="#creating-your-first-dashboard" class="hash-link" aria-label="Direct link to Creating Your First Dashboard" title="Direct link to Creating Your First Dashboard">​</a></h2><p>This section is focused on documentation for end-users who will be using Superset
for the data analysis and exploration workflow
(data analysts, business analysts, data
scientists, etc). In addition to this site, <a href="http://preset.io/" target="_blank" rel="noopener noreferrer">Preset.io</a> maintains an updated set of end-user
documentation at <a href="https://docs.preset.io/" target="_blank" rel="noopener noreferrer">docs.preset.io</a>.</p><p>This tutorial targets someone who wants to create charts and dashboards in Superset. We’ll show you
how to connect Superset to a new database and configure a table in that database for analysis.
You’ll also explore the data you’ve exposed and add a visualization to a dashboard so that you get a
feel for the end-to-end user experience.</p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="connecting-to-a-new-database">Connecting to a new database<a href="#connecting-to-a-new-database" class="hash-link" aria-label="Direct link to Connecting to a new database" title="Direct link to Connecting to a new database">​</a></h3><p>Superset itself doesn&#x27;t have a storage layer to store your data but instead pairs with
your existing SQL-speaking database or data store.</p><p>First things first, we need to add the connection credentials to your database to be able
to query and visualize data from it. If you&#x27;re using Superset locally via
<a href="/docs/installation/installing-superset-using-docker-compose">Docker compose</a>, you can
skip this step because a Postgres database, named <strong>examples</strong>, is included and
pre-configured in Superset for you.</p><p>Under the <strong>+</strong> menu in the top right, select Data, and then the <em>Connect Database</em> option:</p><img loading="lazy" src="/img/tutorial/tutorial_01_add_database_connection.png" width="600" class="img_ev3q"> <!-- --> <br><br><p>Then select your database type in the resulting modal:</p><img loading="lazy" src="/img/tutorial/tutorial_02_select_database.png" width="600" class="img_ev3q"> <!-- --> <br><br><p>Once you&#x27;ve selected a database, you can configure a number of advanced options in this window,
or for the purposes of this walkthrough, you can click the link below all these fields:</p><img loading="lazy" src="/img/tutorial/tutorial_03a_database_connection_string_link.png" width="600" class="img_ev3q"> <!-- --> <br><br><p>Once you&#x27;ve clicked that link you only need to specify two things (the database name and SQLAlchemy URI):</p><img loading="lazy" src="/img/tutorial/tutorial_03b_connection_string_details.png" width="600" class="img_ev3q"> <!-- --> <br><br><p>As noted in the text below the form, you should refer to the SQLAlchemy documentation on
<a href="https://docs.sqlalchemy.org/en/12/core/engines.html#database-urls" target="_blank" rel="noopener noreferrer">creating new connection URIs</a>
for your target database.</p><p>Click the <strong>Test Connection</strong> button to confirm things work end to end. If the connection looks good, save the configuration
by clicking the <strong>Connect</strong> button in the bottom right corner of the modal window:</p><p>Congratulations, you&#x27;ve just added a new data source in Superset!</p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="registering-a-new-table">Registering a new table<a href="#registering-a-new-table" class="hash-link" aria-label="Direct link to Registering a new table" title="Direct link to Registering a new table">​</a></h3><p>Now that you’ve configured a data source, you can select specific tables (called <strong>Datasets</strong> in Superset)
that you want exposed in Superset for querying.</p><p>Navigate to <strong>Data ‣ Datasets</strong> and select the <strong>+ Dataset</strong> button in the top right corner.</p><img loading="lazy" src="/img/tutorial/tutorial_08_sources_tables.png" class="img_ev3q"><p>A modal window should pop up in front of you. Select your <strong>Database</strong>,
<strong>Schema</strong>, and <strong>Table</strong> using the drop downs that appear. In the following example,
we register the <strong>cleaned_sales_data</strong> table from the <strong>examples</strong> database.</p><img loading="lazy" src="/img/tutorial/tutorial_09_add_new_table.png" class="img_ev3q"><p>To finish, click the <strong>Add</strong> button in the bottom right corner. You should now see your dataset in the list of datasets.</p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="customizing-column-properties">Customizing column properties<a href="#customizing-column-properties" class="hash-link" aria-label="Direct link to Customizing column properties" title="Direct link to Customizing column properties">​</a></h3><p>Now that you&#x27;ve registered your dataset, you can configure column properties
for how the column should be treated in the Explore workflow:</p><ul><li>Is the column temporal? (should it be used for slicing &amp; dicing in time series charts?)</li><li>Should the column be filterable?</li><li>Is the column dimensional?</li><li>If it&#x27;s a datetime column, how should Superset parse
the datetime format? (using the <a href="https://en.wikipedia.org/wiki/ISO_8601" target="_blank" rel="noopener noreferrer">ISO-8601 string pattern</a>)</li></ul><img loading="lazy" src="/img/tutorial/tutorial_column_properties.png" class="img_ev3q"><h3 class="anchor anchorWithStickyNavbar_LWe7" id="superset-semantic-layer">Superset semantic layer<a href="#superset-semantic-layer" class="hash-link" aria-label="Direct link to Superset semantic layer" title="Direct link to Superset semantic layer">​</a></h3><p>Superset has a thin semantic layer that adds many quality of life improvements for analysts.
The Superset semantic layer can store 2 types of computed data:</p><ol><li>Virtual metrics: you can write SQL queries that aggregate values
from multiple column (e.g. <code>SUM(recovered) / SUM(confirmed)</code>) and make them
available as columns for (e.g. <code>recovery_rate</code>) visualization in Explore.
Aggregate functions are allowed and encouraged for metrics.</li></ol><img loading="lazy" src="/img/tutorial/tutorial_sql_metric.png" class="img_ev3q"><p>You can also certify metrics if you&#x27;d like for your team in this view.</p><ol start="2"><li>Virtual calculated columns: you can write SQL queries that
customize the appearance and behavior
of a specific column (e.g. <code>CAST(recovery_rate) as float</code>).
Aggregate functions aren&#x27;t allowed in calculated columns.</li></ol><img loading="lazy" src="/img/tutorial/tutorial_calculated_column.png" class="img_ev3q"><h3 class="anchor anchorWithStickyNavbar_LWe7" id="creating-charts-in-explore-view">Creating charts in Explore view<a href="#creating-charts-in-explore-view" class="hash-link" aria-label="Direct link to Creating charts in Explore view" title="Direct link to Creating charts in Explore view">​</a></h3><p>Superset has 2 main interfaces for exploring data:</p><ul><li><strong>Explore</strong>: no-code viz builder. Select your dataset, select the chart,
customize the appearance, and publish.</li><li><strong>SQL Lab</strong>: SQL IDE for cleaning, joining, and preparing data for Explore workflow</li></ul><p>We&#x27;ll focus on the Explore view for creating charts right now.
To start the Explore workflow from the <strong>Datasets</strong> tab, start by clicking the name
of the dataset that will be powering your chart.</p><img loading="lazy" src="/img/tutorial/tutorial_launch_explore.png" class="img_ev3q"><br><br><p>You&#x27;re now presented with a powerful workflow for exploring data and iterating on charts.</p><ul><li>The <strong>Dataset</strong> view on the left-hand side has a list of columns and metrics,
scoped to the current dataset you selected.</li><li>The <strong>Data</strong> preview below the chart area also gives you helpful data context.</li><li>Using the <strong>Data</strong> tab and <strong>Customize</strong> tabs, you can change the visualization type,
select the temporal column, select the metric to group by, and customize
the aesthetics of the chart.</li></ul><p>As you customize your chart using drop-down menus, make sure to click the <strong>Run</strong> button
to get visual feedback.</p><img loading="lazy" src="/img/tutorial/tutorial_explore_run.jpg" class="img_ev3q"><p>In the following screenshot, we craft a grouped Time-series Bar Chart to visualize
our quarterly sales data by product line just by clicking options in drop-down menus.</p><img loading="lazy" src="/img/tutorial/tutorial_explore_settings.jpg" class="img_ev3q"><h3 class="anchor anchorWithStickyNavbar_LWe7" id="creating-a-slice-and-dashboard">Creating a slice and dashboard<a href="#creating-a-slice-and-dashboard" class="hash-link" aria-label="Direct link to Creating a slice and dashboard" title="Direct link to Creating a slice and dashboard">​</a></h3><p>To save your chart, first click the <strong>Save</strong> button. You can either:</p><ul><li>Save your chart and add it to an existing dashboard</li><li>Save your chart and add it to a new dashboard</li></ul><p>In the following screenshot, we save the chart to a new &quot;Superset Duper Sales Dashboard&quot;:</p><img loading="lazy" src="/img/tutorial/tutorial_save_slice.png" class="img_ev3q"><p>To publish, click <strong>Save and goto Dashboard</strong>.</p><p>Behind the scenes, Superset will create a slice and store all the information needed
to create your chart in its thin data layer
(the query, chart type, options selected, name, etc).</p><img loading="lazy" src="/img/tutorial/tutorial_first_dashboard.png" style="width:100%;max-width:500px" class="img_ev3q"><p> To resize the chart, start by clicking the Edit Dashboard button in the top right corner.</p><img loading="lazy" src="/img/tutorial/tutorial_edit_button.png" width="300" class="img_ev3q"><p>Then, click and drag the bottom right corner of the chart until the chart layout snaps
into a position you like onto the underlying grid.</p><img loading="lazy" src="/img/tutorial/tutorial_chart_resize.png" style="width:100%;max-width:500px" class="img_ev3q"><p> Click <strong>Save</strong> to persist the changes.</p><p>Congrats! You’ve successfully linked, analyzed, and visualized data in Superset. There are a wealth
of other table configuration and visualization options, so please start exploring and creating
slices and dashboards of your own</p><p>ֿ</p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="manage-access-to-dashboards">Manage access to Dashboards<a href="#manage-access-to-dashboards" class="hash-link" aria-label="Direct link to Manage access to Dashboards" title="Direct link to Manage access to Dashboards">​</a></h3><p>Access to dashboards is managed via owners (users that have edit permissions to the dashboard)</p><p>Non-owner users access can be managed two different ways:</p><ol><li>Dataset permissions - if you add to the relevant role permissions to datasets it automatically grants implicit access to all dashboards that uses those permitted datasets</li><li>Dashboard roles - if you enable <strong>DASHBOARD_RBAC</strong> <a href="/docs/installation/configuring-superset#feature-flags">feature flag</a> then you be able to manage which roles can access the dashboard<ul><li>Granting a role access to a dashboard will bypass dataset level checks. Having dashboard access implicitly grants read access to all the featured charts in the dashboard, and thereby also all the associated datasets.</li><li>If no roles are specified for a dashboard, regular <strong>Dataset permissions</strong> will apply.</li></ul></li></ol><img loading="lazy" src="/img/tutorial/tutorial_dashboard_access.png" class="img_ev3q"><h3 class="anchor anchorWithStickyNavbar_LWe7" id="customizing-dashboard">Customizing dashboard<a href="#customizing-dashboard" class="hash-link" aria-label="Direct link to Customizing dashboard" title="Direct link to Customizing dashboard">​</a></h3><p>The following URL parameters can be used to modify how the dashboard is rendered:</p><ul><li><code>standalone</code>:<ul><li><code>0</code> (default): dashboard is displayed normally</li><li><code>1</code>: Top Navigation is hidden</li><li><code>2</code>: Top Navigation + title is hidden</li><li><code>3</code>: Top Navigation + title + top level tabs are hidden</li></ul></li><li><code>show_filters</code>:<ul><li><code>0</code>: render dashboard without Filter Bar</li><li><code>1</code> (default): render dashboard with Filter Bar if native filters are enabled</li></ul></li><li><code>expand_filters</code>:<ul><li>(default): render dashboard with Filter Bar expanded if there are native filters</li><li><code>0</code>: render dashboard with Filter Bar collapsed</li><li><code>1</code>: render dashboard with Filter Bar expanded</li></ul></li></ul><p>For example, when running the local development build, the following will disable the
Top Nav and remove the Filter Bar:
<code>http://localhost:8088/superset/dashboard/my-dashboard/?standalone=1&amp;show_filters=0</code></p></div><footer class="theme-doc-footer docusaurus-mt-lg"><div class="theme-doc-footer-edit-meta-row row"><div class="col"><a href="https://github.com/apache/superset/edit/master/docs/docs/creating-charts-dashboards/creating-your-first-dashboard.mdx" target="_blank" rel="noreferrer noopener" class="theme-edit-this-page"><svg fill="currentColor" height="20" width="20" viewBox="0 0 40 40" class="iconEdit_Z9Sw" aria-hidden="true"><g><path d="m34.5 11.7l-3 3.1-6.3-6.3 3.1-3q0.5-0.5 1.2-0.5t1.1 0.5l3.9 3.9q0.5 0.4 0.5 1.1t-0.5 1.2z m-29.5 17.1l18.4-18.5 6.3 6.3-18.4 18.4h-6.3v-6.2z"></path></g></svg>Edit this page</a></div><div class="col lastUpdated_vwxv"></div></div></footer></article><nav class="pagination-nav docusaurus-mt-lg" aria-label="Docs pages"><a class="pagination-nav__link pagination-nav__link--prev" href="/docs/installation/docker"><div class="pagination-nav__sublabel">Previous</div><div class="pagination-nav__label">Docker builds, images and tags</div></a><a class="pagination-nav__link pagination-nav__link--next" href="/docs/creating-charts-dashboards/exploring-data"><div class="pagination-nav__sublabel">Next</div><div class="pagination-nav__label">Exploring Data in Superset</div></a></nav></div></div><div class="col col--3"><div class="tableOfContents_bqdL thin-scrollbar theme-doc-toc-desktop"><ul class="table-of-contents table-of-contents__left-border"><li><a href="#creating-your-first-dashboard" class="table-of-contents__link toc-highlight">Creating Your First Dashboard</a><ul><li><a href="#connecting-to-a-new-database" class="table-of-contents__link toc-highlight">Connecting to a new database</a></li><li><a href="#registering-a-new-table" class="table-of-contents__link toc-highlight">Registering a new table</a></li><li><a href="#customizing-column-properties" class="table-of-contents__link toc-highlight">Customizing column properties</a></li><li><a href="#superset-semantic-layer" class="table-of-contents__link toc-highlight">Superset semantic layer</a></li><li><a href="#creating-charts-in-explore-view" class="table-of-contents__link toc-highlight">Creating charts in Explore view</a></li><li><a href="#creating-a-slice-and-dashboard" class="table-of-contents__link toc-highlight">Creating a slice and dashboard</a></li><li><a href="#manage-access-to-dashboards" class="table-of-contents__link toc-highlight">Manage access to Dashboards</a></li><li><a href="#customizing-dashboard" class="table-of-contents__link toc-highlight">Customizing dashboard</a></li></ul></li></ul></div></div></div></div></main></div></div><footer class="footer"><div class="container container-fluid"><div class="footer__bottom text--center"><div class="footer__copyright">
          <div class="footer__applitools">
            We use &nbsp;<a href="https://applitools.com/" target="_blank" rel="nofollow"><img src="/img/applitools.png" title="Applitools"></a>
          </div>
          <p>Copyright © 2024,
          The <a href="https://www.apache.org/" target="_blank" rel="noreferrer">Apache Software Foundation</a>,
          Licensed under the Apache <a href="https://apache.org/licenses/LICENSE-2.0" target="_blank" rel="noreferrer">License</a>.</p>
          <p><small>Apache Superset, Apache, Superset, the Superset logo, and the Apache feather logo are either registered trademarks or trademarks of The Apache Software Foundation. All other products or name brands are trademarks of their respective holders, including The Apache Software Foundation.
          <a href="https://www.apache.org/" target="_blank">Apache Software Foundation</a> resources</small></p>
          <img class="footer__divider" src="/img/community/line.png" alt="Divider">
          <p>
            <small>
              <a href="/docs/security/" target="_blank" rel="noreferrer">Security</a>&nbsp;|&nbsp;
              <a href="https://www.apache.org/foundation/sponsorship.html" target="_blank" rel="noreferrer">Donate</a>&nbsp;|&nbsp;
              <a href="https://www.apache.org/foundation/thanks.html" target="_blank" rel="noreferrer">Thanks</a>&nbsp;|&nbsp;
              <a href="https://apache.org/events/current-event" target="_blank" rel="noreferrer">Events</a>&nbsp;|&nbsp;
              <a href="https://apache.org/licenses/" target="_blank" rel="noreferrer">License</a>
            </small>
          </p>
          <!-- telemetry/analytics pixel: -->
          <img referrerpolicy="no-referrer-when-downgrade" src="https://static.scarf.sh/a.png?x-pxid=39ae6855-95fc-4566-86e5-360d542b0a68">
          </div></div></div></footer></div>
<script src="/assets/js/runtime~main.29a1022f.js"></script>
<script src="/assets/js/main.ecd8e30e.js"></script>
</body>
</html>