diff --git a/advanced/rest-api/overview.mdx b/advanced/rest-api/overview.mdx
index f9d74b067..05273b1ae 100644
--- a/advanced/rest-api/overview.mdx
+++ b/advanced/rest-api/overview.mdx
@@ -4,16 +4,11 @@ title: Overview
## Trigger Updates
-Leverage the REST API to programmatically trigger an update when desired.
-The primary use-case will be to trigger updates. We will be adding more and more
-functionality to the API overtime. Let us know what else you want to see in
-[our community](https://mintlify.com/community)!
+Use our REST API to trigger updates programmatically. More API functionality is in development - share feature requests in [our community](https://mintlify.com/community).
## Authentication
-You can generate an API key through
-[the dashboard](https://dashboard.mintlify.com/settings/integrations). The API key is
-associated with the entire org and can be used across multiple deployments.
+Generate your API key in [the dashboard](https://dashboard.mintlify.com/settings/integrations). One API key works for all deployments in your org.
@@ -21,12 +16,11 @@ associated with the entire org and can be used across multiple deployments.
## Discovery API
-The Discovery API allows you to embed an AI chat experience grounded in your docs and continually kept up to date into any application of your choosing.
-Responses include citations so you can point your users to the right places they need to get help.
+The Discovery API lets you embed AI chat into any app. The chat is powered by your docs and provides cited responses to help users find information.
## Getting Started
-To get started, you'll need to generate a Discovery API key in the [dashboard](https://dashboard.mintlify.com/products/chat/widget):
+1. Generate a Discovery API key in the [dashboard](https://dashboard.mintlify.com/products/chat/widget):
- The Discovery API token is a public token that can be referenced in your
- frontend code whereas the API key is a server-side token that should be kept
- secret.
+ Discovery API tokens are public and safe for frontend code. API keys are for server-side use only and should remain private.
-Now that you have an API key, check out our [example](https://github.com/mintlify/discovery-api-example) for how to use
-the API for AI chat. You can also see a deployed version of this example at [chat.mintlify.com](https://chat.mintlify.com).
+See our [example implementation](https://github.com/mintlify/discovery-api-example) or check out the live demo at [chat.mintlify.com](https://chat.mintlify.com).
\ No newline at end of file
diff --git a/advanced/subpath/cloudflare.mdx b/advanced/subpath/cloudflare.mdx
index 13ff2d841..a53a65288 100644
--- a/advanced/subpath/cloudflare.mdx
+++ b/advanced/subpath/cloudflare.mdx
@@ -5,9 +5,7 @@ description: "Host documentation at a /docs subpath using Cloudflare Workers"
## Create Cloudflare Worker
-Navigate to the `Workers & Pages > Create application > Create worker`. You
-should be able to presented with the following screen where you can create a new
-Cloudlfare worker.
+Go to `Workers & Pages > Create application > Create worker` to set up a new Cloudflare worker.
@@ -15,10 +13,11 @@ Cloudlfare worker.
### Add custom domain
-Once the worker is created, click `Configure worker`. Navigate to the worker
-`Settings > Triggers`. Click on `Add Custom Domain` to add your desired domain
-into the list - we recommend you add both the version with and without `www.`
-prepended to the domain.
+After creating the worker:
+1. Click `Configure worker`
+2. Go to `Settings > Triggers`
+3. Click `Add Custom Domain`
+4. Add your domain (both with and without `www.`)
-If you have trouble setting up a custom subdirectory,
-[contact our support team](mailto:sales@mintlify.com) and we'll walk you through
-upgrading your hosting with us.
+Need help? [Contact our support team](mailto:sales@mintlify.com) for hosting upgrades.
### Edit Worker Script
-Click on `Edit Code` and add the following script into the worker's code.
+Click `Edit Code` and add this script:
- Edit `DOCS_URL` by replacing `[SUBDOMAIN]` with your unique subdomain and
- `CUSTOM_URL` with your website's base URL.
+ Replace `[SUBDOMAIN]` with your subdomain and `CUSTOM_URL` with your website's URL in `DOCS_URL`.
```javascript
@@ -76,5 +72,4 @@ async function handleRequest(request) {
}
```
-Click on `Deploy` and wait for the changes to propagate (it can take up to a few
-hours).
+Deploy and wait for changes to propagate (up to a few hours).
\ No newline at end of file
diff --git a/api-playground/mdx/configuration.mdx b/api-playground/mdx/configuration.mdx
index 55682df30..2f06e3c11 100644
--- a/api-playground/mdx/configuration.mdx
+++ b/api-playground/mdx/configuration.mdx
@@ -1,13 +1,13 @@
---
title: 'MDX Setup'
-description: 'Generate docs pages for your API endpoints using MDX'
+description: 'Generate API docs using MDX'
---
-Mintlify allows you to define your API endpoints using a combination of `mint.json` configuration, MDX metadata fields, and the `` component. From the defined endpoints, we generate an API playground, request examples, and response examples.
+Define your API endpoints using `mint.json` config, MDX metadata, and the `` component to generate an API playground with request and response examples.
- In your `mint.json` file, define your base URL and auth method:
+ Add API configuration to your `mint.json`:
```json
{
@@ -20,7 +20,7 @@ Mintlify allows you to define your API endpoints using a combination of `mint.js
}
```
- If you would not like to show an API playground, you don't need to include auth types. Hide the playground with the following field:
+ To hide the API playground:
```json
{
@@ -32,12 +32,11 @@ Mintlify allows you to define your API endpoints using a combination of `mint.js
}
```
- Find a full list of API configurations [here](/settings/global#api-configurations).
+ See all API configurations [here](/settings/global#api-configurations).
-
-
- Each API endpoint page should have a corresponding MDX file. At the top of each file, define:
+
+ Create an MDX file for each endpoint with the required metadata:
```md
---
@@ -46,20 +45,18 @@ Mintlify allows you to define your API endpoints using a combination of `mint.js
---
```
- You can specify path parameters by adding the parameter name to the path, wrapped with `{}`:
+ For path parameters, use `{}`:
```bash
https://api.example.com/v1/endpoint/{userId}
```
-
- If you have `baseUrl` configured in [mint.json](/settings/global), you can use relative paths like `/v1/endpoint`.
-
+ With `baseUrl` configured in mint.json, you can use relative paths like `/v1/endpoint`
-
- Add your endpoint pages to the sidebar by adding the paths to the `navigation` field in your `mint.json`. Learn more about structuring your docs [here](/settings/navigation).
+
+ Add endpoint pages to your sidebar in `mint.json`'s `navigation` field. See [navigation docs](/settings/navigation).
-
+
\ No newline at end of file
diff --git a/api-playground/openapi/setup.mdx b/api-playground/openapi/setup.mdx
index bc24fbbf6..d72dd0f84 100644
--- a/api-playground/openapi/setup.mdx
+++ b/api-playground/openapi/setup.mdx
@@ -5,16 +5,13 @@ description: "Reference OpenAPI endpoints in your docs pages"
## Add an OpenAPI specification file
-To describe your endpoints with OpenAPI, make sure you have a valid OpenAPI
-document in either JSON or YAML format that follows the
-[OpenAPI specification](https://swagger.io/specification/). Your document must
-follow OpenAPI specification 3.0+.
+Add your OpenAPI document (JSON or YAML) following the [OpenAPI 3.0+ specification](https://swagger.io/specification/).
## Auto-populate API pages
-The fastest way to get started with OpenAPI is to add an `openapi` field to a tab or anchor in the `mint.json`. This field can contain either the path to an OpenAPI document in your docs repo, or the URL of a hosted OpenAPI document. Mintlify will automatically generate a page for each OpenAPI operation and place them in the tab/anchor.
+The quickest setup: Add an `openapi` field to your `mint.json` under a tab or anchor. Use either a file path or URL to your OpenAPI doc.
-**Example with Anchors:**
+**Using Anchors:**
```json {5}
{
@@ -29,9 +26,7 @@ The fastest way to get started with OpenAPI is to add an `openapi` field to a ta
}
```
-
-
-**Example with Tabs:**
+**Using Tabs:**
```json {6}
{
@@ -45,108 +40,50 @@ The fastest way to get started with OpenAPI is to add an `openapi` field to a ta
}
```
-
-
-To validate your OpenAPI spec, you can use this command:
`mintlify openapi-check `
-
-
-When using this option, the metadata for the generated pages will have the following default values:
-
-* `title`: The `summary` field from the OpenAPI operation, if present. Otherwise a title generated from the HTTP method and endpoint.
-
-* `description`: The `description` field from the OpenAPI operation, if present.
-
-* `version`: The `version` value from the anchor or tab, if present.
+Validate your OpenAPI spec: `mintlify openapi-check `
-There are some scenarios in which the default behavior isn't sufficient. If you need more customizability, you can create an MDX page for your OpenAPI operation, and modify it just like any other MDX page.
+Default page metadata will use:
+- `title`: OpenAPI operation's `summary` or auto-generated from method/endpoint
+- `description`: OpenAPI operation's `description`
+- `version`: Anchor/tab's version value
-## Create MDX files for API pages
+## Custom API Pages
-If you want to customize the page metadata, add additional content, omit certain OpenAPI operations, or reorder OpenAPI pages in your navigation, you'll need an MDX page for each operation. Here is [an example MDX OpenAPI page](https://github.com/elevenlabs/elevenlabs-docs/blob/e5e267c97b8d1e4c21db1dcdb8b005eb1dfed7da/api-reference/speech-to-speech.mdx?plain=1#L2) from [Elevenlabs](https://elevenlabs.io/docs/api-reference/speech-to-speech).
+Need more control? Create MDX pages for your API operations.
-
-
-### Autogenerate files
-
-For large OpenAPI documents, creating one MDX page for each OpenAPI operation can be a lot of work. To make it easier, we created a local OpenAPI page scraper.
-
-Our Mintlify [scraper](https://www.npmjs.com/package/@mintlify/scraping)
-autogenerates MDX files for your OpenAPI endpoints. Use the relative path to the
-OpenAPI document in your codebase.
-
-```bash
-npx @mintlify/scraping@latest openapi-file
-```
+### Generate MDX Files Automatically
-Add the `-o` flag to specify a folder to populate the files into. If a folder is
-not specified, the files will populate in the working directory.
+For large APIs, use our scraper to generate MDX files:
```bash
npx @mintlify/scraping@latest openapi-file -o api-reference
```
-Learn more about our scraping package [here](https://www.npmjs.com/package/@mintlify/scraping).
-
-The scraper will output an array of
-[Navigation entries](/settings/global#structure) containing your OpenAPI MDX
-files. You can either append these entries to your existing Navigation, or
-reorder and add the files to your navigation manually.
-
- If your OpenAPI document is invalid, the files will not autogenerate.
+ Invalid OpenAPI docs won't generate files.
-### Manually specify files
-
-You can always create an MDX page manually, and reference the OpenAPI operation in the page's metadata using the `openapi` field.
-
-
-
-By using the OpenAPI reference, the name, description, parameters, responses,
-and the API playground will be automatically generated from the OpenAPI document.
-
-If you have multiple OpenAPI files, include the path to the OpenAPI file to ensure Mintlify finds the correct OpenAPI document. This is not required if you have
-only one OpenAPI file - it will automatically detect your OpenAPI file.
-
-
- ```md Example
- ---
- title: "Get users"
- openapi: "/path/to/openapi-1.json GET /users"
- ---
- ```
+### Manual MDX Creation
- ```md Format
- ---
- title: "title of the page"
- openapi: openapi-file-path method path
- ---
- ```
-
+Create custom MDX pages by referencing OpenAPI operations in the frontmatter:
-
+```md
+---
+title: "Get users"
+openapi: "/path/to/openapi.json GET /users"
+---
+```
- The method and path must match the method and path specified in the OpenAPI
- document exactly. If the endpoint doesn't exist in the OpenAPI file,
- the page will be empty.
+ Method and path must exactly match your OpenAPI document.
-## Create MDX files for OpenAPI schemas
+## OpenAPI Schema Pages
-Mintlify also allows you to create individual pages for any OpenAPI schema
-defined in an OpenAPI document's `components.schemas` field:
+Create pages for schema definitions using:
-
- ```md Example
- ---
- openapi-schema: OrderItem
- ---
- ```
-
- ```md Format
- ---
- openapi-schema: "schema-key"
- ---
- ```
-
\ No newline at end of file
+```md
+---
+openapi-schema: "schema-key"
+---
+```
\ No newline at end of file
diff --git a/code.mdx b/code.mdx
index b137fcce0..d42f86a69 100644
--- a/code.mdx
+++ b/code.mdx
@@ -8,15 +8,15 @@ icon: 'code'
### Inline Code
-To denote a `word` or `phrase` as code, enclose it in backticks (`).
+Use backticks (`) to mark `code` within text.
```
-To denote a `word` or `phrase` as code, enclose it in backticks (`).
+Use backticks (`) to mark `code` within text.
```
### Code Block
-Use [fenced code blocks](https://www.markdownguide.org/extended-syntax/#fenced-code-blocks) by enclosing code in three backticks and follow the leading ticks with the programming language of your snippet to get syntax highlighting. Optionally, you can also write the name of your code after the programming language.
+Create code blocks using three backticks. Add a language name for syntax highlighting, and optionally a filename.
```java HelloWorld.java
class HelloWorld {
@@ -36,4 +36,4 @@ class HelloWorld {
```
````
-Visit the [Code Block page](/content/components/code) for more detailed docs.
+For more details, see the [Code Block page](/content/components/code).
\ No newline at end of file
diff --git a/content/components/code.mdx b/content/components/code.mdx
index d59351bb4..59822bee2 100644
--- a/content/components/code.mdx
+++ b/content/components/code.mdx
@@ -16,7 +16,7 @@ const hello = "world";
## Basic Code Block
-Use [fenced code blocks](https://www.markdownguide.org/extended-syntax/#fenced-code-blocks) by enclosing code in three backticks.
+Use triple backticks to create code blocks:
```
helloWorld();
@@ -30,9 +30,7 @@ helloWorld();
## Syntax Highlighting
-Put the name of your programming language after the three backticks to get syntax highlighting.
-
-We use [Prism](https://prismjs.com/#supported-languages) for syntax highlighting. [Test Drive Prism](https://prismjs.com/test.html#language=markup) lists all the languages supported.
+Add a language identifier after the backticks for syntax highlighting. We use [Prism](https://prismjs.com/#supported-languages).
```java
class HelloWorld {
@@ -54,7 +52,7 @@ class HelloWorld {
## Names
-You can add more text after the programming language to set the name of your code example. The text can be anything as long as its all in one line.
+Add text after the language to name your code example:
```javascript Code Block Example
const hello = "world";
@@ -68,7 +66,7 @@ const hello = "world";
## Line Highlighting
-You can highlight specific lines in your code blocks by adding a special comment after the language identifier. Use curly braces `{}` and specify line numbers or ranges separated by commas.
+Highlight specific lines using `{line-numbers}` after the language identifier:
```javascript Line Highlighting Example {1,3-5}
const greeting = "Hello, World!";
@@ -90,7 +88,7 @@ sayHello();
## Code Groups
-Want to display multiple code examples in one code box? Check out the Code Group docs:
+Need multiple code examples in one block? See the Code Group docs:
Read the reference for the Code Group component
+
+
\ No newline at end of file
diff --git a/development.mdx b/development.mdx
index 856629aaf..7862dbd9c 100644
--- a/development.mdx
+++ b/development.mdx
@@ -1,18 +1,17 @@
---
title: 'Local Development'
-description: 'Preview changes locally to update your docs'
+description: 'Preview docs locally'
---
-
-**Prerequisite**: Please install Node.js (version 19 or higher) before proceeding.
-
+Requires Node.js v19+
-**Step 1**: Install Mintlify:
+## Install and Run
-
+**1. Install Mintlify**
+
```bash npm
npm i -g mintlify
```
@@ -24,16 +23,17 @@ description: 'Preview changes locally to update your docs'
```bash pnpm
pnpm add -g mintlify
```
-
-**Step 2**: Navigate to the docs directory (where the `mint.json` file is located) and execute the following command:
+**2. Start Dev Server**
+
+Run this in your docs directory (where `mint.json` is):
```bash
mintlify dev
```
-Alternatively, if you do not want to install Mintlify globally you can use a run script available:
+Alternatively, run without global installation:
```bash npm
@@ -47,35 +47,26 @@ Alternatively, if you do not want to install Mintlify globally you can use a run
```bash pnpm
pnpm dlx mintlify dev
```
-
- Yarn's "dlx" run script requires yarn version >2. See [here](https://yarnpkg.com/cli/dlx) for more information.
+ Yarn's "dlx" needs yarn v2+. [Details](https://yarnpkg.com/cli/dlx)
-A local preview of your documentation will be available at `http://localhost:3000`.
-
-### Custom Ports
+Preview at `http://localhost:3000`
-By default, Mintlify uses port 3000. You can customize the port Mintlify runs on by using the `--port` flag. To run Mintlify on port 3333, for instance, use this command:
+## Custom Port
+Change the default port (3000):
```bash
mintlify dev --port 3333
```
-If you attempt to run Mintlify on a port that's already in use, it will use the next available port:
+## Updates
-```md
-Port 3000 is already in use. Trying 3001 instead.
-```
-
-## Mintlify Versions
-
-Please note that each CLI release is associated with a specific version of Mintlify. If your local website doesn't align with the production version, please update the CLI:
+Update CLI to match production:
-
```bash npm
npm i -g mintlify@latest
```
@@ -87,20 +78,18 @@ Please note that each CLI release is associated with a specific version of Mintl
```bash pnpm
pnpm up --global mintlify
```
-
-## Validating Links
-
-The CLI can assist with validating reference links made in your documentation. To identify any broken links, use the following command:
+## Link Validator
+Check for broken links:
```bash
mintlify broken-links
```
## Deployment
-If the deployment is successful, you should see the following:
+Successful deployment shows:
-## Code Formatting
+## Editor Setup
-We suggest using extensions on your IDE to recognize and format MDX. If you're a VSCode user, consider the [MDX VSCode extension](https://marketplace.visualstudio.com/items?itemName=unifiedjs.vscode-mdx) for syntax highlighting, and [Prettier](https://marketplace.visualstudio.com/items?itemName=esbenp.prettier-vscode) for code formatting.
+For VSCode users:
+- [MDX extension](https://marketplace.visualstudio.com/items?itemName=unifiedjs.vscode-mdx) for syntax highlighting
+- [Prettier](https://marketplace.visualstudio.com/items?itemName=esbenp.prettier-vscode) for formatting
## Troubleshooting
-
-
- This may be due to an outdated version of node. Try the following:
- 1. Remove the currently-installed version of mintlify: `npm remove -g mintlify`
- 2. Upgrade to Node v19 or higher.
- 3. Reinstall mintlify: `npm install -g mintlify`
+
+ 1. Remove mintlify: `npm remove -g mintlify`
+ 2. Upgrade to Node v19+
+ 3. Reinstall: `npm install -g mintlify`
-
-
- Solution: Go to the root of your device and delete the \~/.mintlify folder. Afterwards, run `mintlify dev` again.
+
+ Delete ~/.mintlify folder and run `mintlify dev` again
-
+
\ No newline at end of file
diff --git a/integrations/analytics/clearbit.mdx b/integrations/analytics/clearbit.mdx
index 629525434..5363d3104 100644
--- a/integrations/analytics/clearbit.mdx
+++ b/integrations/analytics/clearbit.mdx
@@ -2,7 +2,7 @@
title: "Clearbit"
---
-Add the following to your `mint.json` file to send analytics to Clearbit.
+Configure Clearbit analytics in `mint.json`:
@@ -23,3 +23,4 @@ Add the following to your `mint.json` file to send analytics to Clearbit.
```
+
\ No newline at end of file
diff --git a/integrations/analytics/google-analytics.mdx b/integrations/analytics/google-analytics.mdx
index 7ebfe1610..3bd95ede1 100644
--- a/integrations/analytics/google-analytics.mdx
+++ b/integrations/analytics/google-analytics.mdx
@@ -2,27 +2,24 @@
title: "Google Analytics 4"
---
-You will need to generate a new GA4 property to use with Mintlify. The data collected will go into the same project as your other Google Analytics data.
+Generate a new GA4 property for your Mintlify documentation. If you're using Universal Analytics (UA), you can still create a GA4 property in the same project.
-If you are using the old version of Google Analytics, Universal Analytics, you will still be able to generate a GA4 property. GA4 data is slightly different from UA data but still gets collected in the same project.
+## Setup Steps
-## How to Connect GA4 to Mintlify
+### 1. Create a Web Stream
-### Create a Web Stream
-
-You will need to create a web stream to get the Measurement ID to put into Mintlify.
-
-Click the cog at the bottom left of the Google Analytics screen. Then click on Data Streams.
+1. Go to Google Analytics settings (cog icon, bottom left)
+2. Navigate to Data Streams
+3. Click "Add Stream" > "Web"
+4. Enter your Mintlify docs URL

-Create a Web Stream and put the URL of your Mintlify docs site as the stream URL.
-
-Your Measurement ID looks like `G-XXXXXXX` and will show up under Stream Details immediately after you create the Web Stream.
+Your Measurement ID (format: `G-XXXXXXX`) will appear in Stream Details.
-### Put Measurement ID in mint.json
+### 2. Configure mint.json
-Add your Measurement ID to your `mint.json` file like so:
+Add your Measurement ID:
```json mint.json
"analytics": {
@@ -32,14 +29,12 @@ Add your Measurement ID to your `mint.json` file like so:
}
```
-### Wait
+### 3. Verification
-Google Analytics takes two to three days to show your data.
-
-You can use the [Google Analytics Debugger](https://chrome.google.com/webstore/detail/google-analytics-debugger/jnkmfdileelhofjcijamephohjechhna?hl=en) to check analytics are enabled correctly. The extension will log to your browser's console every time GA4 makes a request.
+- Data appears in GA4 within 2-3 days
+- Use [Google Analytics Debugger](https://chrome.google.com/webstore/detail/google-analytics-debugger/jnkmfdileelhofjcijamephohjechhna?hl=en) to verify setup
+- Check browser console for GA4 requests
-
-Preview links have analytics turned off.
-
-
+Preview links don't track analytics.
+
\ No newline at end of file
diff --git a/integrations/analytics/hotjar.mdx b/integrations/analytics/hotjar.mdx
index a872a8f72..e75bda99d 100644
--- a/integrations/analytics/hotjar.mdx
+++ b/integrations/analytics/hotjar.mdx
@@ -2,7 +2,7 @@
title: "HotJar"
---
-Add the following to your `mint.json` file to send analytics to HotJar.
+Add to `mint.json` to enable HotJar analytics:
```json Analytics options in mint.json
"analytics": {
@@ -11,4 +11,4 @@ Add the following to your `mint.json` file to send analytics to HotJar.
"hjsv": "required"
}
}
-```
+```
\ No newline at end of file
diff --git a/integrations/analytics/pirsch.mdx b/integrations/analytics/pirsch.mdx
index e4b3e3085..8b24375ad 100644
--- a/integrations/analytics/pirsch.mdx
+++ b/integrations/analytics/pirsch.mdx
@@ -2,26 +2,21 @@
title: "Pirsch"
---
-Add the following to your `mint.json` file to send analytics to Pirsch.
+Add Pirsch analytics to your `mint.json`:
-You can get your site ID from Settings \> Developer \> Identification Code.
-
-
-
-```json Analytics options in mint.json
+```json
"analytics": {
"pirsch": {
- "id": "required"
+ "id": "required" // Get from Settings > Developer > Identification Code
}
}
```
-```json Example
+Example:
+```json
"analytics": {
"pirsch": {
"id": "8Kw7OKxBfswOjnKGZa7P9Day8JmVYwTp"
}
}
-```
-
-
+```
\ No newline at end of file
diff --git a/integrations/analytics/segment.mdx b/integrations/analytics/segment.mdx
index 1f1b8076b..a296a3d2f 100644
--- a/integrations/analytics/segment.mdx
+++ b/integrations/analytics/segment.mdx
@@ -2,7 +2,7 @@
title: "Segment"
---
-Add your Segment write key to your `mint.json` file to send analytics to Segment.
+Add your Segment write key in `mint.json`:
diff --git a/integrations/privacy/osano.mdx b/integrations/privacy/osano.mdx
index ded3d2d59..fc1044d35 100644
--- a/integrations/privacy/osano.mdx
+++ b/integrations/privacy/osano.mdx
@@ -2,7 +2,7 @@
title: "Osano"
---
-Add the following to your `mint.json` file to add the [Osano](https://www.osano.com/) cookie consent manager.
+To integrate the [Osano](https://www.osano.com/) cookie consent manager, add this to your `mint.json`:
@@ -20,7 +20,7 @@ Add the following to your `mint.json` file to add the [Osano](https://www.osano.
-The `SOURCE` can be found as the `src` value in the code snippet generated by Osano. It always starts with `https://cmp.osano.com/`.
+Get the `SOURCE` from Osano's generated code snippet - it's the `src` URL that starts with `https://cmp.osano.com/`.
```html Code snippet from Osano
diff --git a/integrations/sdks/speakeasy.mdx b/integrations/sdks/speakeasy.mdx
index d45628bed..cb02d8caa 100644
--- a/integrations/sdks/speakeasy.mdx
+++ b/integrations/sdks/speakeasy.mdx
@@ -3,11 +3,11 @@ title: Speakeasy
description: Automate your SDK usage snippets in the API playground
---
-You can integrate Speakeasy-generated code snippets from your SDKs directly into your Mintlify API reference documentation. SDK usage snippets are shown in the [interactive playground](https://mintlify.com/docs/api-playground/overview) of your Mintlify-powered documentation.
+Speakeasy-generated code snippets from your SDKs can be integrated directly into your Mintlify API reference docs. These snippets appear in the [interactive playground](https://mintlify.com/docs/api-playground/overview).
-## Speakeasy SDK Repository Changes
+## SDK Repository Setup
-In your Speakeasy SDK repos, add the following to the `targets` section of your `.speakeasy/workflow.yaml` file to ensure code samples are automatically produced alongside SDK generations.
+Add this to your `.speakeasy/workflow.yaml` file's `targets` section:
```yaml .speakeasy/workflow.yaml
targets:
@@ -18,46 +18,32 @@ targets:
output: codeSamples.yaml
```
-Code samples will be generated in the form of an [OpenAPI overlay file](https://www.speakeasyapi.dev/openapi/overlays) that will be used in the Mintlify docs repository.
+## Docs Repository Setup
-## Mintlify Docs Repository Changes
-
-The workflow files produced will automatically bundle your source OpenAPI spec and Speakeasy code samples into a single output file, `openapi.yaml`. Mintlify will use this output file when constructing your API reference.
-
-### Interactive CLI Set Up
-
-Run the following commands to set up the `.speakeasy/workflow.yaml` and `.github/workflows/sdk_generation.yaml` files through the interactive Speakeasy CLI.
+### Option 1: CLI Setup (Recommended)
+1. Run these commands:
```bash
speakeasy configure sources
speakeasy configure github
```
-Set up your source spec. The source spec is the OpenAPI spec that code samples will be generated for, and it's often the same specification used to power Mintlify docs.
-
-
-
-Add the overlay created by Speakeasy to inject code snippets into your spec.
-
-
+2. Follow the prompts to:
+ - Set up your source OpenAPI spec
+ - Add the code snippet overlay
+ - Set the output spec path
-Provide a name and path for the OpenAPI spec. This will be the final spec used by Mintlify.
+3. Add your `SPEAKEASY_API_KEY` to repository secrets under `Settings > Secrets & Variables > Actions`
-
+### Option 2: Manual Setup
-Finally, Add your `SPEAKEASY_API_KEY` as a repository secret to your Minlify repo under `Settings > Secrets & Variables > Actions`. Find the Speakeasy API key in the Speakeasy dashboard under the **API Keys** tab.
-
-## Manual Set Up
-
-Alternatively, you can manually set up the following files in your Mintlify docs repo.
-
-
-```yaml .speakeasy/workflow.yaml
+1. Create `.speakeasy/workflow.yaml`:
+```yaml
workflowVersion: 1.0.0
sources:
docs-source:
inputs:
- - location: {{your_api_spec}} # local or remote references supported
+ - location: {{your_api_spec}}
overlays:
- location: https://raw.githubusercontent.com/{{your_sdk_repo_1}}/codeSamples.yaml
- location: https://raw.githubusercontent.com/{{your_sdk_repo_2}}/codeSamples.yaml
@@ -66,7 +52,8 @@ sources:
targets: {}
```
-```yaml .speakeasy/workflows/sdk_generation.yaml
+2. Create `.speakeasy/workflows/sdk_generation.yaml`:
+```yaml
name: Generate
permissions:
checks: write
@@ -94,4 +81,4 @@ jobs:
speakeasy_api_key: ${{ secrets.SPEAKEASY_API_KEY }}
```
-Finally, make sure you add your `SPEAKEASY_API_KEY` as a repository secret to your Minlify repo under `Settings > Secrets & Variables > Actions`. Find the Speakeasy API key in the Speakeasy dashboard under the **API Keys** tab.
+3. Add `SPEAKEASY_API_KEY` to repository secrets
\ No newline at end of file
diff --git a/integrations/sdks/stainless.mdx b/integrations/sdks/stainless.mdx
index 8a21bfab4..83fa54dcd 100644
--- a/integrations/sdks/stainless.mdx
+++ b/integrations/sdks/stainless.mdx
@@ -3,18 +3,17 @@ title: Stainless
description: Automate your SDK example snippets in the API playground
---
-If you use Mintlify's OpenAPI support for your API reference documentation, add the following to your Stainless config:
+Add this to your Stainless config to enable Mintlify's OpenAPI support:
```yaml openapi.stainless.yml
openapi:
code_samples: mintlify
```
-Configure the [OpenAPI setup](/api-playground/openapi/setup#in-the-repo) in your Mintlify docs. To integrate Stainless, modify the GitHub Action that uploads your OpenAPI spec to Stainless so that it pushes the Stainless-enhanced OpenAPI spec into your docs repo like so:
-
+Set up your [OpenAPI configuration](/api-playground/openapi/setup#in-the-repo) in Mintlify, then use this GitHub Action to sync your Stainless-enhanced OpenAPI spec to your docs repo:
```yaml
-name: Upload OpenAPI spec to Stainless and (Mintlify) docs repo
+name: Upload OpenAPI spec to Stainless and docs repo
on:
push:
@@ -40,13 +39,12 @@ jobs:
with:
source_file: 'config/my-company-openapi.documented.json'
destination_repo: '{DOCS_REPO_NAME}'
- destination_folder: 'openapi-specs' # (optional) the folder in the destination repository to place the file in, if not the root directory
- user_email: '{EMAIL}' # the email associated with the GH token
- user_name: '{USERNAME}' # the username associated with the GH token
+ destination_folder: 'openapi-specs'
+ user_email: '{EMAIL}'
+ user_name: '{USERNAME}'
commit_message: 'Auto-updates from Stainless'
```
-This assumes the following secrets have been [uploaded to your GitHub Actions Secrets](https://docs.github.com/en/actions/security-guides/using-secrets-in-github-actions):
-
-- `secrets.STAINLESS_API_KEY`: Your Stainless API key.
-- `secrets.API_TOKEN_GITHUB`: A GitHub [Personal Access Token](https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens) with permissions to push to your docs repo.
+Required GitHub Secrets:
+- `STAINLESS_API_KEY`: Your Stainless API key
+- `API_TOKEN_GITHUB`: GitHub [Personal Access Token](https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens) with docs repo push access
\ No newline at end of file
diff --git a/integrations/support/intercom.mdx b/integrations/support/intercom.mdx
index 412c371c2..1e5ad4ddd 100644
--- a/integrations/support/intercom.mdx
+++ b/integrations/support/intercom.mdx
@@ -2,7 +2,7 @@
title: "Intercom"
---
-Add the following to your `mint.json` file to add an [Intercom](https://www.intercom.com) widget.
+To enable Intercom, add your APP_ID to `mint.json`:
@@ -19,3 +19,4 @@ Add the following to your `mint.json` file to add an [Intercom](https://www.inte
```
+
\ No newline at end of file
diff --git a/quickstart.mdx b/quickstart.mdx
index 60ebbc253..e903d87e7 100644
--- a/quickstart.mdx
+++ b/quickstart.mdx
@@ -1,6 +1,6 @@
---
title: "Quickstart"
-description: "Start building modern documentation in under five minutes"
+description: "Deploy your docs in under 5 minutes"
icon: "rocket"
---
@@ -15,70 +15,52 @@ icon: "rocket"
/>
-## Getting Started
+## Setup
-Welcome! Follow the instructions below to learn how to deploy, update and
-supercharge your documentation with Mintlify.
+Follow these steps to deploy and customize your docs with Mintlify.
-### Creating the Repository
+### Create Your Docs Repo
-Mintlify docs are rendered from MDX files and configurations defined in our
-[starter kit](https://github.com/mintlify/starter). We use GitHub to integrate
-your docs with your code, and make source control effortless.
+Your docs are built from MDX files using our [starter kit](https://github.com/mintlify/starter).
-
+
+ 1. Clone our [starter template](https://github.com/mintlify/starter) into a new public repo
+ 2. Contact [support@mintlify.com](mailto:support@mintlify.com) to deploy
- If you've created a docs repo in our onboarding, this step is complete. You can find your docs repository on your Mintlify [dashboard](https://dashboard.mintlify.com).
-
- To create your docs repo without logging into GitHub, follow these instructions:
- 1. Clone our [starter template](https://github.com/mintlify/starter) into a new public repo. You can make the repo private later.
- 2. [Get in touch](mailto:support@mintlify.com) with our team to deploy your repo.
+ Already created a repo through our onboarding? Find it on your [dashboard](https://dashboard.mintlify.com).

-
-
-
- The next step is to install our GitHub app. This ensures that your updates are automatically deployed when you push changes. You can find the installation link in the [dashboard](https://dashboard.mintlify.com/settings), on the Settings page. Upon successful installation, a check mark will appear next to the commit hash of the repository.
+
+ Install our GitHub app from the [dashboard settings](https://dashboard.mintlify.com/settings) for auto-deployments.

-
-
-### Updating the Content
-
-Mintlify enables you to easily customize the style, structure, and content of
-your docs.
+### Edit Content
-
-
- 1. Install [git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git).
- 2. Once git is installed, clone your docs repository using `git clone `. If you haven't set it up yet, now would be a good time to do so with these [SSH keys](https://docs.github.com/en/authentication/connecting-to-github-with-ssh/generating-a-new-ssh-key-and-adding-it-to-the-ssh-agent).
- 3. Use your favorite IDE to open the repository.
- 4. Install our Mintlify CLI to preview changes with `npm i -g mintlify`.
+
+ 1. Install [git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)
+ 2. Clone your repo: `git clone `
+ 3. Install Mintlify CLI: `npm i -g mintlify`
- Learn more about this in our [local development guide](/development).
-
+ See [local development guide](/development) for more details.
-
-
- Learn more about how to use the web editor on our [guide](/web-editor).
-
+
+ Check our [web editor guide](/web-editor).
-
-
- Easily customize colors, logos and buttons among other configurations in our `mint.json` file. Start with these basic configurations:
+
+ Edit `mint.json` to customize your docs:
```json
"name": "Your Company"
@@ -95,87 +77,60 @@ your docs.
},
```
- A full list of supported configurations can be found at [global settings](/settings/global).
-
+ See [global settings](/settings/global) for all options.
-
-
- Add content with simple MDX files. Initiate your pages with this template:
+
+ Create MDX files with this header:
```md
---
title: "Page Title"
- sidebarTitle: "Sidebar title (optional - if different from page title)"
- description: "Subtitle (optional)"
+ sidebarTitle: "Sidebar title (optional)"
+ description: "Description (optional)"
---
```
- Learn more about adding images, tables, lists, and more using the [MDX syntax](/text). We also offer a [wide array of components](/content/components).
-
+ Learn about [MDX syntax](/text) and [components](/content/components).
-
-
- Once ready, commit and push your changes to update your docs site. Here is a [guide](https://docs.github.com/en/get-started/using-git/pushing-commits-to-a-remote-repository#about-git-push) on how to do that. If the GitHub app is unable to successfully deploy your changes, you can manually update your docs through our [dashboard](https://dashboard.mintlify.com).
+
+ Push changes to deploy automatically. Manual updates available on the [dashboard](https://dashboard.mintlify.com).

-
-
-
- You can easily set up your API references using an OpenAPI document.
-
- 1. Add your `openapi.yaml` or `openapi.json` file into your docs repository or define the `openapi` field in `mint.json` with a URL.
-
+
+ 1. Add OpenAPI spec (`openapi.yaml`/`openapi.json`) or set URL in `mint.json`:
```json
- "openapi": "link-to-your-openapi-file"
+ "openapi": "your-openapi-url"
```
- 2. Use our [scraper](/api-playground/openapi/setup#autogenerate-files-recommended) to autogenerate your OpenAPI endpoints files as:
-
+ 2. Generate endpoint files:
```bash
npx @mintlify/scraping@latest openapi-file
```
- 3. Finally, include the generated endpoint MDX files to your `mint.json` under `navigation`.
-
- For a complete guide on using Mintlify with OpenAPI, check out [this guide](/api-playground/openapi/setup). [This guide](/api-playground/openapi/writing-openapi) explains how to configure your API authentication methods. For manual API references definition, explore [our syntax](/api-playground/overview).
+ 3. Add generated files to `mint.json` navigation
+ See guides for [OpenAPI setup](/api-playground/openapi/setup) and [auth methods](/api-playground/openapi/writing-openapi).
-
-
- Our in-house analytics give you insights into page views, search analytics, session recordings and more. Access these on your [dashboard](https://dashboard.mintlify.com/analytics).
-
- We also support integrations with a range of analytics providers. You can find the list of providers [here](/integrations/analytics/overview).
-
+
+ Access built-in analytics on your [dashboard](https://dashboard.mintlify.com/analytics) or add third-party [integrations](/integrations/analytics/overview).
-
- We provide a white-glove migration service as part of our Enterprise plan.
- Interested? You can request it by [contacting us](mailto:sales@mintlify.com).
-
+### Launch
-### Publishing
-
-
-
- Integrate your docs into your website by hosting them on a custom domain. This is included even in the free plan.
-
- Navigate to your [dashboard settings](https://dashboard.mintlify.com/settings) to add a custom domain.
+
+ Set up your domain in [dashboard settings](https://dashboard.mintlify.com/settings).

-
-Congrats! You've set up your Mintlify Docs and it's looking amazing! Need
-support or want to give some feedback? You can join our
-[community](https://mintlify.com/community) or drop us an email at
-[support@mintlify.com](mailto:support@mintlify.com).
+Need help? Join our [community](https://mintlify.com/community) or email [support@mintlify.com](mailto:support@mintlify.com).
\ No newline at end of file
diff --git a/settings/authentication-personalization/authentication-setup/jwt.mdx b/settings/authentication-personalization/authentication-setup/jwt.mdx
index d35fd7e3a..baad2b0de 100644
--- a/settings/authentication-personalization/authentication-setup/jwt.mdx
+++ b/settings/authentication-personalization/authentication-setup/jwt.mdx
@@ -4,45 +4,32 @@ description: 'Use a customized login flow to authenticate users'
---
- This is the documentation for the JWT **Authentication** Handshake. The steps for setting up the [JWT **Personalization** Handshake](/settings/authentication-personalization/personalization-setup/jwt) are slightly different.
+ This documents the JWT **Authentication** Handshake. For JWT **Personalization** Handshake setup, see [here](/settings/authentication-personalization/personalization-setup/jwt).
-If you don’t have a dashboard, or if you want to keep your dashboard and docs completely separate, you can use your own login flow to authenticate users via a JWT in the URL.
+Use JWT-based authentication to implement custom login flows without a dashboard.
-## Implementation
+## Setup Steps
- Go to your [Mintlify dashboard settings](https://dashboard.mintlify.com/products/authentication) and generate a private key. Store this key somewhere secure where it can be accessed by your backend.
+ Get a private key from your [Mintlify dashboard](https://dashboard.mintlify.com/products/authentication). Store it securely for backend access.
- Create a login flow that does the following:
- - Authenticate the user
- - Create a JWT containing the authenticated user's info in the [User](../sending-data) format
- - Sign the JWT with the secret key, using the EdDSA algorithm
- - Create a redirect URL back to the `/login/jwt-callback` path of your docs, including the JWT as the hash
+ Build a login flow that:
+ - Authenticates users
+ - Creates a JWT with user info in the [User](../sending-data) format
+ - Signs JWT with EdDSA algorithm using your secret key
+ - Redirects to `/login/jwt-callback` with JWT in the hash
-
- Return to your [Mintlify dashboard settings](https://dashboard.mintlify.com/products/authentication) and add the login URL to your Authentication settings.
+
+ Add your login URL in [Mintlify dashboard settings](https://dashboard.mintlify.com/products/authentication).
-## Example
+## Example Implementation
-I want to set up authentication for my docs hosted at `docs.foo.com`. I want my docs
-to be completely separate from my dashboard (or I don’t have a dashboard at all).
-
-To set up authentication with Mintlify, I go to my Mintlify dashboard and generate a
-JWT secret. I create a web URL `https://foo.com/docs-login` that initiates a login flow
-for my users. At the end of this login flow, once I have verified the identity of the user,
-I create a JWT containing the user’s custom data according to Mintlify’s specification.
-I use a JWT library to sign this JWT with my Mintlify secret, create a redirect URL of the
-form `https://docs.foo.com/login/jwt-callback#{SIGNED_JWT}`, and redirect the user.
-
-I then go to the Mintlify dashboard settings and enter `https://foo.com/docs-login` for the
-Login URL field.
-
-Here's what the code might look like:
+For docs hosted at `docs.foo.com`, create a login endpoint at `https://foo.com/docs-login`. After user verification, generate a signed JWT and redirect to `https://docs.foo.com/login/jwt-callback#{SIGNED_JWT}`.
```ts TypeScript
@@ -99,4 +86,4 @@ async def return_mintlify_auth_status(current_user):
return RedirectResponse(url=f'https://docs.foo.com/login/jwt-callback#{jwt_token}', status_code=302)
```
-
+
\ No newline at end of file
diff --git a/settings/authentication-personalization/authentication-setup/mintlify.mdx b/settings/authentication-personalization/authentication-setup/mintlify.mdx
index 9839bdc17..eeff23903 100644
--- a/settings/authentication-personalization/authentication-setup/mintlify.mdx
+++ b/settings/authentication-personalization/authentication-setup/mintlify.mdx
@@ -4,43 +4,33 @@ description: "Use Mintlify to authenticate users"
---
- The Mintlify Auth Handshake is available only for Authentication, *not*
- Personalization.
+ Mintlify Auth Handshake is for Authentication only, not Personalization.
-You can use Mintlify to authenticate and manage access to your documentation. Anyone that can access your dashboard will automatically be able to see your documentation.
+Mintlify handles authentication for your documentation. Users with dashboard access can automatically view your docs.
-This handshake method also enables private preview deployments, so that only Mintlify authenticated users will be able to access your preview deployments.
+This method also secures preview deployments - only authenticated Mintlify users can access them.
- Authentication is available only by request. Please{" "}
- contact sales for access. After we've
- enabled access, you can follow the implementation instructions.
+ Authentication requires approval. Contact sales for access.
### Example
-I want to set up authentication for my docs hosted at `docs.foo.com`. I want my docs
-to be internal, and the people that will be viewing my docs are the same people that
-contribute to my docs.
+Let's say you want to restrict `docs.foo.com` to internal team members who also maintain the docs.
-To set up authentication with Mintlify, I can go to my [Mintlify dashboard settings](https://dashboard.mintlify.com/products/authentication)
-and enable Authentication with the Mintlify Auth Handshake.
+Just enable Authentication with Mintlify Auth Handshake in your [dashboard settings](https://dashboard.mintlify.com/products/authentication),
+then add your team members through the [organization settings](https://dashboard.mintlify.com/settings/organization/members).
-I can then ensure that anyone that should be able to read the docs has been added as a user in
-my [Mintlify dashboard settings](https://dashboard.mintlify.com/settings/organization/members).
-
-## Implementation
+## Setup Steps
-
- Go to your [Mintlify dashboard
- settings](https://dashboard.mintlify.com/products/authentication) and select
- the Mintlify Auth Handshake.
+
+ Go to [Authentication settings](https://dashboard.mintlify.com/products/authentication) and select Mintlify Auth Handshake.
- Ensure that any users that should be able to view your documentation have
- been added as users in your [Mintlify dashboard
- settings](https://dashboard.mintlify.com/settings/organization/members).
+ Add team members through [organization settings](https://dashboard.mintlify.com/settings/organization/members).
+
+
\ No newline at end of file
diff --git a/settings/authentication-personalization/authentication-setup/oauth.mdx b/settings/authentication-personalization/authentication-setup/oauth.mdx
index 45206968c..20ffd45fb 100644
--- a/settings/authentication-personalization/authentication-setup/oauth.mdx
+++ b/settings/authentication-personalization/authentication-setup/oauth.mdx
@@ -1,49 +1,46 @@
---
title: 'OAuth 2.0 Handshake'
-description: 'Integrate with your OAuth server to enable user login via the Authorization Code flow'
+description: 'Set up OAuth Authorization Code flow for user login'
---
- This is the documentation for the OAuth **Authentication** Handshake. The steps for setting up the [OAuth **Personalization** Handshake](/settings/authentication-personalization/personalization-setup/oauth) are slightly different.
+ This guide covers OAuth **Authentication** Handshake setup. For **Personalization** Handshake setup, see [here](/settings/authentication-personalization/personalization-setup/oauth).
-If you have an existing OAuth server, you can integrate with Mintlify for a seamless login experience.
-
-## Implementation
+## Setup Steps
-
- Go to your [Mintlify authentication settings](https://dashboard.mintlify.com/products/authentication), select the OAuth option, and fill out the required fields:
-
- - **Authorization URL**: The base URL for the authorization request, to which we will add the appropriate query parameters.
- - **Client ID**: An ID for the OAuth 2.0 client to be used.
- - **Scopes**: An array of scopes that will be requested.
- - **Token URL**: The base URL for the token exchange request.
- - **Info API URL** (optional): The endpoint that will be hit to retrieve user info. If omitted, the OAuth flow will only be used to verify identity, and the user info will be empty.
+
+ Head to [Mintlify authentication settings](https://dashboard.mintlify.com/products/authentication) and configure OAuth:
+
+ - **Authorization URL**: Base authorization request URL
+ - **Client ID**: Your OAuth 2.0 client ID
+ - **Scopes**: Required OAuth scopes
+ - **Token URL**: Token exchange URL
+ - **Info API URL** (optional): Endpoint for user info retrieval
-
- Copy the Redirect URL listed in the [Mintlify authentication settings](https://dashboard.mintlify.com/products/authentication) and add it as an authorized redirect URL for your OAuth server.
+
+ Copy the Redirect URL from your [authentication settings](https://dashboard.mintlify.com/products/authentication) and add it to your OAuth server's authorized redirects.
-
- If you want to take advantage of authentication's customization features, you'll need to create an endpoint to retrieve info about your users.
- Create an API endpoint that can be accessed with an OAuth access token, and responds with a JSON payload following the [User](../sending-data) format.
-
- Return to your [Mintlify authentication settings](https://dashboard.mintlify.com/products/authentication) and add the Info API URL
- to your OAuth configuration.
+
+ For authentication customization, create an endpoint that:
+ - Accepts an OAuth access token
+ - Returns user data in [User](../sending-data) format
+ - Add this endpoint URL to your OAuth config as Info API URL
## Example
-I have an existing OAuth server that supports the Authorization Code flow. I want to set up authentication for my docs hosted at `foo.com/docs`.
-
-To set up authentication with Mintlify, I create an endpoint `api.foo.com/docs/user-info` which requires an OAuth access token with the `docs-user-info` scope, and responds with the user's custom data according to Mintlify’s specification.
-
-I then go to the Mintlify dashboard settings, navigate to the Authentication settings, select OAuth, and enter the relevant values for the OAuth flow and Info API endpoint:
-- **Authorization URL**: `https://auth.foo.com/authorization`
-- **Client ID**: `ydybo4SD8PR73vzWWd6S0ObH`
-- **Scopes**: `['docs-user-info']`
-- **Token URL**: `https://auth.foo.com/exchange`
-- **Info API URL**: `https://api.foo.com/docs/user-info`
-
-Finally, I copy the Redirect URL displayed in the dashboard settings and add it as an authorized redirect URL in my OAuth client configuration settings.
+Using an OAuth server for docs at `foo.com/docs`:
+
+1. Create endpoint `api.foo.com/docs/user-info` that requires `docs-user-info` scope
+2. Configure OAuth in Mintlify dashboard:
+```
+Authorization URL: https://auth.foo.com/authorization
+Client ID: ydybo4SD8PR73vzWWd6S0ObH
+Scopes: ['docs-user-info']
+Token URL: https://auth.foo.com/exchange
+Info API URL: https://api.foo.com/docs/user-info
+```
+3. Add the Redirect URL to your OAuth client config
\ No newline at end of file
diff --git a/settings/authentication-personalization/personalization-setup/choosing-a-handshake.mdx b/settings/authentication-personalization/personalization-setup/choosing-a-handshake.mdx
index 9c7823cc3..6ccb2147f 100644
--- a/settings/authentication-personalization/personalization-setup/choosing-a-handshake.mdx
+++ b/settings/authentication-personalization/personalization-setup/choosing-a-handshake.mdx
@@ -1,85 +1,70 @@
---
title: 'Choosing a Handshake'
-description: 'How to decide which Handshake method is right for your docs'
+description: 'Select the right Handshake method for your docs'
---
- This is the documentation for **Personalization** Handshake methods. Authentication offers a [different set of Handshake methods](/settings/authentication-personalization/authentication-setup/choosing-a-handshake).
+ This guide covers **Personalization** Handshake methods. For authentication, see [Authentication Handshake methods](/settings/authentication-personalization/authentication-setup/choosing-a-handshake).
-Before your users can access personalized content, they must be authenticated. Mintlify supports three Personalization Handshake methods:
+Users need to be authenticated to access personalized content. Choose from three methods:
-1. **Shared Session**: Utilize the same session token used by your dashboard to authenticate users.
-2. **JWT**: Use your own login flow to send user info to your docs via a JWT in the URL.
-3. **OAuth 2.0**: Integrate with your OAuth server to enable user login via the PKCE flow.
+1. **Shared Session**: Use your dashboard's session token
+2. **JWT**: Pass user info via JWT in the URL
+3. **OAuth 2.0**: Use PKCE flow with your OAuth server
## Prerequisites
-
- - You have a dashboard or other user portal hosted at your domain.
- - Your users' session credentials are stored as cookies.
- - You can create a new API endpoint at the same origin or a subdomain of your dashboard.
- - If your dashboard is at `foo.com`, the **API URL** must start with `foo.com` or `*.foo.com`
- - If your dashboard is at `dash.foo.com`, the **API URL** must start with `dash.foo.com` or `*.dash.foo.com`
- - Your docs are hosted at the same domain as your dashboard.
- - If your dashboard is at `foo.com`, your **docs** must be hosted at `foo.com` or `*.foo.com`
- - If your dashboard is at `*.foo.com`, your **docs** must be hosted at `foo.com` or `*.foo.com`
+ - Dashboard hosted at your domain
+ - Session stored in cookies
+ - API endpoint at same origin/subdomain as dashboard
+ - Docs hosted at same domain as dashboard
+
+ Example domains:
+ - Dashboard at `foo.com`: API must be `foo.com` or `*.foo.com`
+ - Dashboard at `dash.foo.com`: API must be `dash.foo.com` or `*.dash.foo.com`
-
- - You have some existing login flow.
- - You can add a final step in this login flow that creates a JWT and redirects to the docs.
+ - Existing login flow
+ - Ability to create JWT and redirect to docs
-
- - You have an existing OAuth server that supports the PKCE flow.
- - You can create a new API endpoint that can be accessed by the returned OAuth access token.
+ - OAuth server with PKCE support
+ - API endpoint accessible via OAuth token
-## Pros & Cons
+## Comparison
- Pros:
-
- - Users that are logged into your dashboard are automatically logged into your docs
- - Your users' sessions are persistent, meaning you can refresh data without requiring additional login
- - Minimal setup required
-
- Cons:
-
- - Your docs will make a request to your backend, which may be undesirable
- - You must have a dashboard that uses session authentication
- - CORS configuration is usually required
+ ✅ Auto-login if user is in dashboard
+ ✅ Persistent sessions
+ ✅ Simple setup
+
+ ❌ Requires backend request
+ ❌ Needs dashboard with session auth
+ ❌ Requires CORS setup
- Pros:
-
- - Reduced risk of API endpoint abuse
- - Zero CORS configuration
- - No restrictions on API URLs
-
- Cons:
-
- - Must be able to hook into your existing login flow
- - Dashboard sessions and docs authentication are completely decoupled, so users will need to log in to your dashboard and your docs separately
- - Every time you want to refresh user data, your users must re-login to your docs
- - If your users' data changes frequently, you must require your users to log in frequently or risk having stale data in the docs
- - If your users' data rarely changes, this shouldn't be a problem
+ ✅ Lower API abuse risk
+ ✅ No CORS needed
+ ✅ Flexible API URLs
+
+ ❌ Must modify login flow
+ ❌ Separate login for dashboard and docs
+ ❌ Requires re-login for data updates
- Pros:
-
- - Heightened security standard
- - No restrictions on API URLs
-
- Cons:
-
- - Requires significant work if setting up OAuth server for the first time
- - Dashboard sessions and docs authentication are completely decoupled, so users will need to log in to your dashboard and your docs separately
- - Might be overkill for some applications
+ ✅ High security
+ ✅ Flexible API URLs
+
+ ❌ Complex OAuth setup
+ ❌ Separate login for dashboard and docs
+ ❌ May be excessive for simple needs
+
+
\ No newline at end of file
diff --git a/settings/authentication-personalization/personalization-setup/oauth.mdx b/settings/authentication-personalization/personalization-setup/oauth.mdx
index d786a042f..c76ef0418 100644
--- a/settings/authentication-personalization/personalization-setup/oauth.mdx
+++ b/settings/authentication-personalization/personalization-setup/oauth.mdx
@@ -1,45 +1,49 @@
---
title: 'OAuth 2.0 Handshake'
-description: 'Integrate with your OAuth server to enable user login via the PKCE flow'
+description: 'Set up user login via PKCE flow'
---
- This is the documentation for the OAuth **Personalization** Handshake. The steps for setting up the [OAuth **Authentication** Handshake](/settings/authentication-personalization/authentication-setup/oauth) are slightly different.
+ This guide covers OAuth **Personalization** Handshake. For **Authentication** Handshake setup, see [here](/settings/authentication-personalization/authentication-setup/oauth).
-If you have an existing OAuth server that supports the PKCE flow, you can integrate with Mintlify for a seamless login experience.
-
-## Implementation
+## Setup
-
- Create an API endpoint that can be accessed with an OAuth access token, and responds with a JSON payload following the [User](../sending-data) format. Take note of the scope or scopes required to access this endpoint.
+
+ Build an API endpoint that:
+ - Accepts OAuth access token
+ - Returns JSON in [User](../sending-data) format
+ - Note the required scopes
-
- Go to your [Mintlify dashboard settings](https://dashboard.mintlify.com/products/authentication), select the OAuth option, and fill out the required fields:
-
- - **Authorization URL**: The base URL for the authorization request, to which we will add the appropriate query parameters.
- - **Client ID**: An ID for the OAuth 2.0 client to be used.
- - **Scopes**: An array of scopes that will be requested.
- - **Token URL**: The base URL for the token exchange request.
- - **Info API URL**: The endpoint that will be hit to retrieve user info.
+
+ In [Mintlify dashboard](https://dashboard.mintlify.com/products/authentication), select OAuth and configure:
+ - **Authorization URL**: Base URL for auth requests
+ - **Client ID**: OAuth 2.0 client identifier
+ - **Scopes**: Required scope array
+ - **Token URL**: Token exchange URL
+ - **Info API URL**: User info endpoint
-
- Copy the Redirect URL listed in the [Mintlify dashboard settings](https://dashboard.mintlify.com/products/authentication) and add it as an authorized redirect URL for your OAuth server.
+
+ Add the Redirect URL from [dashboard settings](https://dashboard.mintlify.com/products/authentication) to your OAuth server's allowed redirects.
## Example
-I have an existing OAuth server that supports the PKCE flow. I want to set up authentication for my docs hosted at `foo.com/docs`.
+For docs hosted at `foo.com/docs`:
-To set up authentication with Mintlify, I create an endpoint `api.foo.com/docs/user-info` which requires an OAuth access token with the `docs-user-info` scope, and responds with the user's custom data according to Mintlify’s specification.
+1. Create endpoint `api.foo.com/docs/user-info`:
+ - Requires: OAuth token with `docs-user-info` scope
+ - Returns: User data per Mintlify spec
-I then go to the Mintlify dashboard settings, navigate to the Personalization settings, select OAuth, and enter the relevant values for the OAuth flow and Info API endpoint:
-- **Authorization URL**: `https://auth.foo.com/authorization`
-- **Client ID**: `ydybo4SD8PR73vzWWd6S0ObH`
-- **Scopes**: `['docs-user-info']`
-- **Token URL**: `https://auth.foo.com/exchange`
-- **Info API URL**: `https://api.foo.com/docs/user-info`
+2. Configure OAuth in dashboard:
+```
+Authorization URL: https://auth.foo.com/authorization
+Client ID: ydybo4SD8PR73vzWWd6S0ObH
+Scopes: ['docs-user-info']
+Token URL: https://auth.foo.com/exchange
+Info API URL: https://api.foo.com/docs/user-info
+```
-Finally, I copy the Redirect URL displayed in the dashboard settings and add it as an authorized redirect URL in my OAuth client configuration settings.
+3. Add dashboard's Redirect URL to OAuth client config
\ No newline at end of file
diff --git a/settings/authentication-personalization/personalization-setup/shared-session.mdx b/settings/authentication-personalization/personalization-setup/shared-session.mdx
index 5066952c1..bd252dfb0 100644
--- a/settings/authentication-personalization/personalization-setup/shared-session.mdx
+++ b/settings/authentication-personalization/personalization-setup/shared-session.mdx
@@ -1,54 +1,50 @@
---
title: 'Shared Session Handshake'
-description: 'Seamlessly share user sessions between your dashboard and your docs'
+description: 'Share user sessions between your dashboard and docs'
---
- This is the documentation for the Shared Session **Personalization** Handshake. The Shared Session Handshake is not available for Authentication.
+ This feature is only available for Personalization, not Authentication.
-This method utilizes the session authentication info already stored in your user’s browser to create a seamless documentation experience.
+Uses existing session authentication in the user's browser to personalize docs.
## Implementation
- Create an API endpoint that uses session authentication to identify users, and responds with a JSON payload following the [User](../sending-data) format.
+ Create an API endpoint that uses session auth to identify users and returns JSON in the [User](../sending-data) format.
- If the API domain does not *exactly match* the docs domain:
- - Add the docs domain to your API's `Access-Control-Allow-Origin` header (must not be `*`)
- - Ensure your API’s `Access-Control-Allow-Credentials` header is `true`
+ If your API domain differs from docs domain:
+ - Add docs domain to `Access-Control-Allow-Origin` header (not `*`)
+ - Set `Access-Control-Allow-Credentials: true`
- These CORS options only need to be enabled on the *single endpoint* responsible for returning user information. We do not recommend enabling these options on all dashboard endpoints.
+ Only enable these CORS settings on the user info endpoint.
-
- Go to your [Mintlify dashboard settings](https://dashboard.mintlify.com/products/authentication) and add the API URL and your Login URL to your Personalization settings.
+
+ Add your API URL and Login URL in your [Mintlify dashboard settings](https://dashboard.mintlify.com/products/authentication).
## Examples
-### Dashboard at subdomain, docs at subdomain
+### Dashboard and docs on subdomains
-I have a dashboard at `dash.foo.com`, which uses cookie-based session authentication. My dashboard API routes are hosted at `dash.foo.com/api`. I want to set up authentication for my docs hosted at `docs.foo.com`.
+**Setup:** Dashboard on `dash.foo.com`, docs on `docs.foo.com`
+1. Create endpoint: `dash.foo.com/api/docs/user-info`
+2. Enable CORS for `https://docs.foo.com`
+3. Set API URL in Mintlify dashboard
-To set up authentication with Mintlify, I create another dashboard endpoint `dash.foo.com/api/docs/user-info` which identifies the user using session auth, and responds with their custom data according to Mintlify’s specification. I then add `https://docs.foo.com` to the `Access-Control-Allow-Origin` allow-list **for this route only**, and ensure my `Access-Control-Allow-Credentials` configuration is set to `true` **for this route only**.
+### Dashboard on subdomain, docs on root
-I then go to the Mintlify dashboard settings and enter `https://dash.foo.com/api/docs/user-info` for the API URL field.
+**Setup:** Dashboard on `dash.foo.com`, docs on `foo.com/docs`
+1. Create endpoint: `dash.foo.com/api/docs/user-info`
+2. Enable CORS for `https://foo.com`
+3. Set API URL in Mintlify dashboard
-### Dashboard at subdomain, docs at root
+### Both on root domain
-I have a dashboard at `dash.foo.com`, which uses cookie-based session authentication. My dashboard API routes are hosted at `dash.foo.com/api`. I want to set up authentication for my docs hosted at `foo.com/docs`.
-
-To set up authentication with Mintlify, I create another dashboard endpoint `dash.foo.com/api/docs/user-info` which identifies the user using session auth, and responds with their custom data according to Mintlify’s specification. I then add `https://foo.com` to the `Access-Control-Allow-Origin` allow-list **for this route only**, and ensure my `Access-Control-Allow-Credentials` configuration is set to `true` **for this route only**.
-
-I then go to the Mintlify dashboard settings and enter `https://dash.foo.com/api/docs/user-info` for the API URL field.
-
-### Dashboard at root, docs at root
-
-I have a dashboard at `foo.com/dashboard`, which uses cookie-based session authentication. My dashboard API routes are hosted at `foo.com/api`. I want to set up authentication for my docs hosted at `foo.com/docs`.
-
-To set up authentication with Mintlify, I create another dashboard endpoint `foo.com/api/docs/user-info` which identifies the user using session auth, and responds with their custom data according to Mintlify’s specification.
-
-I then go to the Mintlify dashboard settings and enter `https://foo.com/api/docs/user-info` for the API URL field.
\ No newline at end of file
+**Setup:** Dashboard on `foo.com/dashboard`, docs on `foo.com/docs`
+1. Create endpoint: `foo.com/api/docs/user-info`
+2. Set API URL in Mintlify dashboard
\ No newline at end of file
diff --git a/settings/authentication.mdx b/settings/authentication.mdx
index 35bb3eddc..2b3755fe3 100644
--- a/settings/authentication.mdx
+++ b/settings/authentication.mdx
@@ -1,14 +1,13 @@
---
title: "Single Sign-On (SSO)"
-description: "Customize how your team can login to your Mintlify dashboard"
+description: "Set up SSO for your Mintlify dashboard"
icon: 'user-unlock'
---
-Mintlify supports single sign-on to your dashboard via SAML and OIDC. If you use Okta or Google Workspace, we have provider-specific documentation for setting up SSO, but if you use another provider, please contact us!
+Mintlify supports SAML and OIDC for SSO integration. We have specific guides for Okta and Google Workspace below.
- SSO functionality is available on our Enterprise plan. [Contact
- us](https://mintlify.com/enterprise) to learn more!
+ SSO requires Enterprise plan. [Contact us](https://mintlify.com/enterprise)
## Okta
@@ -16,38 +15,38 @@ Mintlify supports single sign-on to your dashboard via SAML and OIDC. If you use
-
- Under `Applications`, click to create a new app integration using SAML 2.0.
+
+ Go to `Applications` → Create new app integration → SAML 2.0
-
- Enter the following:
- * Single sign-on URL (provided by Mintlify)
- * Audience URI (provided by Mintlify)
+
+ Configure these settings:
+ * Single sign-on URL: (from Mintlify)
+ * Audience URI: (from Mintlify)
* Name ID Format: `EmailAddress`
- * Attribute Statements:
- | Name | Name format | Value
- | ---- | ----------- | -----
+ * Attributes:
+ | Name | Format | Value
+ | ---- | ------ | -----
| `firstName` | Basic | `user.firstName` |
| `lastName` | Basic | `user.lastName` |
-
- Once the application is set up, navigate to the sign-on tab and send us the metadata URL.
- We'll enable the connection from our side using this information.
+
+ Send us your metadata URL from the sign-on tab
-
- Under `Applications`, click to create a new app integration using OIDC.
- You should choose the `Web Application` application type.
+
+ Go to `Applications` → Create new app integration → OIDC → Web Application
-
- Select the authorization code grant type and enter the Redirect URI provided by Mintlify.
+
+ Enable authorization code grant type and add Mintlify's Redirect URI
-
- Once the application is set up, navigate to the General tab and locate the client ID & client secret.
- Please securely provide us with these, along with your Okta instance URL (e.g. `.okta.com`). You can send these via a service like 1Password or SendSafely.
+
+ Send us securely:
+ - Client ID
+ - Client secret
+ - Okta instance URL (`.okta.com`)
@@ -58,22 +57,25 @@ Mintlify supports single sign-on to your dashboard via SAML and OIDC. If you use
-
- Under `Web and mobile apps`, select `Add custom SAML app` from the `Add app` dropdown.
+
+ Go to `Web and mobile apps` → `Add app` → `Add custom SAML app`

-
- Copy the provided SSO URL, Entity ID, and x509 certificate and send it to the Mintlify team.
+
+ Send us:
+ - SSO URL
+ - Entity ID
+ - x509 certificate

-
- On the Service provider details page, enter the following:
- * ACS URL (provided by Mintlify)
- * Entity ID (provided by Mintlify)
+
+ Service provider settings:
+ * ACS URL: (from Mintlify)
+ * Entity ID: (from Mintlify)
* Name ID format: `EMAIL`
* Name ID: `Basic Information > Primary email`
@@ -81,15 +83,14 @@ Mintlify supports single sign-on to your dashboard via SAML and OIDC. If you use

- On the next page, enter the following attribute statements:
- | Google Directory Attribute | App Attribute |
- | -------------------------- | ------------- |
+ Attribute mapping:
+ | Google Directory | App Attribute |
+ | ---------------- | ------------- |
| `First name` | `firstName` |
| `Last name` | `lastName` |
- Once this step is complete and users are assigned to the application, let our team know and we'll enable SSO for your account!
+ After assigning users, notify us to enable SSO.
-
-
+
\ No newline at end of file