Skip to content

The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:

docs - update embedding docs (#66784)

Jeff Bruemmer426acdbc859c
diff --git a/docs/README.md b/docs/README.md
index 18c1279eac8..91252508504 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -204,16 +204,12 @@ Metabase's reference documentation.
- [Embedding overview](./embedding/start.md)
- [Embedding introduction](./embedding/introduction.md)
-- [Modular embedding](./embedding/modular-embedding.md)
-- [Modular embedding SDK](./embedding/sdk/introduction.md)
-- Full app embedding
- - [Full app embedding overview](./embedding/full-app-embedding.md)
- - [Full app embedding quick start](./embedding/full-app-embedding-quick-start-guide.md)
-- Static embedding
- - [Static embedding overview](./embedding/static-embedding.md)
- - [Parameters for static embeds](./embedding/static-embedding-parameters.md)
- - [Translate embedded dashboards and questions](./embedding/translations.md)
-- [Securing embedded Metabase](./embedding/securing-embeds.md)
+- Modular embedding
+ - [SSO](./embedding/modular-embedding.md)
+ - [Guest](./embedding/guest-embedding.md)
+ - [SDK](./embedding/sdk/introduction.md)
+- [Full app embedding](./embedding/full-app-embedding.md)
+- [Securing embeds](./embedding/securing-embeds.md)
### Configuration
diff --git a/docs/actions/introduction.md b/docs/actions/introduction.md
index 91ba3f5bc34..ade9fd11b4b 100644
--- a/docs/actions/introduction.md
+++ b/docs/actions/introduction.md
@@ -64,7 +64,7 @@ Before using actions in production, consider playing around with actions on some
- If caching is enabled for the relevant table or model, you may not see the effects of an action in Metabase until Metabase refreshes the data (though you can always manually refresh the data).
- When creating records on a table that lacks an automatically generated primary key, you'll need to input an available ID (i.e., an ID not already in use by another record).
- You can't "undo" actions. You can, however, create and run an action to recreate a deleted record, or change an updated record back to its original values (provided you know the original values).
-- Actions are unavailable for public dashboards, and dashboards in [static embeds](../embedding/static-embedding.md).
+- Actions are unavailable for public dashboards and dashboards in [guest embeds](../embedding/guest-embedding.md). To use actions in embeds, you can use [modular embedding](../embedding/modular-embedding.md) with SSO or [full app embedding](../embedding/full-app-embedding.md).
## Further reading
diff --git a/docs/configuring-metabase/fonts.md b/docs/configuring-metabase/fonts.md
index 17e813cb6e4..11dd15c3ebb 100644
--- a/docs/configuring-metabase/fonts.md
+++ b/docs/configuring-metabase/fonts.md
@@ -121,7 +121,7 @@ To support multiple character sets, for example both Latin and Cyrillic, you'll
## Customizing the font for individual embedded items
-In addition to the [included fonts](#included-fonts), if you set a custom font for your Metabase, that font will be selectable from "Use instance font" in [static embeds](../embedding/static-embedding.md).
+When configuring [guest embeds](../embedding/guest-embedding.md), you can select from any of the [included fonts](#included-fonts). If you've set a custom font for your Metabase, you can also select "Use instance font" to use your custom font in the embed.
## Further reading
diff --git a/docs/configuring-metabase/localization.md b/docs/configuring-metabase/localization.md
index f1c7197688b..2a76bb3f691 100644
--- a/docs/configuring-metabase/localization.md
+++ b/docs/configuring-metabase/localization.md
@@ -59,7 +59,7 @@ Supported languages include:
| Ukrainian | `uk` |
| Vietnamese | `vi` |
-The locale codes are relevant for setting the language in [static embeds](../embedding/static-embedding-parameters.md#setting-the-language-for-a-static-embed).
+The locale codes are relevant for setting the language in [guest embeds](../embedding/guest-embedding.md).
> While Metabase can support languages that read right to left, the Metabase UI is designed around languages that read left to right.
@@ -139,4 +139,4 @@ This setting doesn't affect [SQL queries](../questions/native-editor/writing-sql
## Localizing embedded Metabase
-You can translate both Metabase UI elements (like button labels) and content (like dashboard names) in static embeds. See [Setting the language for static embeds](../embedding/static-embedding-parameters.md#setting-the-language-for-a-static-embed) and [Translating embedded dashboards and questions](../embedding/translations.md).
+You can translate both Metabase UI elements (like button labels) and content (like dashboard names) in guest embeds. See [Setting the language for guest embeds](../embedding/guest-embedding.md) and [Translating embedded dashboards and questions](../embedding/translations.md).
diff --git a/docs/dashboards/actions.md b/docs/dashboards/actions.md
index 6d7d0602a89..0e45230712e 100644
--- a/docs/dashboards/actions.md
+++ b/docs/dashboards/actions.md
@@ -50,11 +50,11 @@ If you also wire that filter up to a card with a model on the dashboard, you can
You can add as many buttons as you want, and wire them up to one or more filters.
-## Actions are unavailable for public dashboards and dashboards in static embeds
+## Actions are unavailable for public dashboards and dashboards in guest embeds
-While you can add actions to dashboards and use them in your Metabase, actions won't work on dashboards accessed via [public links](./introduction.md#sharing-dashboards-with-public-links), or dashboards in static embeds.
+While you can add actions to dashboards and use them in your Metabase, actions won't work on dashboards accessed via [public links](./introduction.md#sharing-dashboards-with-public-links), or dashboards in guest embeds.
-If you want people outside of your Metabase to use an action, you can create a [public form for an action](../actions/custom.md#make-public), or expose actions via [Full app embedding](../embedding/full-app-embedding.md).
+If you want people outside of your Metabase to use an action, you can create a [public form for an action](../actions/custom.md#make-public), or expose actions via [modular embedding](../embedding/modular-embedding.md) with SSO or [full app embedding](../embedding/full-app-embedding.md).
## Further reading
diff --git a/docs/embedding/sdk/snippets/appearance/theme.ts b/docs/embedding/appearance.md
similarity index 60%
rename from docs/embedding/sdk/snippets/appearance/theme.ts
rename to docs/embedding/appearance.md
index 29f14342caf..486a0de2f76 100644
--- a/docs/embedding/sdk/snippets/appearance/theme.ts
+++ b/docs/embedding/appearance.md
@@ -1,6 +1,26 @@
-import { defineMetabaseTheme } from "@metabase/embedding-sdk-react";
+---
+title: "Customizing the appearance of modular embeds"
+summary: "Style your embedded Metabase components using themes to customize colors, backgrounds, and more."
+redirect_from:
+ - /docs/latest/embedding/sdk/appearance
+---
-const theme = defineMetabaseTheme({
+# Customizing the appearance of modular embeds
+
+{% include plans-blockquote.html feature="Modular embedding" %}
+
+You can style your embedded [Metabase components](./components.md) with a **theme**.
+
+![Embed share button](./images/embed-share-button.png)
+
+Change the colors, and the code snippet will include a `theme` object in the object passed to the `defineMetabaseConfig` function.
+
+## Theme options
+
+Here's an example that includes the various styling options available via the [modular embedding React SDK](./sdk/introduction.md):
+
+```json
+{
// Specify a font to use from the set of fonts supported by Metabase.
// You can set the font to "Custom" to use the custom font
// configured in your Metabase instance.
@@ -199,4 +219,103 @@ const theme = defineMetabaseTheme({
zIndex: 4,
},
},
-});
+}
+```
+
+
+## Customizing the appearance of an SSO embed
+
+![Behavior and appearance with sso](./images/embed-with-sso.png)
+
+Add a `theme` object to your config object:
+
+
+```html
+<script defer src="http://localhost:3000/app/embed.js"></script>
+<script>
+function defineMetabaseConfig(config) {
+ window.metabaseConfig = config;
+}
+</script>
+
+<script>
+ defineMetabaseConfig({
+ "theme": {
+ "colors": {
+ "background": "#FFFFFF",
+ "text-primary": "hsla(204, 66%, 8%, 0.84)",
+ "brand": "hsla(208, 72%, 60%, 1.00)",
+ "background-hover": "rgb(236, 236, 236)",
+ "background-disabled": "rgb(231, 231, 231)",
+ "background-secondary": "rgb(233, 233, 233)",
+ "background-light": "rgb(233, 233, 233)",
+ "text-secondary": "rgba(9, 30, 44, 0.84)",
+ "text-tertiary": "rgba(11, 37, 54, 0.84)",
+ "brand-hover": "rgb(185, 216, 244)",
+ "brand-hover-light": "rgb(238, 245, 252)"
+ }
+ },
+ "instanceUrl": "http://localhost:3000"
+ });
+</script>
+
+<metabase-dashboard dashboard-id="10"
+ with-title="true"
+ with-downloads="false"
+ with-subscriptions="false"
+ hidden-parameters='["category"]'
+ drills="true">
+</metabase-dashboard>
+```
+
+## Customizing the appearance of a guest embed
+
+![Behavior and appearance](./images/behavior-and-appearance.png)
+
+Add a `theme` object to your config object:
+
+```html
+<script defer src="http://localhost:3000/app/embed.js"></script>
+<script>
+function defineMetabaseConfig(config) {
+ window.metabaseConfig = config;
+}
+</script>
+
+<script>
+ defineMetabaseConfig({
+ "theme": {
+ "colors": {
+ "background": "#FFFFFF",
+ "text-primary": "hsla(204, 66%, 8%, 0.84)",
+ "brand": "hsla(208, 72%, 60%, 1.00)",
+ "background-hover": "rgb(236, 236, 236)",
+ "background-disabled": "rgb(231, 231, 231)",
+ "background-secondary": "rgb(233, 233, 233)",
+ "background-light": "rgb(233, 233, 233)",
+ "text-secondary": "rgba(9, 30, 44, 0.84)",
+ "text-tertiary": "rgba(11, 37, 54, 0.84)",
+ "brand-hover": "rgb(185, 216, 244)",
+ "brand-hover-light": "rgb(238, 245, 252)"
+ }
+ },
+ "isGuest": true,
+ "instanceUrl": "http://localhost:3000"
+ });
+</script>
+
+<metabase-dashboard
+ token=<TODO: Fetch the JWT token from your backend and programmatically pass it to this 'metabase-dashboard' component>
+ with-title="true"
+ with-downloads="false">
+</metabase-dashboard>
+```
+
+## Example app with theming
+
+Check out our [sample app](https://github.com/metabase/modular-embedding-sample-app). Bring your Metabase, embed a question or dashboard, and play around with changing colors.
+
+## Limitations
+
+- CSS variables aren't yet supported. If you'd like Metabase to support CSS variables, please upvote this [feature request](https://github.com/metabase/metabase/issues/59237).
+- Colors set in the visualization settings for a question will override theme colors.
diff --git a/docs/embedding/sdk/authentication.md b/docs/embedding/authentication.md
similarity index 79%
rename from docs/embedding/sdk/authentication.md
rename to docs/embedding/authentication.md
index 16762b20190..cbef8136f2b 100644
--- a/docs/embedding/sdk/authentication.md
+++ b/docs/embedding/authentication.md
@@ -1,24 +1,29 @@
---
-title: Embedded analytics SDK - authentication
+title: Modular embedding - authentication
+summary: Adding SSO with JWT or SAML for authenticating modular embeds.
+redirect_from:
+- /docs/latest/embedding/sdk/authentication
---
-# Embedded analytics SDK - authentication
+# Modular embedding - authentication
-{% include plans-blockquote.html feature="Embedded analytics SDK" sdk=true %}
+{% include plans-blockquote.html feature="Modular embedding" sdk=true %}
-For using the SDK in production, you'll need to set up authentication with SSO.
+For using modular embedding with SSO in production, you'll need to set up authentication.
If you're developing locally, you can also set up authentication with [API keys](#authenticating-locally-with-api-keys).
+You can set up SSO with JWT or SAML.
+
## Setting up JWT SSO
-To set up JWT SSO, you'll need [a Metabase Pro or Enterprise license](https://www.metabase.com/pricing/) (If you don't have a license, check out [this quickstart](./quickstart.md))
+To set up JWT SSO, you'll need [a Metabase Pro or Enterprise license](https://www.metabase.com/pricing/).
Here's a high-level overview:
1. [Enable JWT SSO in your Metabase](#1-enable-jwt-sso-in-your-metabase)
2. [Add a new endpoint to your backend to handle authentication](#2-add-a-new-endpoint-to-your-backend-to-handle-authentication)
-3. [Wire the SDK in your frontend to your new endpoint](#3-wire-the-sdk-in-your-frontend-to-your-new-endpoint)
+3. [Wire your frontend to your new endpoint](#3-wire-your-frontend-to-your-new-endpoint)
### 1. Enable JWT SSO in your Metabase
@@ -28,7 +33,7 @@ Here's a high-level overview:
### 2. Add a new endpoint to your backend to handle authentication
-You'll need add a library to your backend to sign your JSON Web Tokens.
+You'll need to add a library to your backend to sign your JSON Web Tokens.
For Node.js, we recommend jsonwebtoken:
@@ -69,9 +74,9 @@ Here's an example of an Express.js endpoint that handles both:
{% include_file "{{ dirname }}/snippets/authentication/express-server-interactive-and-sdk.ts" %}
```
-### 3. Wire the SDK in your frontend to your new endpoint
+### 3. Wire your frontend to your new endpoint
-Update the SDK config in your frontend code to point your backend's authentication endpoint.
+Update the config in your frontend code to point to your backend's authentication endpoint.
```js
{% include_file "{{ dirname }}/snippets/authentication/auth-config-base.tsx" snippet="example" %}
@@ -97,11 +102,11 @@ You can customize how the SDK fetches the request token by specifying the `fetch
The response should be in the form of `{ jwt: "{JWT_TOKEN}" }`
-## Authenticating with SAML SSO
+## Setting up SAML SSO
{% include plans-blockquote.html feature="SAML authentication" sdk=true %}
-To use SAML single sign-on with the Embedded analytics SDK, you'll need to set up SAML in both your Metabase and your Identity Provider (IdP). See the docs on [SAML-based authentication](../../people-and-groups/authenticating-with-saml.md).
+To use SAML single sign-on with modular embedding, you'll need to set up SAML in both your Metabase and your Identity Provider (IdP). See the docs on [SAML-based authentication](../people-and-groups/authenticating-with-saml.md).
Once SAML is configured in Metabase and your IdP, you can configure the SDK to use SAML by setting the `preferredAuthMethod` in your `MetabaseAuthConfig` to `"saml"`:
@@ -109,13 +114,13 @@ Once SAML is configured in Metabase and your IdP, you can configure the SDK to u
{% include_file "{{ dirname }}/snippets/authentication/auth-config-saml.tsx" snippet="example" %}
```
-Using SAML authentication with the Embedded analytics SDK will typically involve redirecting people to a popup with your Identity Provider's login page for authentication. After successful authentication, the person will be redirected back to the embedded content.
+Using SAML authentication with modular embedding will typically involve redirecting people to a popup with your Identity Provider's login page for authentication. After successful authentication, the person will be redirected back to the embedded content.
-Due to the nature of redirects and popups involved in the SAML flow, SAML authentication with the SDK may not work seamlessly in all embedding contexts, particularly within iframes, depending on browser security policies and your IdP's configuration. We recommend testing auth flows in your target environments.
+Due to the nature of redirects and popups involved in the SAML flow, SAML authentication may not work seamlessly in all embedding contexts, particularly within iframes, depending on browser security policies and your IdP's configuration. We recommend testing auth flows in your target environments.
-Unlike JWT authentication, you won't be able to implement a custom `fetchRequestToken` function on your backend when pairing SAML with the SDK.
+Unlike JWT authentication, you won't be able to implement a custom `fetchRequestToken` function on your backend when pairing SAML with modular embedding.
-## If both SAML and JWT are enabled, the SDK will default to SAML
+## If both SAML and JWT are enabled, modular embedding will default to SAML
You can override this default behavior to prefer the JWT authentication method by setting `preferredAuthMethod="jwt"` in your authentication config:
@@ -139,11 +144,11 @@ This hook can only be used within components wrapped by `MetabaseProvider`.
## Authenticating locally with API keys
-> The Embedded analytics SDK only supports JWT authentication in production. Authentication with API keys is only supported for local development and evaluation purposes.
+> Modular embedding only supports JWT authentication in production. Authentication with API keys is only supported for local development and evaluation purposes.
-For developing locally to try out the SDK, you can authenticate using an API key.
+For developing locally to try out modular embedding, you can authenticate using an API key.
-First, create an [API key](../../people-and-groups/api-keys.md).
+First, create an [API key](../people-and-groups/api-keys.md).
Then you can then use the API key to authenticate with Metabase in your application. All you need to do is include your API key in the config object using the key: `apiKey`.
@@ -155,11 +160,11 @@ Then you can then use the API key to authenticate with Metabase in your applicat
Each end-user _must_ have their own Metabase account.
-The problem with having end-users share a Metabase account is that, even if you filter data on the client side via the SDK, all end-users will still have access to the session token, which they could use to access Metabase directly via the API to get data they're not supposed to see.
+The problem with having end-users share a Metabase account is that, even if you filter data on the client side via modular embedding, all end-users will still have access to the session token, which they could use to access Metabase directly via the API to get data they're not supposed to see.
If each end-user has their own Metabase account, however, you can configure permissions in Metabase and everyone will only have access to the data they should.
-In addition to this, we consider shared accounts to be unfair usage. Fair usage of the SDK involves giving each end-user of the embedded analytics their own Metabase account.
+In addition to this, we consider shared accounts to be unfair usage. Fair usage of modular embedding involves giving each end-user of the embedded analytics their own Metabase account.
## Upgrade guide for JWT SSO setups on SDK version 54 or below
@@ -174,7 +179,7 @@ If you're upgrading from an SDK version 1.54.x or below and you're using JWT SSO
- [Update backend endpoint to return `{ jwt: "token" }` JSON response for SDK requests](#update-your-jwt-endpoint-to-handle-sdk-requests).
-Additionally, if you have SAML set up, but you'd prefer to use JWT SSO, you'll need to set a [preferred authentication method](#if-both-saml-and-jwt-are-enabled-the-sdk-will-default-to-saml).
+Additionally, if you have SAML set up, but you'd prefer to use JWT SSO, you'll need to set a [preferred authentication method](#if-both-saml-and-jwt-are-enabled-modular-embedding-will-default-to-saml).
### Remove `authProviderUri` from your auth config
diff --git a/docs/embedding/components.md b/docs/embedding/components.md
new file mode 100644
index 00000000000..e2daaaf9e21
--- /dev/null
+++ b/docs/embedding/components.md
@@ -0,0 +1,131 @@
+---
+title: Modular embedding components
+summary: Embed dashboards, questions, query builder, AI chat, and a collection browser.
+---
+
+# Modular embedding components
+
+There are different components you can embed, each with various options.
+
+> While you can use component parameters to show or hide parts of the embedded component, these parameters are _not_ a substitute for [permissions](../permissions/start.md). Even if you hide stuff, people could still grab their token from the frontend and use it to query the Metabase API.
+
+This page covers what you can embed. For theming your embeds, see [Appearance](./appearance.md).
+
+## Dashboard
+
+To render a dashboard:
+
+```html
+<metabase-dashboard dashboard-id="1" with-title="true" with-downloads="false">
+</metabase-dashboard>
+```
+
+### Required parameters
+
+- `dashboard-id` - This can be a regular ID or an entity ID. [Using Entity IDs](../installation-and-operation/serialization.md#entity-ids-work-with-embedding) in your embeds ensures that the IDs stay stable when exporting from one Metabase and importing to another. Only for SSO. Guest embeds set the id with token.
+
+### Optional parameters
+
+- `with-title` (default is true) - show the dashboard title in the embed
+- `with-downloads` (default is false) - show the button to download the dashboard as PDF and download question results
+- `drills` (default is true) - lets you drill through the dashboard
+- `initial-parameters` - default value for dashboard filters, like `{ 'productId': '42' }`.
+- `with-subscriptions` - let people set up [dashboard subscriptions](../dashboards/subscriptions.md).
+- `refresh` - auto-refreshes the dashboard. `refresh="60"` will refresh the dashboard every 60 seconds.
+- `hidden-parameters` - list of filter names to hide from the dashboard, like `['productId']`
+- `locale` - see [translations](./translations.md) (only available for guest embeds).
+
+If you surround your attribute value with double quotes, make sure to use single quotes:
+
+```html
+<metabase-dashboard
+ dashboard-id="1"
+ initial-parameters="{ 'productId': '42' }"
+></metabase-dashboard>
+```
+
+If you surround your attribute value with double quotes, make sure to use single quotes:
+
+```html
+<metabase-dashboard
+ dashboard-id="1"
+ hidden-parameters="['productId']"
+></metabase-dashboard>
+```
+
+## Resizing dashboards to fit their content
+
+The `<metabase-dashboard>` web component automatically resizes to fit its content. No additional configuration is needed.
+
+## Question
+
+To render a question (chart):
+
+```html
+<metabase-question question-id="1"></metabase-question>
+```
+
+### Required parameters
+
+- `question-id` - This can be a regular ID or an entity ID. [Using Entity IDs](../installation-and-operation/serialization.md#entity-ids-work-with-embedding) in your embeds ensures that the IDs stay stable when exporting from one Metabase and importing to another. Only for SSO embeds. Guest embeds set the id with a token.
+
+ Use `question-id="new"` to embed the query builder exploration interface.
+
+### Optional parameters
+
+- `drills` (default is true) - lets you drill through the question
+- `with-title` (default is true) - show the title
+- `with-downloads` (default is false) - show downloads
+- `initial-sql-parameters` - default value for SQL parameters, only applicable to native SQL questions, like `{ "productId": "42" }`
+- `is-save-enabled` (default is false)
+- `target-collection` - this is to enforce saving into a particular collection. Values: regular ID, entity ID, `"personal”`, `"root”`
+
+## Browser
+
+To render a collection browser so people can navigate a collection and open dashboards or questions:
+
+```html
+<metabase-browser initial-collection="14" read-only="false"></metabase-browser>
+```
+
+### Required parameters
+
+- `initial-collection` - This can be a collection ID or `root`. Use a collection ID (e.g., `14`) to start in a specific collection. Use `root` to start at the top-level, "Our Analytics" collection.
+
+### Optional parameters
+
+- `read-only` (default is true) – if true, people can interact with items (filter, summarize, drill-through) but cannot save. If false, they can create and edit items in the collection.
+
+## AI chat
+
+To render the AI chat interface:
+
+```html
+<metabase-metabot></metabase-metabot>
+```
+
+### Required parameters
+
+None.
+
+### Optional parameters
+
+- `layout` (default is `auto`) – how should the browser position the visualization with respect to the chat interface. Possible values are:
+ - `auto` (default): Metabot uses the `stacked` layout on mobile screens, and a `sidebar` layout on larger screens.
+ - `stacked`: the question visualization stacks on top of the chat interface.
+ - `sidebar`: the question visualization appears to the left of the chat interface, which is in the right sidebar.
+
+## Customizing loader and error components
+
+If you're using the [modular embedding SDK](./sdk/introduction.md), you can provide your own components for loading and error states by specifying `loaderComponent` and `errorComponent` as props to `MetabaseProvider`.
+
+```tsx
+{% include_file "{{ dirname }}/sdk/snippets/appearance/customizing-loader-and-components.tsx" snippet="imports" %}
+
+{% include_file "{{ dirname }}/sdk/snippets/appearance/customizing-loader-and-components.tsx" snippet="example" %}
+```
+
+## Further reading
+
+- [Appearance](./appearance.md)
+- [Modular embedding SDK](./sdk/introduction.md).
diff --git a/docs/embedding/full-app-embedding-quick-start-guide.md b/docs/embedding/full-app-embedding-quick-start-guide.md
index 45c74a5569a..ea06f6c2ea3 100644
--- a/docs/embedding/full-app-embedding-quick-start-guide.md
+++ b/docs/embedding/full-app-embedding-quick-start-guide.md
@@ -72,7 +72,7 @@ Here you'll need to input some values for your SSO to work.
You'll want to declare up two constants in your app:
- `METABASE_JWT_SHARED_SECRET`, paste the JWT signing key that you got from your Metabase here.
-- `METABASE_SITE_URL`, which points to your Metabase's root path.
+- `METABASE_SITE_URL`, which points to your Metabase instance's root path.
```javascript
const METABASE_JWT_SHARED_SECRET = "YOURSIGNINGKEY";
@@ -121,7 +121,7 @@ You'll need to add a route to sign people in to your Metabase via SSO using JWT.
{% include_file "{{ dirname }}/snippets/interactive-embedding-quick-start-guide/sso-with-jwt.ts" snippet="sso-route" %}
```
-If the person has never signed in to Metabase before, Metabase will create an account for them.
+Metabase creates an account for first-time sign-ins.
### CHECKPOINT: sign in to your Metabase using SSO
diff --git a/docs/embedding/full-app-embedding.md b/docs/embedding/full-app-embedding.md
index 0644241a7d3..51d26b77164 100644
--- a/docs/embedding/full-app-embedding.md
+++ b/docs/embedding/full-app-embedding.md
@@ -12,7 +12,7 @@ redirect_from:
{% include shared/in-page-promo-embedding-workshop.html %}
-**Full app embedding** (previously called "interactive embedding") lets you embed the entire Metabase app in an iframe. Full app embedding integrates your [permissions](../permissions/introduction.md) and [SSO](../people-and-groups/start.md#authentication) to give people the right level of access to [query](../questions/query-builder/editor.md) and [drill-down](https://www.metabase.com/learn/metabase-basics/querying-and-dashboards/questions/drill-through) into your data.
+**Full app embedding** lets you embed the entire Metabase app in an iframe. Full app embedding integrates your [permissions](../permissions/introduction.md) and [SSO](../people-and-groups/start.md#authentication) to give people the right level of access to [query](../questions/query-builder/editor.md) and [drill-down](https://www.metabase.com/learn/metabase-basics/querying-and-dashboards/questions/drill-through) into your data.
> If you are just starting out with Metabase embedding, consider using [Modular embedding](./modular-embedding.md) instead of full app embedding - it's an improved, more customizable option for embedding individual Metabase components.
@@ -139,7 +139,7 @@ SameSite values include:
You can also set the [`MB_SESSION_COOKIE_SAMESITE` environment variable](../configuring-metabase/environment-variables.md#mb_session_cookie_samesite).
-If you're using Safari, you'll need to [allow cross-site tracking](https://support.apple.com/en-tj/guide/safari/sfri40732/mac). Depending on the browser, you may also run into issues when viewing emdedded items in private/incognito tabs.
+If you're using Safari, you'll need to [allow cross-site tracking](https://support.apple.com/en-tj/guide/safari/sfri40732/mac). Depending on the browser, you may also run into issues when viewing embedded items in private/incognito tabs.
Learn more about [SameSite cookies](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie/SameSite).
diff --git a/docs/embedding/guest-embedding.md b/docs/embedding/guest-embedding.md
new file mode 100644
index 00000000000..86a363e0b3b
--- /dev/null
+++ b/docs/embedding/guest-embedding.md
@@ -0,0 +1,189 @@
+---
+title: Guest embeds
+summary: Embed questions, dashboards, and documents without requiring SSO.
+---
+
+# Guest embeds
+
+{% include shared/in-page-promo-embedding-workshop.html %}
+
+Guest embeds are a way to embed basic Metabase components in your app without requiring you to create a Metabase account for each person viewing the charts and dashboards. But not logging people in to your Metabase has some major tradeoffs: see [limitations](#guest-embed-limitations).
+
+Even though you're not using SSO, guest embeds are still secure: Metabase will only load the embed if the request has a JWT signed with the secret shared between your app and your Metabase. The JWT also includes a reference to the resource to load (like the ID of the embedded item), and any values for parameters.
+
+To restrict data in guest embeds for specific people or groups, use [locked parameters](./static-embedding-parameters.md#restricting-data-in-a-static-embed-with-locked-parameters).
+
+## Turning on guest embedding in Metabase
+
+1. Go to **Settings > Admin settings > Embedding > Guest embeds**.
+2. Toggle **Enable guest embedding**.
+
+## Creating a guest embed
+
+![Sharing button to embed dashboard](./images/sharing-embed.png)
+
+To create a guest embed:
+
+1. Go to the item that you want to embed in your website. You can also open a command palette with Ctrl/Cmd+K and type "New embed".
+2. Click the **sharing icon**.
+3. Select **Embed**.
+4. Under **Authentication**, select **Guest**.
+5. Optional: [customize the appearance of the embed](./appearance.md)
+6. Optional: [Add parameters to the embed](./components.md).
+7. Click **Publish**.
+8. Get the code snippet that the wizard generates and add it to your app.
+
+![Guest embed settings](./images/guest-embed-settings.png)
+
+## Notes on the code the wizard generates
+
+You can edit the code (see [components](./components.md) and [appearance](./appearance.md). But here's an overview of the code the wizard generates, and where to put it.
+
+### Client-side code
+
+Add the embed script and configuration to your HTML:
+
+```html
+<script defer src="YOUR_METABASE_URL/app/embed.js"></script>
+<script>
+ window.metabaseConfig = {
+ isGuest: true,
+ instanceUrl: "YOUR_METABASE_URL",
+ };
+</script>
+```
+
+Then add the component for the item you want to embed:
+
+```html
+<!-- For dashboards -->
+<metabase-dashboard
+ token="YOUR_JWT_TOKEN"
+ with-title="true"
+ with-downloads="false"
+ initial-parameters='{"category":["Gizmo"]}'
+></metabase-dashboard>
+
+<!-- For questions -->
+<metabase-question token="YOUR_JWT_TOKEN"></metabase-question>
+```
+
+> Never hardcode JWT tokens directly in your HTML. Always fetch the token from your backend and pass the token to the web component programmatically.
+
+### Server-side code
+
+Your server generates signed JWT tokens that authenticate the embed request. Here's an example using Node.js:
+
+```javascript
+const jwt = require("jsonwebtoken");
+
+const METABASE_SECRET_KEY = "YOUR_METABASE_SECRET_KEY";
+
+const payload = {
+ resource: { dashboard: 10 }, // or { question: 5 } for questions
+ params: {},
+ exp: Math.round(Date.now() / 1000) + 10 * 60, // 10 minute expiration
+};
+
+const token = jwt.sign(payload, METABASE_SECRET_KEY);
+```
+
+Replace `YOUR_METABASE_SECRET_KEY` with your [embedding secret key](#regenerating-the-embedding-secret-key).
+
+### Component attributes
+You can set different attributes to enable/disable UI. Here are some example attributes:
+
+| Attribute | Description |
+| -------------------- | -------------------------------------------------------------------- |
+| `token` | Required. The signed JWT token from your server. |
+| `with-title` | Show or hide the title. Values: `"true"` or `"false"`. |
+| `with-downloads` | Enable or disable downloads. Values: `"true"` or `"false"`. |
+| `initial-parameters` | JSON string of parameter values. Example: `'{"category":["Gizmo"]}'` |
+
+Attributes will differ based on the type of thing you're embedding. Guest embeds have fewer options that embeds that use SSO. See more on [components and their attributes](./components.md).
+
+## Editing parameters on an embedded question or dashboard
+
+If you change the [parameters](./static-embedding-parameters.md) of your embedded item:
+
+1. After making your changes, copy the code Metabase generates.
+2. Click **Publish** again.
+3. Update the code on your server so that it matches the code generated by Metabase.
+
+## Disabling embedding for a question or dashboard
+
+You can find a list of all guest embeds of questions and dashboards from **Admin settings** > **Embedding** > **Guest embeds**.
+
+1. Visit the embeddable question or dashboard.
+2. Click the **sharing icon** (square with an arrow pointing to the top right).
+3. Select **Embed**.
+4. Select **Guest embedding**
+5. Click **Unpublish**.
+
+## Removing the "Powered by Metabase" banner
+
+![Powered by Metabase](./images/powered-by-metabase.png)
+
+The banner appears on guest embeds created with Metabase's open-source version. To remove the banner, you'll need to upgrade to a [Pro](https://www.metabase.com/product/pro) or [Enterprise](https://www.metabase.com/product/enterprise) plan.
+
+## Regenerating the embedding secret key
+
+Your embedding secret key is used to sign JWTs for all of your embeds.
+
+1. Go to **Admin** > **Embedding** > **Guest embeds**.
+2. Under **Regenerate secret key**, click **Regenerate key**.
+
+This key is shared across all guest embeds. Whoever has access to this key could get access to all embedded artifacts, so keep this key secure. If you regenerate this key, you'll need to update your server code with the new key.
+
+## Custom destinations on dashboards in guest embeds
+
+You can only use the **URL** option for [custom destinations](../dashboards/interactive.md#custom-destinations) on dashboards with guest embedding. External URLs will open in a new tab or window.
+
+You can propagate filter values into the external URL, unless the filter is locked.
+
+## Translating guest embeds
+
+See [Translating embedded questions and dashboards](./translations.md).
+
+## How guest embedding works
+
+Guest embeds use web components (`<metabase-dashboard>` and `<metabase-question>`) that communicate with your Metabase instance. Each embed request requires a JWT token signed with your secret key.
+
+When a visitor views your page:
+
+1. Your server generates a signed JWT token containing the resource ID (dashboard or question) and any locked parameters.
+2. The web component sends the token to Metabase.
+3. Metabase verifies the JWT signature using your secret key.
+4. If valid, Metabase returns the embedded content.
+
+For interactive filters, you can pass initial parameter values via the `initial-parameters` attribute. When a visitor changes a filter, the web component handles the update automatically.
+
+The signed JWT is generated using your [Metabase secret key](#regenerating-the-embedding-secret-key). The secret key tells Metabase that the request can be trusted. Note that this secret key is shared for all guest embeds, so whoever has access to that key will have access to all embedded artifacts.
+
+If you want to embed charts with additional interactive features, like [drill-down](https://www.metabase.com/learn/metabase-basics/querying-and-dashboards/questions/drill-through) and [self-service querying](../questions/query-builder/editor.md), see [Modular embedding](./modular-embedding.md).
+
+## Guest embed limitations
+
+Because guest embeds don't require you to create a Metabase account for each person via SSO, Metabase can't know who is viewing the embed, and therefore can't give them access to all their data and all the cool stuff Metabase can do.
+
+Guest embeds can't take advantage of:
+
+- [Row and column security](../permissions/row-and-column-security.md)
+- [Drill-through](https://www.metabase.com/learn/metabase-basics/querying-and-dashboards/questions/drill-through)
+- [Usage analytics](../usage-and-performance-tools/usage-analytics.md).
+- [Query builder](../questions/query-builder/editor.md)
+- [AI chat](./sdk/ai-chat.md).
+
+For those features, check out [Modular embedding with SSO](./modular-embedding.md).
+
+## Example app with guest embed and theming
+
+Check out our [sample app](https://github.com/metabase/modular-embedding-sample-app). Bring your Metabase, embed a dashboard, and play around with changing colors.
+
+## Further reading
+
+- [Parameters for guest embeds](./static-embedding-parameters.md).
+- [Reference apps repo](https://github.com/metabase/embedding-reference-apps).
+- [Strategies for delivering customer-facing analytics](https://www.metabase.com/learn/metabase-basics/embedding/overview).
+- [Publishing data visualizations to the web](https://www.metabase.com/learn/metabase-basics/embedding/charts-and-dashboards).
+- [Customizing Metabase's appearance](../configuring-metabase/appearance.md).
diff --git a/docs/embedding/images/04-preview.png b/docs/embedding/images/04-preview.png
deleted file mode 100644
index 2c094660f36..00000000000
Binary files a/docs/embedding/images/04-preview.png and /dev/null differ
diff --git a/docs/embedding/images/05-code.png b/docs/embedding/images/05-code.png
deleted file mode 100644
index ad5452e2e69..00000000000
Binary files a/docs/embedding/images/05-code.png and /dev/null differ
diff --git a/docs/embedding/images/behavior-and-appearance.png b/docs/embedding/images/behavior-and-appearance.png
new file mode 100644
index 00000000000..ca210d66b0d
Binary files /dev/null and b/docs/embedding/images/behavior-and-appearance.png differ
diff --git a/docs/embedding/images/embed-flow-options.png b/docs/embedding/images/embed-flow-options.png
index fa4c6163d67..a5da5f0d3df 100644
Binary files a/docs/embedding/images/embed-flow-options.png and b/docs/embedding/images/embed-flow-options.png differ
diff --git a/docs/embedding/images/embed-share-button.png b/docs/embedding/images/embed-share-button.png
new file mode 100644
index 00000000000..2ec76b4053b
Binary files /dev/null and b/docs/embedding/images/embed-share-button.png differ
diff --git a/docs/embedding/images/embed-with-sso.png b/docs/embedding/images/embed-with-sso.png
new file mode 100644
index 00000000000..4fc9da9c827
Binary files /dev/null and b/docs/embedding/images/embed-with-sso.png differ
diff --git a/docs/embedding/images/guest-embed-settings.png b/docs/embedding/images/guest-embed-settings.png
new file mode 100644
index 00000000000..51adfbef12c
Binary files /dev/null and b/docs/embedding/images/guest-embed-settings.png differ
diff --git a/docs/embedding/images/modular-embedding-wizard.png b/docs/embedding/images/modular-embedding-wizard.png
new file mode 100644
index 00000000000..66ca6adbef8
Binary files /dev/null and b/docs/embedding/images/modular-embedding-wizard.png differ
diff --git a/docs/embedding/images/new-modular-embed-from-admin-settings.png b/docs/embedding/images/new-modular-embed-from-admin-settings.png
new file mode 100644
index 00000000000..0d791b0ea8e
Binary files /dev/null and b/docs/embedding/images/new-modular-embed-from-admin-settings.png differ
diff --git a/docs/embedding/introduction.md b/docs/embedding/introduction.md
index 1f74e9cd538..d68b634e524 100644
--- a/docs/embedding/introduction.md
+++ b/docs/embedding/introduction.md
@@ -1,34 +1,60 @@
---
title: Embedding introduction
+summary: Different ways you can embed charts and dashboards, or all of Metabase, in your app.
redirect_from:
- /docs/latest/administration-guide/13-embedding
---
# Embedding introduction
-You can embed Metabase tables, charts, and dashboards—even Metabase's query builder—in your website or application.
+{% include shared/in-page-promo-embedding-workshop.html %}
-Here are the different ways you can embed Metabase.
+You can embed Metabase tables, charts, and dashboards—even Metabase's query builder—in your website or application. Here are the different ways you can embed Metabase:
-{% include shared/in-page-promo-embedding-workshop.html %}
+- [Modular embedding](#modular-embedding)
+- [Full app embedding](#full-app-embedding)
+- [Public links](#public-links-and-embeds)
## Modular embedding
-With [modular embedding](./modular-embedding.md), you can embed individual Metabase components in your web app. Choose from dashboards, questions, or the query builder, and configure per‑component options like drill‑through, parameters, downloads, and theming. Modular embedding integrates with [SSO](securing-embeds.md) and [data permissions](../permissions/embedding.md).
+With [modular embedding](./modular-embedding.md), you can embed individual Metabase components in your web app. You can use guest embeds for basic functionality, or use SSO to take full advantage of Metabase.
+
+You can use two different ways to authenticate modular embeds:
+
+- [SSO](#modular-embedding)
+- [Guest](#guest-embedding)
+
+Here's a basic breakdown of what each auth type enables:
+
+| Component | SSO | Guest |
+| ----------------------------------------------------- | --- | ----- |
+| Chart | ✅ | ✅ |
+| Chart with drill-through | ✅ | ❌ |
+| Dashboard | ✅ | ✅ |
+| Dashboard with drill-through | ✅ | ❌ |
+| [Query builder](../questions/query-builder/editor.md) | ✅ | ❌ |
+| Browser to navigate collections | ✅ | ❌ |
+| Metabot AI chat | ✅ | ❌ |
-**When to use modular embedding**: You want to [offer multi-tenant, self-service analytics](https://www.metabase.com/blog/why-full-app-embedding), you want a drop‑in script, and want to embed Metabase components with per‑component controls and theming.
+Currently, you can't embed [documents](../documents/introduction.md).
-## Static embedding
+### SSO embeds
-Also known as signed embedding, [static embedding](./static-embedding.md) is a secure way to embed charts and dashboards.
+With SSO, Metabase can know who's viewing what, which unlocks a lot of power. You can automatically apply [data permissions](../permissions/embedding.md), which means you can give people access to all the cool tools Metabase provides, and everyone will only ever see the data they're allowed to.
-**When to use static embedding**: you don't want to offer ad-hoc querying or chart drill-through. To filter data relevant to the viewer, you can use static embeds with [locked parameters](./static-embedding-parameters.md#locked-parameters-limit-the-values-available-to-other-editable-parameters).
+**When to use SSO**: You want to offer multi-tenant, self-service analytics, or you want to include the query builder, AI chat, drill-through, or a collection browser.
+
+### Guest embedding
+
+[Guest embeds](./guest-embedding.md) are a secure way to embed charts and dashboards.
+
+**When to use guest embeds**: simple embedding use cases where you don't want to offer ad-hoc querying or chart drill-through. To filter data relevant to the viewer, you can use guest embeds with [locked parameters](./static-embedding-parameters.md#locked-parameters-limit-the-values-available-to-other-editable-parameters).
## Public links and embeds
If you'd like to share your data with the good people of the internet, admins can create a [public link](./public-links.md) or embed a question or dashboard directly in your website.
-**When to use public links and embeds**: public links and embeds are good for one-off charts and dashboards. Admins can use them when you just need to show someone a chart or dashboard without giving people access to your Metabase. And you don't care who sees the data; you want to make those stats available to everyone.
+**When to use public links and embeds**: One-off charts and dashboards. Admins can use public links when you just need to show someone a chart or dashboard without giving people access to your Metabase. And you don't care who sees the data; you want to make the item available to everyone.
## Full app embedding
@@ -36,35 +62,32 @@ If you'd like to share your data with the good people of the internet, admins ca
## Comparison of embedding types
-| Action | [React SDK](./sdk/introduction.md) | [Modular](./modular-embedding.md) | [Full app](./full-app-embedding.md) | [Static](./static-embedding.md) | [Public](../embedding/public-links.md) |
-| ------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------- | --------------------------------- | ----------------------------------- | ------------------------------- | -------------------------------------- |
-| Display charts and dashboards | ✅ | ✅ | ✅ | ✅ | ✅ |
-| Display interactive [filter widgets](https://www.metabase.com/glossary/filter-widget) | ✅ | ✅ | ✅ | ✅ | ✅ |
-| Export results\* | ✅ | ✅ | ✅ | ✅ | ✅ |
-| Restrict data with [locked filters](./static-embedding-parameters.md#restricting-data-in-a-static-embed-with-locked-parameters) | ❌ | ❌ | ❌ | ✅ | ❌ |
-| [Data segregation](../permissions/embedding.md) | ✅ | ✅ | ✅ | ❌ | ❌ |
-| Use the [drill-through menu](https://www.metabase.com/learn/metabase-basics/querying-and-dashboards/questions/drill-through) | ✅ | ✅ | ✅ | ❌ | ❌ |
-| Self-serve via [query builder](../questions/query-builder/editor.md) | ✅ | ✅ | ✅ | ❌ | ❌ |
-| [Basic appearance customization](../configuring-metabase/appearance.md)\*\* | ✅ | ✅ | ✅ | ✅ | ✅ |
-| [Advanced theming](./sdk/appearance.md) | ✅ | ✅ | ❌ | ❌ | ❌ |
-| View usage of embeds with [usage analytics](../usage-and-performance-tools/usage-analytics.md) | ✅ | ✅ | ✅ | ❌ | ❌ |
-| Embed individual Metabase components | ✅ | ✅ | ❌ | ❌ | ❌ |
-| Manage access and interactivity per component | ✅ | ✅ | ❌ | ❌ | ❌ |
-| Custom layouts | ✅ | ❌ | ❌ | ❌ | ❌ |
-| Customize behavior with [plugins](./sdk/plugins.md) | ✅ | ❌ | ❌ | ❌ | ❌ |
+| Action | [Modular SDK](./sdk/introduction.md) | [Modular SSO](./modular-embedding.md) | [Modular Guest](./guest-embedding.md) | [Full app](./full-app-embedding.md) | [Public](../embedding/public-links.md) |
+| -------------------------------------------------------------------------------------------------------------------- | ------------------------------------ | ------------------------------------- | ------------------------------------- | ----------------------------------- | -------------------------------------- |
+| Charts and dashboards | ✅ | ✅ | ✅ | ✅ | ✅ |
+| [Filter widgets](https://www.metabase.com/glossary/filter-widget) | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Export results\* | ✅ | ✅ | ✅ | ✅ | ✅ |
+| [Locked filters](./static-embedding-parameters.md#restricting-data-in-a-static-embed-with-locked-parameters) | ❌ | ❌ | ✅ | ❌ | ❌ |
+| [Data segregation](../permissions/embedding.md) | ✅ | ✅ | ❌ | ✅ | ❌ |
+| [Drill-through menu](https://www.metabase.com/learn/metabase-basics/querying-and-dashboards/questions/drill-through) | ✅ | ✅ | ❌ | ✅ | ❌ |
+| [Query builder](../questions/query-builder/editor.md) | ✅ | ✅ | ❌ | ✅ | ❌ |
+| [Basic appearance customization](../configuring-metabase/appearance.md)\*\* | ✅ | ✅ | ✅ | ✅ | ✅ |
+| [Advanced theming](./appearance.md) | ✅ | ✅ | ❌ | ❌ | ❌ |
+| [Usage analytics](../usage-and-performance-tools/usage-analytics.md) | ✅ | ✅ | ❌ | ✅ | ❌ |
+| Embed individual Metabase components | ✅ | ✅ | ❌ | ❌ | ❌ |
+| Manage access and interactivity per component | ✅ | ✅ | ❌ | ❌ | ❌ |
+| Custom layouts | ✅ | ❌ | ❌ | ❌ | ❌ |
+| Customize behavior with [plugins](./sdk/plugins.md) | ✅ | ❌ | ❌ | ❌ | ❌ |
+| AI chat | ✅ | ✅ | ❌ | ✅ | ❌ |
\* Each embedding type allows data downloads by default, but only [Pro and Enterprise](https://www.metabase.com/pricing/) plans can disable data downloads.
\*\* Requires a [Pro and Enterprise](https://www.metabase.com/pricing/) plan for any embedding type.
-## Switching from static embedding to Modular embedding
-
-[Modular embedding](./modular-embedding.md) requires authentication via single sign-on (SSO), so you'll need to set that up both in your Metabase and in your application's server. Check out our [Modular embedding authentication](../embedding/sdk/authentication.md).
-
## Further reading
- [Strategies for delivering customer-facing analytics](https://www.metabase.com/learn/metabase-basics/embedding/overview).
- [Publishing data visualizations to the web](https://www.metabase.com/learn/metabase-basics/embedding/charts-and-dashboards).
- [Multi-tenant self-service analytics](https://www.metabase.com/learn/metabase-basics/embedding/multi-tenant-self-service-analytics).
- [Customizing Metabase's appearance](../configuring-metabase/appearance.md).
-- [Securing embedded Metabase](./securing-embeds.md)
+- [Securing embedded Metabase](./securing-embeds.md).
diff --git a/docs/embedding/modular-embedding.md b/docs/embedding/modular-embedding.md
index b29d2f4d37d..ebda41b543a 100644
--- a/docs/embedding/modular-embedding.md
+++ b/docs/embedding/modular-embedding.md
@@ -7,105 +7,104 @@ redirect_from:
# Modular embedding
-{% include plans-blockquote.html feature="Modular embedding" convert_pro_link_to_embbedding=true %}
-
-Modular embedding lets you embed Metabase entities like questions, dashboards, or even the query builder into your own application using customizable components.
+{% include plans-blockquote.html feature="Modular embedding with SSO" convert_pro_link_to_embbedding=true %}
{% include shared/in-page-promo-embedding-workshop.html %}
-Modular embedding allows you to embed individual Metabase components (like questions, dashboards, or a query builder) using a simple drop-in script. You don't need to write embedding code on your own - just use the built-in wizard to create a code snippet, and paste it into your app.
-
-Unlike with [full app embedding](./full-app-embedding.md), where you embed the entire Metabase app in an iframe, modular embedding lets you choose from a set of predefined components like a single chart, a dashboard with optional drill-through, or query builder, and customize those components.
-
-Modular embedding uses [JWT](../people-and-groups/authenticating-with-jwt.md) or [SAML](../people-and-groups/authenticating-with-saml.md) to authenticate people and automatically apply the right permissions.
-
-Currently you can choose to embed:
-
-- A dashboard
-- A question (chart). You can embed both questions built with the query builder and questions built with SQL.
-- Full graphical [query builder](../questions/query-builder/editor.md) to enable people to build their own charts and explorations.
-- A browser to navigate collections and open dashboards or questions.
-- [AI chat interface](./sdk/ai-chat.md).
+![Modular embedding wizard](./images/modular-embedding-wizard.png)
-## Quickstart
+Modular embedding lets you embed and customize Metabase [components](./components.md) (like dashboards, the query builder, AI chat, and more) into your own application. You don't need to write embedding code on your own - just use the wizard to create a code snippet and paste it into your app.
-You can also follow the setup guide directly in Metabase in **Admin settings > Embedding > Setup guide**. We're recording the steps here for convenience.
+If you're using React, check out the [Modular embedding SDK](./sdk/introduction.md).
-### 1. Enable modular embedding
+## Enable modular embedding
1. In Metabase, go to **Admin settings > Embedding**.
2. Toggle on **Enable modular embedding**.
3. Under **Cross-Origin Resource Sharing (CORS)**, add the URLs of the websites where you want to embed Metabase (such as `https://*.example.com`). For testing embeds, you can use `localhost` which is always included in CORS policy.
-4. If you are embedding Metabase components in a domain that's different from your Metabase's domain (including when you're testing the app locally but use Metabase Cloud), go to **Admin settings > Embedding > Security** and set **SameSite cookie** to **None**.
+4. If you're embedding Metabase components in a domain that's different from your Metabase's domain (including when you're testing the app locally but use Metabase Cloud), go to **Admin settings > Embedding > Security** and set **SameSite cookie** to **None**.
-### 2. Create a new embed
+## Create a new embed
-1. In Metabase, open a command palette with Ctrl/Cmd+K, type "New embed" and select "new embed" command. This will open the interactive wizard that you can use to set up your embed.
+In your Metabase:
- If you're planning to embed an existing question or dashboard, you can instead go straight to that question or dashboard, click on the **Share** button, and choose **Embed**.
+1. Visit the item you want to embed.
+2. Click the sharing icon.
+3. Select **Embed**.
-2. Choose the _type_ of entity to embed:
+![Embed share button](./images/embed-share-button.png)
- - Dashboard
- - Chart
- - Exploration (which will embed the Metabase query builder)
- - Browser
- - Metabot question (which will embed AI chat)
+You can also open a command palette with Ctrl/Cmd+K, type "New embed". You'll get a wizard to help you set up your embed.
-3. Next, select the entity you want to embed. For browser, pick the collection you want people to start from.
+You can also go to **Admin settings > Embedding > Modular embedding** and click **New embed**.
-Once you've selected what you want to embed, click Next to customize your embed.
+![New modular embed from the admin settings](./images/new-modular-embed-from-admin-settings.png)
-### 3. Customize your embed
+## Pick how to authenticate the embed
-The exact customization options you see will depend on what type of entity you're embedding. You'll see a live preview of how the embed will look with your chosen options. Check out [Customizing embeds](#customizing-embeds) for more details on customization options.
+How you authenticate the embed determines how cool the embed can get. This page covers the SSO setup, which lets you do everything. This setup requires you to have [set up SSO for your Metabase](./authentication.md). You can check out a [comparison between SSO and guest](./introduction.md#comparison-of-embedding-types), or jump straight to the [guest embed docs](./guest-embedding.md). But we recommend setting up modular embedding with SSO.
-![Customizing embeds](./images/embed-flow-options.png)
+## Customize your embed
-You'll also be able to pick brand, text, and background color used for all your embeds. To configure other colors (e.g. secondary colors, query builder colors etc), as well as font, you can specify a [theme](#theming) in your embed code snippet.
+The exact customization options you see will depend on what type of entity you're embedding. You'll see a live preview of the embed with your customizations.
-All the customization options you select in this interactive flow will be reflected in the parameter values in the embed code, so you'll be able to adjust them later by editing the embed snippet.
+![Embed flow options for AI chat](./images/embed-flow-options.png)
-Once you're done customizing your embed, click "Next".
+You'll also be able to pick colors for:
-### 4. Select authentication method
+- Brand
+- Text
+- Background
-You'll get a choice between "Existing Metabase session" and "Single sign-on (SSO)".
+But you can customize a lot more later. To configure other colors (like secondary colors, query builder colors, and more), as well as font, you can specify a `theme` in your embed code snippet.
-- If you select **Existing Metabase session**, you'll be able to preview your embeds as the user you're currently logged into Metabase, and only in the same browser as your current session. Not all browsers are supported - we recommend using Google Chrome. To test out embedding in other contexts, you can use [API keys](#use-api-keys-to-test-embeds) instead. For production usage, use [SSO](#set-up-sso).
+All the customization options you select in this interactive flow will be reflected in code snippet, which you can edit as you see fit.
-- If you set up JWT in your Metabase instance, you'll be able to select **Single sign-on (SSO)**, see [Set up SSO](#set-up-sso).
-
-### 5. Add the embedding script into your app
-
-Metabase will generate a code snippet that you can copy and paste into your app, see [Embed code snippets](#embed-code-snippets) for an example. You can later modify this code snippet to specify additional appearance options or change the behavior of some components.
-
-Add the code snippet into your app, and refresh the page.
+For example, this code defines the font, color, and size for text, background colors, and colors for filters and summaries:
-## Each end user should have their own Metabase account
+```html
+<script>
+ defineMetabaseConfig({
+ instanceUrl: "https://your-metabase-url",
+ theme: {
+ fontFamily: "Lato",
+ fontSize: "16px",
+ colors: {
+ background: "#11123d",
+ "text-primary": "#f9f9fc",
+ brand: "#50e397",
+ filter: "#7172AD",
+ summarize: "#88BF4D",
+ },
+ },
+ });
+</script>
+```
-Each end-user must have their own Metabase account.
+For more look-and-feel twiddling, see [appearance](./appearance.md).
-The problem with having end-users share a Metabase account is that, even if you filter data on the client side via the modular embedding, all end-users will still have access to the session token, which they could use to access Metabase directly via the API to get data they’re not supposed to see.
+Once you're done customizing your embed, click **Next**.
-If each end-user has their own Metabase account, however, you can configure permissions in Metabase and everyone will only have access to the data they should.
+## Add the embedding script to your app
-In addition to this, we consider shared accounts to be unfair usage. Fair usage of modular embedding involves giving each end-user of the embedded analytics their own Metabase account.
+Metabase will generate a code snippet that you can copy and paste into your app. See the example below. You can later modify this code snippet to specify additional appearance options or change the behavior of some components.
-## Embed code snippets
+You'll add this code snippet to your app and refresh the page.
-The code snippets to embed Metabase entities using modular embedding should have three parts:
+The code snippets:
-1. Loading the modular embedding library from your Metabase instance.
-2. Global configuration settings to be used for all embeds, like the URL of your Metabase instance, appearance themes, etc. See [Configuring embeds](#configuring-embeds).
-3. Components for Metabase entities to be embedded, with their parameters. See [Components](#components).
+- Loading the modular embedding library from your Metabase instance.
+- Set global configuration settings, like the URL of your Metabase and the `theme`. See [Page-level config](#page-level-config).
+- The component(s) to embed, with their parameters. See [Components](./components.md).
-Here's an example of a script:
+Here's an example snippet:
```html
<!-- Load embedding library -->
<!-- REPLACE WITH YOUR METABASE URL HERE -->
+
<script defer src="https://your-metabase-url/app/embed.js"></script>
+
<script>
function defineMetabaseConfig(config) {
window.metabaseConfig = config;
@@ -132,15 +131,23 @@ Here's an example of a script:
Note the `defer` attribute and the reference to your Metabase URL in the script that loads `embed.js` library.
-If you're embedding multiple entities in a single page, you only need to include the `<script>` tags once globally.
+If you're embedding multiple components in a single page, you only need to include the `<script>` tags once globally.
+
+## Each end user should have their own Metabase account
+
+With SSO embeds, each end-user must have their own Metabase account.
-You can also generate the code snippet for modular embedding interactively in Metabase through **Admin > Embedding > Setup guide > Embed in your code**. Check out the [quickstart](#quickstart).
+The problem with having end-users share a Metabase account is that, even if you filter data on the client side via the modular embedding, all end-users will still have access to the session token, which they could use to access Metabase directly via the API to get data they’re not supposed to see.
+
+If each end-user has their own Metabase account, however, you can configure permissions in Metabase and everyone will only have access to the data they should.
+
+In addition to this, we consider shared accounts to be unfair usage. Fair usage of modular embedding involves giving each end-user of the embedded analytics their own Metabase account.
## Customizing embeds
The exact customization options you see will depend on what type of entity you're embedding.
-When you're creating a new embed using **Admin > Embedding > Setup guide > Embed in your code**, you'll see the following customization options in the interactive creation flow. These options correspond to parameters in [components](#components).
+When you're creating a new embed using **Admin > Embedding > Setup guide > Embed in your code**, you'll see the following customization options in the interactive creation flow. These options correspond to parameters in [components](./components.md).
- **Allow people to drill through on data points**: determines whether people can interact with the chart (or charts on a dashboard). Interactivity includes [drilling down](https://www.metabase.com/learn/metabase-basics/querying-and-dashboards/questions/drill-through) to individual records from aggregated questions, filtering on click, zooming in, etc. Disabling drill-through for an embedded _question_ also disables people's ability to add filters and summaries.
@@ -152,70 +159,24 @@ When you're creating a new embed using **Admin > Embedding > Setup guide > Embed
- **Show title**: what it says on the tin.
-- **Allow editing dashboards and questions**: lets people create and edit dashboards or questions in the current collection. When disabled, they can still perform actions like filter, summarize, and drill-through, but won’t be able to save results.
+- **Allow editing dashboards and questions**: lets people create and edit dashboards or questions in the current collection. When disabled, they can still perform actions like filter, summarize, and drill-through, but won't be able to save results.
-## Configuring embeds
+## Page-level config
To define the configuration that applies to every embed on the page, use the `defineMetabaseConfig()` function. Its parameters include:
- `instanceUrl: "https://your-metabase-url"` (required): the URL of your Metabase instance, like `https://youlooknicetoday.metabaseapp.com`
-- `theme: {...}` (optional): [appearance options for the embeds](#theming).
+- `theme: {...}` (optional): [appearance options for the embeds](./appearance.md).
- `useExistingUserSession: true|false` (optional, for development only) - lets you preview the embed locally using your Metabase admin account session. Only supported in Google Chrome.
- `apiKey: mb_YourAPIKey` (optional, for development only) - another way to preview embeds locally using an API key.
-- `fetchRequestToken: () => Promise<{ jwt: string }>` (optional) - you can customize how the SDK fetches the refresh token for JWT authentication by specifying the `fetchRequestToken` function. See [customizing JWT authentication](./sdk/authentication.md#customizing-jwt-authentication).
-
-### Theming
-
-You can specify colors, fonts, spacing, and other appearance options using the `theme` parameter in your embed configuration.
-
-For example, this code defines the font, color, and size for text, background colors, and colors for filters and summaries:
-
-```html
-<script>
- defineMetabaseConfig({
- instanceUrl: "https://your-metabase-url",
- theme: {
- fontFamily: "Lato",
- fontSize: "16px",
- colors: {
- background: "#11123d",
- "text-primary": "#f9f9fc",
- brand: "#50e397",
- filter: "#7172AD",
- summarize: "#88BF4D",
- },
- },
- });
-</script>
-```
-
-See [appearance](./sdk/appearance.md).
+- `fetchRequestToken: () => Promise<{ jwt: string }>` (optional) - you can customize how the SDK fetches the refresh token for JWT authentication by specifying the `fetchRequestToken` function. See [customizing JWT authentication](./authentication.md#customizing-jwt-authentication).
## Authentication
-### Use existing user session to test embeds
-
-> Existing sessions can only be used for testing embeds locally. To make your embeds production-ready, you'll need to implement SSO.
-
-If you're signed into Metabase, you can use that existing session cookie to preview and test your embeds. This only works in the same browser (we recommend Chrome) you're using for your Metabase session (so it won't work in Incognito mode).
-
-Add `useExistingUserSession: true` to `defineMetabaseConfig()` in your embed code. Check out [Configuring embeds](#configuring-embeds).
-
-```html
-<script>
- defineMetabaseConfig({
- instanceUrl: "https://your-metabase-url",
- useExistingUserSession: true,
- });
-</script>
-```
-
-Note that this will not work in some browsers, or in incognito mode. We recommend using Chrome if you'd like to use existing Metabase sessions to test your embeds.
-
### Use API keys to test embeds
> API keys can only be used for testing embeds locally. To make your embeds production-ready or deploy them to another domain, you'll need to implement SSO.
@@ -236,188 +197,6 @@ To use an API key to test your embeds:
API keys should only be used for testing with trusted people. Anyone with access to the front-end can grab the API key and use it to make requests against the Metabase API. For this reason, we only allow using API keys on localhost.
-### Set up SSO
-
-SSO is required to embed in a domain other than localhost. You can use JWT or SAML SSO. To configure SAML, check out [Authenticating with SAML](./sdk/authentication.md#authenticating-with-saml-sso). To configure JWT, follow the steps below.
-
-#### 1. In Metabase, configure [JWT SSO](../people-and-groups/authenticating-with-jwt.md).
-
-#### 2. In your app's backend, add a new endpoint to handle authentication.
-
-You'll need to add a library to your backend to sign your JSON Web Tokens.
-
-For Node.js, we recommend jsonwebtoken:
-
-```sh
-npm install jsonwebtoken --save
-```
-
-Next, set up an endpoint on your backend (like `/sso/metabase`) that uses your Metabase JWT shared secret to generate a JWT for the authenticated person. **This endpoint must return a JSON object with a `jwt` property containing the signed JWT.** For example: `{ "jwt": "your-signed-jwt" }`.
-
-This example code for Node.js sets up an endpoint using Express:
-
-```js
-import express from "express";
-import cors from "cors";
-import session from "express-session";
-import jwt from "jsonwebtoken";
-import fetch from "node-fetch";
-
-// Replace this with your Metabase URL
-const METABASE_INSTANCE_URL = "YOUR_METABASE_URL_HERE";
-// Replace this with the JWT signing secret you generated when enabling
-// JWT SSO in your Metabase.
-const METABASE_JWT_SHARED_SECRET = "YOUR_SECRET_HERE";
-
-const app = express();
-
-app.get("/sso/metabase", async (req, res) => {
- // Usually, you'd grab the user from the current session
- // Here it's hardcoded for demonstration purposes
- // Example:
- // const { user } = req.session;
- const user = {
- email: "[email protected]",
- firstName: "Rene",
- lastName: "Descartes",
- group: "Customer",
- };
-
- if (!user) {
- console.log("no user");
- res.status(401).json({
- status: "error",
- message: "not authenticated",
- });
-
- return;
- }
-
- const token = jwt.sign(
- {
- email: user.email,
- first_name: user.firstName,
- last_name: user.lastName,
- groups: [user.group],
- exp: Math.round(Date.now() / 1000) + 60 * 10, // 10 minutes expiration
- },
- METABASE_JWT_SHARED_SECRET,
- );
- // The user backend should return a JSON object with the JWT.
- res.status(200).json({ jwt: token });
-});
-```
-
-See more examples in the [Embedding SDK docs](./sdk/authentication.md#2-add-a-new-endpoint-to-your-backend-to-handle-authentication).
-
-#### 3. Embeds will use SSO automatically by default
-
-By default, Metabase uses JWT SSO, but you can specify another auth method. To turn on SSO, make sure you _don't_ set your configuration to `apiKey` or `useExistingUserSession`.
-
-## Components
-
-There are different components available that enable different experiences for the end-user.
-
-> While you can use component parameters to show or hide parts of the embedded component, these parameters are _not_ a substitute for [permissions](../permissions/start.md). Even if you hide stuff, people could still grab their token from the frontend and use it to query the Metabase API.
-
-### Dashboard
-
-To render a dashboard:
-
-```html
-<metabase-dashboard dashboard-id="1" with-title="true" with-downloads="false">
-</metabase-dashboard>
-```
-
-**Required parameters:**
-
-- `dashboard-id` - This can be a regular ID or an entity ID. [Using Entity IDs](../installation-and-operation/serialization.md#entity-ids-work-with-embedding) in your embeds ensures that the IDs stay stable when exporting from one Metabase and importing to another.
-
-**Optional parameters:**
-
-- `with-title` (default is true) - show the dashboard title in the embed
-- `with-downloads` (default is false) - show the button to download the dashboard as PDF and download question results
-- `drills` (default is true) - lets you drill through the dashboard
-- `initial-parameters` - default value for dashboard filters, like `{ 'productId': '42' }`.
-
- Make sure to use single quotes if you are surrounding your attribute value with double quotes:
-
- ```html
- <metabase-dashboard
- dashboard-id="1"
- initial-parameters="{ 'productId': '42' }"
- ></metabase-dashboard>
- ```
-
-- `hidden-parameters` - list of filter names to hide from the dashboard, like `['productId']`
-
- Make sure to use single quotes if you are surrounding your attribute value with double quotes:
-
- ```html
- <metabase-dashboard
- dashboard-id="1"
- hidden-parameters="['productId']"
- ></metabase-dashboard>
- ```
-
-### Question
-
-To render a question (chart):
-
-```html
-<metabase-question question-id="1"></metabase-question>
-```
-
-**Required parameters:**
-
-- `question-id` - This can be a regular ID or an entity ID. [Using Entity IDs](../installation-and-operation/serialization.md#entity-ids-work-with-embedding) in your embeds ensures that the IDs stay stable when exporting from one Metabase and importing to another.
-
- Use `question-id="new"` to embed the query builder exploration interface.
-
-**Optional parameters:**
-
-- `drills` (default is true) - lets you drill through the question
-- `with-title` (default is true) - show the title
-- `with-downloads` (default is false) - show downloads
-- `initial-sql-parameters` - default value for SQL parameters, only applicable to native SQL questions, like `{ "productId": "42" }`
-- `is-save-enabled` (default is false)
-- `target-collection` - this is to enforce saving into a particular collection. Values: regular ID, entity ID, `"personal”`, `"root”`
-
-### Browser
-
-To render a collection browser so people can navigate a collection and open dashboards or questions:
-
-```html
-<metabase-browser initial-collection="14" read-only="false"></metabase-browser>
-```
-
-**Required parameters:**
-
-- `initial-collection` - This can be a collection ID or `root`. Use a collection ID (e.g., `14`) to start in a specific collection. Use `root` to start at the top-level, "Our Analytics" collection.
-
-**Optional parameters:**
-
-- `read-only` (default is true) – if true, people can interact with items (filter, summarize, drill-through) but cannot save. If false, they can create and edit items in the collection.
-
-### Metabot
-
-To render the AI chat interface:
-
-```html
-<metabase-metabot></metabase-metabot>
-```
-
-**Required parameters:**
-
-None.
-
-**Optional parameters:**
-
-- `layout` (default is `auto`) – how should the browser position the visualization with respect to the chat interface. Possible values are:
- - `auto` (default): Metabot uses the `stacked` layout on mobile screens, and a `sidebar` layout on larger screens.
- - `stacked`: the question visualization stacks on top of the chat interface.
- - `sidebar`: the question visualization appears to the left of the chat interface, which is in the right sidebar.
-
## Embedding Metabase in a different domain
If you want to embed Metabase in another domain (say, if Metabase is hosted at `metabase.yourcompany.com`, but you want to embed Metabase at `yourcompany.github.io`), you can tell Metabase to set the session cookie's SameSite value to "none".
@@ -432,6 +211,14 @@ SameSite values include:
You can also set the [`MB_SESSION_COOKIE_SAMESITE` environment variable](../configuring-metabase/environment-variables.md#mb_session_cookie_samesite).
-If you're using Safari, you'll need to [allow cross-site tracking](https://support.apple.com/en-tj/guide/safari/sfri40732/mac). Depending on the browser, you may also run into issues when viewing emdedded items in private/incognito tabs.
+If you're using Safari, you'll need to [allow cross-site tracking](https://support.apple.com/en-tj/guide/safari/sfri40732/mac). Depending on the browser, you may also run into issues when viewing embedded items in private/incognito tabs.
Learn more about [SameSite cookies](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie/SameSite).
+
+## Setting up SSO
+
+For production use, you'll need to set up SSO authentication. See [Modular embedding - authentication](./authentication.md) for details on setting up JWT or SAML authentication.
+
+## Example app with SSO embed and theming
+
+Check out our [sample app](https://github.com/metabase/modular-embedding-sample-app). Bring your Metabase, embed a dashboard, and play around with changing colors.
diff --git a/docs/embedding/public-links.md b/docs/embedding/public-links.md
index ad281cf00e2..bcf111e4018 100644
--- a/docs/embedding/public-links.md
+++ b/docs/embedding/public-links.md
@@ -37,7 +37,7 @@ To share a dashboard via a public link, admins can click on the **Sharing** butt
![Sharing a dashboard](./images/dashboard-sharing.png)
-To embed a dashboard, see [static embedding](./static-embedding.md).
+To embed a dashboard, see [guest embedding](./guest-embedding.md).
## Create a public link for a document
@@ -100,7 +100,7 @@ To apply appearance or filter settings to your public embed, you can add paramet
Note that it's possible to find the public link URL behind a public embed. If someone gets access to the public link URL, they can remove the parameters from the URL to view the original question or dashboard (that is, without any appearance or filter settings).
-If you'd like to create a secure embed that prevents people from changing filter names or values, check out [static embedding](./static-embedding.md).
+If you'd like to create a secure embed that prevents people from changing filter names or values, check out [guest embedding](./guest-embedding.md).
## Appearance parameters
diff --git a/docs/embedding/sdk/appearance.md b/docs/embedding/sdk/appearance.md
deleted file mode 100644
index d21b87045bb..00000000000
--- a/docs/embedding/sdk/appearance.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-title: "Embedded analytics SDK - appearance"
----
-
-# Embedded analytics SDK - appearance
-
-{% include plans-blockquote.html feature="Embedded analytics SDK" sdk=true %}
-
-You can style your embedded Metabase components with a theme.
-
-Here's an example that includes the various styling options available:
-
-```ts
-{% include_file "{{ dirname }}/snippets/appearance/theme.ts" %}
-```
-
-### Customizing loader and error components
-
-You can provide your own components for loading and error states by specifying `loaderComponent` and `errorComponent` as props to `MetabaseProvider`.
-
-```tsx
-{% include_file "{{ dirname }}/snippets/appearance/customizing-loader-and-components.tsx" snippet="imports" %}
-
-{% include_file "{{ dirname }}/snippets/appearance/customizing-loader-and-components.tsx" snippet="example" %}
-```
-
-## Limitations
-
-- CSS variables aren't yet supported. If you'd like Metabase to support CSS variables, please upvote this [feature request](https://github.com/metabase/metabase/issues/59237).
-- Colors set in the visualization settings for a question will override theme colors.
diff --git a/docs/embedding/sdk/introduction.md b/docs/embedding/sdk/introduction.md
index 48ef687a029..d53acb1525c 100644
--- a/docs/embedding/sdk/introduction.md
+++ b/docs/embedding/sdk/introduction.md
@@ -93,11 +93,11 @@ Starting with Metabase 57, the SDK consists of two parts:
Start with one of the quickstarts, then see these pages for more info on components, theming, and more.
-- [Authentication](./authentication.md)
+- [Authentication](../authentication.md)
- [Questions](./questions.md)
- [AI chat](./ai-chat.md)
- [Dashboards](./dashboards.md)
-- [Appearance](./appearance.md)
+- [Appearance](../appearance.md)
- [Collections](./collections.md)
- [Plugins](./plugins.md)
- [Config](./config.md)
diff --git a/docs/embedding/sdk/next-js.md b/docs/embedding/sdk/next-js.md
index c0bf2d3416f..20cb8849dcd 100644
--- a/docs/embedding/sdk/next-js.md
+++ b/docs/embedding/sdk/next-js.md
@@ -23,7 +23,7 @@ As of modular embedding SDK 57, the compatibility layer for server-side renderin
## Handling authentication
-App Router and Pages Router have different ways to define API routes. If you want to authenticate users from your server with JWT, you can follow the instructions below. But if you want to authenticate with API keys for local development, see [Authenticating locally with API keys](./authentication.md#authenticating-locally-with-api-keys).
+App Router and Pages Router have different ways to define API routes. If you want to authenticate users from your server with JWT, you can follow the instructions below. But if you want to authenticate with API keys for local development, see [Authenticating locally with API keys](../authentication.md#authenticating-locally-with-api-keys).
### Using App Router
diff --git a/docs/embedding/sdk/quickstart-with-sample-app.md b/docs/embedding/sdk/quickstart-with-sample-app.md
index 0b04fed0d48..297baf64193 100644
--- a/docs/embedding/sdk/quickstart-with-sample-app.md
+++ b/docs/embedding/sdk/quickstart-with-sample-app.md
@@ -128,7 +128,6 @@ From any Metabase page, click on the **gear** icon in the upper right and select
Turn on:
- Modular embedding SDK
-- Static embedding
Otherwise, this whole thing is hopeless.
@@ -247,4 +246,4 @@ In your app, you'll see an embedded `InteractiveQuestion` component.
## Next steps
-To style the components, try changing some of the `theme` options in the client app at `client/src/App.jsx`. For more on theming, check out [Appearance](./appearance.md).
+To style the components, try changing some of the `theme` options in the client app at `client/src/App.jsx`. For more on theming, check out [Appearance](../appearance.md).
diff --git a/docs/embedding/sdk/quickstart.md b/docs/embedding/sdk/quickstart.md
index af4757f222b..6ebaeb399ce 100644
--- a/docs/embedding/sdk/quickstart.md
+++ b/docs/embedding/sdk/quickstart.md
@@ -13,7 +13,7 @@ This setup:
- Only works on localhost when developing your app (though your Metabase doesn't need to be running locally).
- Works with both the Enterprise and Open Source editions of Metabase, both self-hosted and on Metabase Cloud.
-If you want to use the SDK in production, however, you'll also need to [set up JWT SSO authentication](./authentication.md), which requires a [Pro](https://store.metabase.com/checkout/embedding) or [Enterprise plan](https://www.metabase.com/pricing/). To enable JWT SSO when you're self-hosting Metabase, you'll need to run the Enterprise Edition Docker image or JAR, and [activate your license](../../installation-and-operation/activating-the-enterprise-edition.md).
+If you want to use the SDK in production, however, you'll also need to [set up JWT SSO authentication](../authentication.md), which requires a [Pro](https://store.metabase.com/checkout/embedding) or [Enterprise plan](https://www.metabase.com/pricing/). To enable JWT SSO when you're self-hosting Metabase, you'll need to run the Enterprise Edition Docker image or JAR, and [activate your license](../../installation-and-operation/activating-the-enterprise-edition.md).
## Prerequisites
@@ -77,5 +77,5 @@ Run your app and visit the page with the embedded dashboard.
## Next steps
-- Explore [theming to change the look and feel](./appearance.md).
-- Continue by [setting up JWT SSO in Metabase and your app](./authentication.md) to sign people in, manage permissions, and deploy your app in production.
+- Explore [theming to change the look and feel](../appearance.md).
+- Continue by [setting up JWT SSO in Metabase and your app](../authentication.md) to sign people in, manage permissions, and deploy your app in production.
diff --git a/docs/embedding/securing-embeds.md b/docs/embedding/securing-embeds.md
index 14cee7a3e7e..1a4a030c72d 100644
--- a/docs/embedding/securing-embeds.md
+++ b/docs/embedding/securing-embeds.md
@@ -58,41 +58,41 @@ https://my-metabase.com/public/dashboard/184f819c-2c80-4b2d-80f8-26bffaae5d8b
Loading the public link without the query parameter would remove the "Status = Active" filter from the data. The person would get access to the original Accounts data, including the rows with inactive accounts.
-## Static embeds are authorized with JWT
+## Guest embeds are authorized with JWT
-Static embedding uses a [JWT authorization flow](#static-embedding-with-jwt-authorization) to do two things:
+Guest embedding uses a [JWT authorization flow](#guest-embedding-with-jwt-authorization) to do two things:
- Sign resources (e.g., the URLs of charts or dashboards) to ensure that only your embedding application can ask for data from your Metabase.
- Sign parameters (e.g., dashboard filters) to prevent people from [changing the filters](#example-filters-in-public-links-dont-secure-data) and getting access to other data.
-### Static embeds don't have user sessions
+### Guest embeds don't have user sessions
-Static embeds don't authenticate people's identities on the Metabase side, so people can view a static embed without creating a Metabase account. However, without a Metabase account, Metabase won't have a way to remember a user or their session, which means:
+Guest embeds don't authenticate people's identities on the Metabase side, so people can view a guest embed without creating a Metabase account. However, without a Metabase account, Metabase won't have a way to remember a user or their session, which means:
-- Metabase [permissions](../permissions/introduction.md) and [row and column security](../permissions/row-and-column-security.md) won't work --- if you need to lock down sensitive data, you must set up [locked parameters](#example-securing-data-with-locked-parameters-on-a-static-embed) for _each_ of your static embeds.
-- Any filter selections in a static embed will reset once the signed JWT expires.
-- All Static embed usage will show up in [usage analytics](../usage-and-performance-tools/usage-analytics.md) under "External user".
+- Metabase [permissions](../permissions/introduction.md) and [row and column security](../permissions/row-and-column-security.md) won't work --- if you need to lock down sensitive data, you must set up [locked parameters](#example-securing-data-with-locked-parameters-on-a-guest-embed) for _each_ of your guest embeds.
+- Any filter selections in a guest embed will reset once the signed JWT expires.
+- All guest embed usage will show up in [usage analytics](../usage-and-performance-tools/usage-analytics.md) under "External user".
-## Security in static embedding vs. modular and full app embedding
+## Security in guest embedding vs. modular and full app embedding
-Static embedding only guarantees authorized access to your Metabase data (you decide _what_ is accessible).
+Guest embedding only guarantees authorized access to your Metabase data (you decide _what_ is accessible).
-If you want to secure your static embeds based on someone's identity (you decide _who_ gets access to _what_), you'll need to set up your own authentication flow and manually wire that up to [locked parameters](#example-sending-user-attributes-to-a-locked-parameter) on each of your static embeds. Note that locked parameters are essentially filters, so you can only set up **row-level** restrictions in a static embed.
+If you want to secure your guest embeds based on someone's identity (you decide _who_ gets access to _what_), you'll need to set up your own authentication flow and manually wire that up to [locked parameters](#example-sending-user-attributes-to-a-locked-parameter) on each of your guest embeds. Note that locked parameters are essentially filters, so you can only set up **row-level** restrictions in a guest embed.
If you want an easier way to embed different views of data for different customers (without allowing the customers to see each other’s data), learn how [Modular and full app embedding authenticates and authorizes people in one flow](#modular-and-full-app-embedding-auth-with-jwt-or-saml).
-### Static embedding with JWT authorization
+### Guest embedding with JWT authorization
-![Static embedding with JWT authorization.](./images/signed-embedding-jwt.png)
+![Guest embedding with JWT authorization.](./images/signed-embedding-jwt.png)
This diagram illustrates how an embed gets secured by a signed JWT:
1. **Visitor arrives**: your frontend gets a request to display a Metabase [embedding URL](./static-embedding.md#adding-the-embedding-url-to-your-website).
-2. **Signed request**: your backend generates a Metabase embedding URL with a [signed JWT](./static-embedding.md#how-static-embedding-works). The signed JWT should encode any query [parameters](./static-embedding-parameters.md) you're using to filter your data.
+2. **Signed request**: your backend generates a Metabase embedding URL with a [signed JWT](./guest-embedding.md#how-guest-embedding-works). The signed JWT should encode any query [parameters](./static-embedding-parameters.md) you're using to filter your data.
3. **Response**: your Metabase backend returns data based on the query parameters encoded in the signed JWT.
4. **Success**: your frontend displays the embedded Metabase page with the correct data.
-### Example: securing data with locked parameters on a static embed
+### Example: securing data with locked parameters on a guest embed
In the [public embedding example](#example-filters-in-public-links-dont-secure-data), we showed you (perhaps unwisely) how someone could exploit a unique public link by editing its query parameters.
@@ -118,13 +118,13 @@ https://my-metabase.com/public/dashboard/184f819c-2c80-4b2d-80f8-26bffaae5d8b?st
| 2 | Basic | Active |
| 5 | Premium | Active |
-With static embeds, we can "lock" the filter by encoding the query parameter in a signed JWT. For example, say we set up the "Status = Active" filter as a [locked parameter](./static-embedding-parameters.md). The `?status=active` query parameter will be encoded in the signed JWT, so it won't be visible or editable from the static embedding URL:
+With guest embeds, we can "lock" the filter by encoding the query parameter in a signed JWT. For example, say we set up the "Status = Active" filter as a [locked parameter](./static-embedding-parameters.md#restricting-data-in-a-static-embed-with-locked-parameters). The `?status=active` query parameter will be encoded in the signed JWT, so it won't be visible or editable from the guest embedding URL:
```plaintext
https://my-metabase.com/dashboard/your_signed_jwt
```
-If someone tries to add an (unsigned) query parameter to the end of the static embedding URL like this:
+If someone tries to add an (unsigned) query parameter to the end of the guest embedding URL like this:
```plaintext
https://my-metabase.com/dashboard/your_signed_jwt?status=inactive
@@ -154,12 +154,10 @@ The flow might look something like this:
1. A customer logs into our web app.
2. Our app backend looks up the customer's `account_id` based on the account email used during login.
-3. Our app backend uses Metabase's [secret key](./static-embedding.md#regenerating-the-static-embedding-secret-key) to [generate the embedding URL](./static-embedding.md#how-static-embedding-works) with a signed JWT. The signed JWT encodes the query parameters to filter the Accounts dashboard on `Account ID = account_id`.
-4. Metabase returns the filtered dashboard at the static embedding URL.
+3. Our app backend uses Metabase's [secret key](./guest-embedding.md#regenerating-the-embedding-secret-key) to [generate the embedding URL](./guest-embedding.md#how-guest-embedding-works) with a signed JWT. The signed JWT encodes the query parameters to filter the Accounts dashboard on `Account ID = account_id`.
+4. Metabase returns the filtered dashboard at the guest embedding URL.
5. Our app frontend displays the filtered dashboard in an iframe.
-For code samples, see the [static embedding reference app](https://github.com/metabase/embedding-reference-apps).
-
## Modular and full app embedding auth with JWT or SAML
Modular embedding (including using the [SDK](./sdk/introduction.md)), and [full-app embedding](./full-app-embedding.md) integrate with SSO (either [JWT](../people-and-groups/authenticating-with-jwt.md) or [SAML](../people-and-groups/authenticating-with-saml.md)) to authenticate and authorize people in one flow. The auth integration makes it easy to map user attributes (such as a person's role or department) to granular levels of data access, including:
@@ -188,7 +186,7 @@ The mechanics of step 4 will vary a bit depending on whether you use [JWT](../pe
### Example: securing data with SSO and row and column security
-In our static embedding example, we used [locked parameters](#example-securing-data-with-locked-parameters-on-a-static-embed) to display secure filtered views of the Accounts table.
+In our guest embedding example, we used [locked parameters](#example-securing-data-with-locked-parameters-on-a-guest-embed) to display secure filtered views of the Accounts table.
The nice thing about modular and full app embedding and [SSO](../people-and-groups/start.md#sso-for-metabase-pro-and-enterprise-plans) integration is that we don't have to manually manage locked parameters for each embed. Instead, we can map user attributes from our identity provider (IdP) to [permissions](../permissions/introduction.md) and [row and column security](../permissions/row-and-column-security.md) in Metabase. People can get authenticated and authorized to self-serve specific subsets of data from their very first login.
@@ -245,7 +243,7 @@ When Customer 1 logs in, they'll see a different filtered version of the Account
- [Modular embedding with SDK reference app](https://github.com/metabase/metabase-nodejs-react-sdk-embedding-sample)
- [Full app embedding demo](https://embedding-demo.metabase.com/)
- [Full app embedding reference app](https://github.com/metabase/sso-examples/tree/master/app-embed-example)
-- [Static embedding reference app](https://github.com/metabase/embedding-reference-apps)
+- [Guest embedding reference app](https://github.com/metabase/embedding-reference-apps)
## Further reading
diff --git a/docs/embedding/start.md b/docs/embedding/start.md
index ee553aa7ade..2352e65cc76 100644
--- a/docs/embedding/start.md
+++ b/docs/embedding/start.md
@@ -14,31 +14,35 @@ What is embedding, and how does it work?
Embed individual dashboards, questions, or the query builder in your app with an interactive wizard and simple drop-in script, with minimal or no coding required. Control component UI and theming. Integrate your app's auth with Metabase SSO.
-## [Modular embedding SDK](./sdk/introduction.md)
+### [Modular embedding SDK](./sdk/introduction.md)
With the Modular embedding SDK, you can embed individual Metabase components with React (like standalone charts, dashboards, the query builder, and more). You can manage access and interactivity per component, and you have advanced customization for seamless styling.
-## [Modular embedding SDK quickstart](./sdk/quickstart.md)
+### [Modular embedding SDK quickstart](./sdk/quickstart.md)
Jump to a SDK quickstart with a sample React application.
-## [Static embedding](./static-embedding.md)
+### [Guest embedding](./guest-embedding.md)
-Also known as Signed Embedding, Static embedding is a secure way to embed charts and dashboards. Static embeds are view only; people won't be able to drill-through charts and tables.
+Guest embedding is a secure way to embed charts and dashboards. Guest embeds are view only; people won't be able to drill-through charts and tables.
-## [Parameters for static embeds](./static-embedding-parameters.md)
+### [Parameters for guest embeds](./static-embedding-parameters.md)
You can pass parameters between Metabase and your website via the embedding URL to specify how Metabase items should look and behave inside the iframe on your website.
+### [Translating guest embeds](./translations.md)
+
+Upload a translation dictionary to translate questions and dashboards (only in guest embeds).
+
## [Full app embedding](./full-app-embedding.md)
Full app embedding allows you to embed full Metabase app in an iframe. Full app embedding integrates with your data permissions to let people slice and dice data on their own using Metabase's query builder.
-## [Full app embedding quickstart](./full-app-embedding-quick-start-guide.md)
+### [Full app embedding quickstart](./full-app-embedding-quick-start-guide.md)
You'll embed the full Metabase application in your app. Once logged in, people can view a Metabase dashboard in your web app, and be able to use the full Metabase application to explore their data, and only their data.
-## [Full app UI components](./full-app-ui-components.md)
+### [Full app UI components](./full-app-ui-components.md)
Customize the UI components in your full app embed by adding parameters to the embedding URL.
@@ -46,10 +50,6 @@ Customize the UI components in your full app embed by adding parameters to the e
Admins can also create unsecured public links or embeds of questions and dashboards.
-## [Securing embedded Metabase](./securing-embeds.md)
+## [Securing embeds](./securing-embeds.md)
How to make sure the right people can see the right data in your embedded Metabase.
-
-## [Translating questions and dashboards](./translations.md)
-
-Upload a translation dictionary to translate questions and dashboards (only in static embeds).
diff --git a/docs/embedding/static-embedding-parameters.md b/docs/embedding/static-embedding-parameters.md
index a9e9ba34980..8126539b6a4 100644
--- a/docs/embedding/static-embedding-parameters.md
+++ b/docs/embedding/static-embedding-parameters.md
@@ -171,8 +171,6 @@ Because Metabase doesn't display locked parameters as filter widgets, you can us
## Customizing the appearance of a static embed
-![Look and feel: appearance settings on static embed](./images/04-preview.png)
-
You can change the appearance of an embedded item by adding hash parameters (e.g., `#theme=night`) to the end of the URL in your iframe's `src` attribute.
For example, the following embedding URL will display an embedded item in dark mode, without a border, and with its original title:
diff --git a/docs/embedding/static-embedding.md b/docs/embedding/static-embedding.md
index e1d9c07b9f1..9222e4c0f6f 100644
--- a/docs/embedding/static-embedding.md
+++ b/docs/embedding/static-embedding.md
@@ -6,7 +6,7 @@ redirect_from:
# Static embedding
-Also known as: standalone embedding, or signed embedding.
+> We recommend you use the new [Guest embedding](./guest-embedding.md) approach instead of static embedding.
{% include shared/in-page-promo-embedding-workshop.html %}
@@ -55,8 +55,6 @@ To create a static embed:
6. Optional: [Add parameters to the embed](./static-embedding-parameters.md).
7. Click **Publish**.
-![Preview](./images/04-preview.png)
-
## Adding the embedding URL to your website
The embedding URL for a question or dashboard is the Metabase URL that'll be displayed in your website's iframe. It's generated by your web server using your [Metabase site URL](../configuring-metabase/settings.md#site-url), [signed JWT](#how-static-embedding-works), and [parameters](./static-embedding-parameters.md):
@@ -83,8 +81,6 @@ For more examples, see our [reference apps repo](https://github.com/metabase/emb
When you make changes to the look and feel or parameter preview settings, Metabase will update the code and highlight the changes. Make sure to copy these changes to your actual server code.
-![Code samples for embedding](./images/05-code.png)
-
Metabase generates server code for:
- Clojure
diff --git a/docs/embedding/translations.md b/docs/embedding/translations.md
index 0be7c8ab9a2..915791188a0 100644
--- a/docs/embedding/translations.md
+++ b/docs/embedding/translations.md
@@ -1,13 +1,13 @@
---
title: Translate embedded dashboards and questions
-summary: Upload a translation dictionary to translate questions and dashboards into different languages. Only available for static embeds.
+summary: Upload a translation dictionary to translate questions and dashboards into different languages. Only available for guest embeds.
---
# Translate embedded dashboards and questions
{% include plans-blockquote.html feature="Translation of embedded content" convert_pro_link_to_embbedding=true %}
-For now, translations are only available for [guest embed](./static-embedding.md). Translations aren't available for SSO-based modular embedding or full app embedding.
+For now, translations are only available for [guest embeds](./guest-embedding.md). Translations aren't available for SSO-based modular embedding or full app embedding.
You can upload a translation dictionary to translate strings both in Metabase content (like dashboard titles) and in the data itself (like column names and values).
@@ -23,26 +23,31 @@ The dictionary must be a CSV with these columns:
To add a translation dictionary:
-1. Go to **Admin > Embedding > Static**.
+1. Go to **Admin settings > Embedding**.
2. Under **Translate embedded dashboards and question**, click **Upload translation dictionary**.
Uploading a new dictionary will replace the existing dictionary.
To remove a translation dictionary, upload a blank dictionary.
-## Translate content in static embeds
-
-To translate content in a static embed using the uploaded dictionary, add the [`locale` parameter](./static-embedding-parameters.md#setting-the-language-for-a-static-embed) to the embed URL:
+## Translate content in guest embeds
+To translate content in a guest embed using the uploaded dictionary, add the [`locale` parameter](./components.md).
```
-https://metabase.example.com/public/dashboard/7b6e347b-6928-4aff-a56f-6cfa5b718c6b?category=&city=&state=#locale=ko
+ <metabase-dashboard
+ dashboard-id="1"
+ with-title="false"
+ with-subscriptions="true"
+ drills="true"
+ locale="es"
+ </metabase-dashboard>
```
Metabase UI elements (like button labels) will be translated automatically - you don't need to add translations for them to your dictionary.
## Example translation dictionary
-Metabase uses these dictionaries to translate user-generated content, like dashboard names in [static embeds](./static-embedding.md).
+Metabase uses these dictionaries to translate user-generated content, like dashboard names in [guest embeds](./guest-embedding.md).
| Language | String | Translation |
| -------- | ----------- | ------------ |
@@ -53,7 +58,7 @@ Metabase uses these dictionaries to translate user-generated content, like dashb
| pt-BR | Vendor | Vendedor |
| IT | Examples | Esempi |
-Prefer hyphens in your `pt-BR` in your translation dictionary. Underscores are also acceptable (if you download the dictionary _after_ uploading it, Metabase will transform `pt-BR` to `pt_BR`), but since the `locale` parameter in static embedding only accepts locales with hyphens (like `pt-BR`), we recommend using hyphens for consistency.
+Prefer hyphens in your `pt-BR` in your translation dictionary. Underscores are also acceptable (if you download the dictionary _after_ uploading it, Metabase will transform `pt-BR` to `pt_BR`), but since the `locale` parameter in guest embeds only accepts locales with hyphens (like `pt-BR`), we recommend using hyphens for consistency.
[See a list of supported locales](../configuring-metabase/localization.md#supported-languages).
@@ -87,4 +92,4 @@ If the strings you want to translate include markdown formatting, you'll need to
## Further reading
-- [Static embedding](./static-embedding.md)
+- [Guest embedding](./guest-embedding.md)
diff --git a/docs/installation-and-operation/serialization.md b/docs/installation-and-operation/serialization.md
index 2663e1213fd..1301135e48e 100644
--- a/docs/installation-and-operation/serialization.md
+++ b/docs/installation-and-operation/serialization.md
@@ -298,7 +298,7 @@ This ID refers to the collection where the question was saved. In a real export,
### Entity IDs work with embedding
-Metabase supports working with [Entity IDs](#metabase-uses-entity-ids-to-identify-and-reference-metabase-items) for questions, dashboards, and collections in [Static Embedding](../embedding/static-embedding.md), [Modular embedding](../embedding/modular-embedding.md), [SDK](../embedding/sdk/introduction.md), and [Full app embedding](../embedding/full-app-embedding.md).
+Metabase supports working with [Entity IDs](#metabase-uses-entity-ids-to-identify-and-reference-metabase-items) for questions, dashboards, and collections in [Guest embedding](../embedding/guest-embedding.md), [Modular embedding](../embedding/modular-embedding.md), [SDK](../embedding/sdk/introduction.md), and [Full app embedding](../embedding/full-app-embedding.md).
A high-level workflow for using Entity IDs when embedding Metabase in your app would look something like:
diff --git a/docs/permissions/database-routing.md b/docs/permissions/database-routing.md
index 838a4acea4a..f99320e0a4d 100644
--- a/docs/permissions/database-routing.md
+++ b/docs/permissions/database-routing.md
@@ -13,7 +13,7 @@ Database routing is useful for:
- Managing modular and full app embedding setups where each customer has their own database with identical schemas.
- Database routing can't be used with static embedding, because database routing requires people who use the embedded questions and dashboards to have a Metabase account. Without a Metabase account, Metabase can't route the queries because it doesn't know who is viewing the embed.
+ Database routing can't be used with guest embedding, because database routing requires people who use the embedded questions and dashboards to have a Metabase account. Without a Metabase account, Metabase can't route the queries because it doesn't know who is viewing the embed.
- Switching between dev and prod data warehouses.
- Changing the target data warehouse for certain teams.
diff --git a/docs/troubleshooting-guide/my-dashboard-is-slow.md b/docs/troubleshooting-guide/my-dashboard-is-slow.md
index ae5dd84991c..8b729206327 100644
--- a/docs/troubleshooting-guide/my-dashboard-is-slow.md
+++ b/docs/troubleshooting-guide/my-dashboard-is-slow.md
@@ -44,7 +44,7 @@ Caching takes less effort because it doesn't involve any changes to your schemas
One of the easiest ways to make a question or dashboard run faster is to work with a smaller dataset. Your Metabase admin can apply automatic data limitations using things like [SSO](../people-and-groups/start.md#authentication), [data permissions](../permissions/data.md), and [row and column security](../permissions/row-and-column-security.md).
-When someone loads a question or a dashboard in a static embed, however, that question or dashboard will query the full dataset (rather than a smaller dataset limited by permissions). Static, [signed embeds](../embedding/static-embedding.md) don't require people to be logged in, and unauthenticated people viewing the signed embed won't be subject to the permissions and data restrictions set up by your admin.
+When someone loads a question or a dashboard in a guest embed, however, that question or dashboard will query the full dataset (rather than a smaller dataset limited by permissions). [Guest embeds](../embedding/guest-embedding.md) don't require people to be logged in, and unauthenticated people viewing the guest embed won't be subject to the permissions and data restrictions set up by your admin.
## Dashboard is slow compared to similar dashboards
diff --git a/docs/troubleshooting-guide/row-and-column-security.md b/docs/troubleshooting-guide/row-and-column-security.md
index d0be379e883..9fe214d19ce 100644
--- a/docs/troubleshooting-guide/row-and-column-security.md
+++ b/docs/troubleshooting-guide/row-and-column-security.md
@@ -40,9 +40,9 @@ There are several reasons people could be seeing rows that they're not supposed
For the person in question, check to see which groups they belong to. Do any of the groups have access to the table you're trying to secure? If so, remove them from that group. Remember that everyone is a member of the "All users" group; which is why we recommend you revoke permissions from the all users group, and create new groups to selectively apply permissions to your data sources.
-### Is the question available via Static embedding or Public Sharing?
+### Is the question available via guest embedding or Public Sharing?
-**Root cause**: The question is public. [Public questions][public-sharing], even those that use [Static embedding][static-embedding], can't be secured. If someone views the question without logging into Metabase, Metabase lacks user attributes or group information for filtering the data, so it will show all results.
+**Root cause**: The question is public. [Public questions][public-sharing], even those that use [guest embedding][static-embedding], can't be secured. If someone views the question without logging into Metabase, Metabase lacks user attributes or group information for filtering the data, so it will show all results.
**Steps to take**:
@@ -132,13 +132,13 @@ Go to **Admin** > **Table Metadata** and find the table. Check to make sure that
1. Go to **Admin Panel** > **Table Metadata** for the fields in question.
2. If the value is remapped from a restricted table, change it so that Metabase will use the original value from the table. See [Metadata editing][data-model] for more information.
-### Is the question available via static embedding?
+### Is the question available via guest embedding?
-**Root cause**: [Static embedding][static-embedding] will show all results by default. While it's possible to control filtering with [locked parameters][locked-parameters], static embedding depends only on the token generated by the including page, not whether someone is logged into Metabase.
+**Root cause**: [Guest embedding][static-embedding] will show all results by default. While it's possible to control filtering with [locked parameters][locked-parameters], guest embedding depends only on the token generated by the including page, not whether someone is logged into Metabase.
**Steps to take**:
-Since someone must log in so that Metabase can apply row security for that person, avoid using static embedding when you want to restrict row or column access to a table.
+Since someone must log in so that Metabase can apply row security for that person, avoid using guest embedding when you want to restrict row or column access to a table.
## People can't see data they're supposed to be able to see