diff --git a/advanced/rest-api/overview.mdx b/advanced/rest-api/overview.mdx
index f9d74b067..cfe35cbc5 100644
--- a/advanced/rest-api/overview.mdx
+++ b/advanced/rest-api/overview.mdx
@@ -2,31 +2,28 @@
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)!
-
## 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 an API key through [the dashboard](https://dashboard.mintlify.com/settings/integrations). This key works across all deployments within your organization.
+## Trigger Updates
+
+Use our REST API to programmatically trigger documentation updates. Additional API functionality will be added based on user feedback. Share your suggestions in [our community](https://mintlify.com/community).
+
## 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 enables AI-powered chat experiences within your documentation. Key features:
+- Embedded chat interface for any application
+- Responses include citations to source documentation
+- Automatically stays synchronized with your content
-## Getting Started
+### Setup
-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.
+ The Discovery API token is public and safe for frontend code. Keep the API key secure on your server side.
-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).
+2. See our [example implementation](https://github.com/mintlify/discovery-api-example) or view the [live demo](https://chat.mintlify.com).
\ No newline at end of file
diff --git a/advanced/subpath/cloudflare.mdx b/advanced/subpath/cloudflare.mdx
index 13ff2d841..dc33fea4e 100644
--- a/advanced/subpath/cloudflare.mdx
+++ b/advanced/subpath/cloudflare.mdx
@@ -3,22 +3,20 @@ title: "Cloudflare"
description: "Host documentation at a /docs subpath using Cloudflare Workers"
---
-## Create Cloudflare Worker
+## Quick Setup Guide
-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.
+1. Create a Worker
+ - Go to `Workers & Pages > Create application > Create worker`
+ - Give your worker a name and create it
-### 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.
+2. Add Your Domain
+ - Go to `Settings > Triggers`
+ - Click `Add Custom Domain`
+ - 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.
-
-### Edit Worker Script
-
-Click on `Edit Code` and add the following script into the worker's code.
+3. Add the Worker Script
+ - Click `Edit Code`
+ - Copy the script below
+ - Replace `[SUBDOMAIN]` and `[YOUR_DOMAIN]` with your values
+ - Click `Deploy`
-
- Edit `DOCS_URL` by replacing `[SUBDOMAIN]` with your unique subdomain and
- `CUSTOM_URL` with your website's base URL.
-
-
```javascript
addEventListener("fetch", (event) => {
event.respondWith(handleRequest(event.request));
@@ -52,9 +43,7 @@ addEventListener("fetch", (event) => {
async function handleRequest(request) {
try {
const urlObject = new URL(request.url);
- // If the request is to the docs subdirectory
if (/^\/docs/.test(urlObject.pathname)) {
- // Then Proxy to Mintlify
const DOCS_URL = "[SUBDOMAIN].mintlify.dev";
const CUSTOM_URL = "[YOUR_DOMAIN]";
@@ -70,11 +59,9 @@ async function handleRequest(request) {
return await fetch(proxyRequest);
}
} catch (error) {
- // if no action found, play the regular request
return await fetch(request);
}
}
```
-Click on `Deploy` and wait for the changes to propagate (it can take up to a few
-hours).
+> Note: Changes may take a few hours to propagate. Need help? [Contact our support team](mailto:sales@mintlify.com).
\ No newline at end of file
diff --git a/advanced/widget/chat.mdx b/advanced/widget/chat.mdx
index 5c1fc4756..3397d3835 100644
--- a/advanced/widget/chat.mdx
+++ b/advanced/widget/chat.mdx
@@ -9,15 +9,12 @@ description: "Integrate the Mintlify widget into your products to offer users qu
## Getting started
-First, generate an API key in [the Mintlify dashboard](https://dashboard.mintlify.com/chat/widget-auth).
+1. Generate an API key in [the Mintlify dashboard](https://dashboard.mintlify.com/chat/widget-auth).
-
- 
-
+2. Add the widget to your site:
-## Installation
-
-Add the widget by adding these script tags into your site's `
...
` tag.
+### HTML Installation
+Add these scripts to your site's `
` tag:
```html
```
-To use the widget in React and Next.js apps, use the React component from the `@mintlify/widget-react` [package](https://www.npmjs.com/package/@mintlify/widget-react). Here is a basic example of how to use the component in your React application:
+### React Installation
+For React and Next.js apps, use our React component:
```jsx
```
-## Usage
-
-In the first script tag or the React component props, you can customize the appearance and other settings of the widget. `mintlifyWidgetSettings` accepts the following props:
-
-| Prop | Type | Description |
-| ------------ | ------------------------------------------------------------------- | ---------------------------------------------------------- |
-| `connection` | [MintlifyWidgetConnectionProps](#mintlifywidgetconnectionProps) | Information needed to connect to our API. Required. |
-| `display?` | [MintlifyWidgetDisplayProps](#mintlifywidgetdisplayProps) | Configurations for the widget appearance and interactions. |
-| `tracking?` | [MintlifyWidgetTrackingFunctions](#mintlifywidgettrackingfunctions) | Callback functions for tracking analytics. |
-
-### MintlifyWidgetConnectionProps
-
-| Prop | Type | Description |
-| -------- | -------- | ----------------------------------------------------------- |
-| `apiKey` | `string` | Widget API key generated from Mintlify dashboard. Required. |
-| `url?` | `string` | Used for internal testing only |
-
-### MintlifyWidgetDisplayProps
-
-| Prop | Type | Description |
-| ------------- | ----------------------------------------------------------------------- | ----------------------------------------------------------- |
-| `trigger?` | [MintlifyWidgetDisplayTriggerProps](#mintlifywidgetdisplaytriggerprops) | Appearance of the trigger. |
-| `colors?` | [MintlifyWidgetDisplayColorsProps](#mintlifywidgetdisplaycolorsprops) | Colors used across the widget. |
-| `chat?` | [MintlifyWidgetDisplayChatProps](#mintlifywidgetdisplaychatprops) | Configs specific to AI chat. |
-| `isDarkMode?` | `boolean` | Controlled dark mode appearance. Defaults to OS preference. |
-
-#### MintlifyWidgetDisplayTriggerProps
-
-| Prop | Type | Description |
-| ------------- | ------------------------------------ | -------------------------------------------------------------------------------------------------------------------------- |
-| `type?` | `'button'`\|`'input'` | Type of the trigger to display. Defaults to `button`. |
-| `label?` | `string` | Label displayed in the trigger. Defaults to `Get help` for the button trigger and `Ask anything...` for the input trigger. |
-| `buttonIcon?` | `'chat'`\|`'sparkles'`\|`'mintlify'` | Icon used in the trigger. Only available for the `button` trigger. Defaults to `chat`. |
-| `iconOnly?` | `boolean` | Only show icon in the trigger or not. Defaults to `false`. |
-
-Here is an overview of what the trigger looks like with different configurations.
-
-| `type='input'` | |
-| -------------- | ------------------------------------------------------------ |
-| | |
-
-| `type='button'` | `'chat'` | `'sparkles'` | `'mintlify'` |
-| ---------------- | --------------------------------------------------------------------------- | ------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- |
-| `iconOnly=false` | | | |
-| `iconOnly=true` | | | |
-
-#### MintlifyWidgetDisplayColorsProps
+## Configuration Options
-| Prop | Type | Description |
-| --------------- | -------- | -------------------------------------------------------- |
-| `primary?` | `string` | Primary color used in the widget. Defaults to `#0D9373`. |
-| `primaryLight?` | `string` | Primary color in dark mode. Defaults to `#55D799`. |
+### Core Settings
-#### MintlifyWidgetDisplayChatProps
+| Prop | Description |
+| ------------ | ---------------------------------------------------------- |
+| `connection` | Required. Contains API connection details (`apiKey`) |
+| `display` | Optional. Customize widget appearance and interactions |
+| `tracking` | Optional. Add analytics tracking functions |
-| Prop | Type | Description |
-| ------------------------ | ---------- | ------------------------------------------------------------------ |
-| `openCitationInSameTab?` | `boolean` | Open the citation url in the same tab or not. Defaults to `false`. |
-| `exampleQueries?` | `string[]` | Example queries to prompt the user to ask. Defaults to `[]`. |
+### Display Customization
-### MintlifyWidgetTrackingFunctions
+- **Trigger Types**: Choose between `button` or `input` display
+- **Colors**: Customize `primary` and `primaryLight` colors
+- **Dark Mode**: Toggle with `isDarkMode`
+- **Chat Settings**: Configure example queries and citation behavior
-| Prop | Type | Description |
-| --------------------- | ------------------------------------------ | -------------------------------------------------- |
-| `trackChatEnter` | `()=> void` | Triggered when the user opens the chat widget. |
-| `trackCitationClick` | `(title: string, url: string)=> void` | Triggered when the user clicks on a citation. |
-| `trackChatThumbsUp` | `(query: string, response: string)=> void` | Triggered when the user thumbs up on a response. |
-| `trackChatThumbsDown` | `(query: string, response: string)=> void` | Triggered when the user thumbs down on a response. |
-| `trackChatFollowup` | `(query: string)=> void` | Triggered when the user asks a question. |
-| `trackChatClose` | `(queriesCount: number)=> void` | Triggered when the user exits the chat widget. |
+For detailed configuration options and examples, see our [advanced configuration guide]()
+
\ No newline at end of file
diff --git a/api-playground/mdx/configuration.mdx b/api-playground/mdx/configuration.mdx
index 55682df30..9ba2f54f0 100644
--- a/api-playground/mdx/configuration.mdx
+++ b/api-playground/mdx/configuration.mdx
@@ -1,26 +1,26 @@
---
title: 'MDX Setup'
-description: 'Generate docs pages for your API endpoints using MDX'
+description: 'Configure API endpoints documentation 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.
+Learn how to set up API documentation with MDX and generate an interactive API playground.
-
- In your `mint.json` file, define your base URL and auth method:
+
+ Add your API configuration to `mint.json`:
```json
{
"api": {
- "baseUrl": "https://mintlify.com/api", // string array for multiple base URLs
+ "baseUrl": "https://mintlify.com/api",
"auth": {
- "method": "bearer" // options: bearer, basic, key.
+ "method": "bearer"
}
}
}
```
- 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, use:
```json
{
@@ -31,13 +31,10 @@ 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).
-
-
- 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 following metadata:
```md
---
@@ -46,20 +43,17 @@ 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 paths with parameters, use `{parameterName}`:
```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, 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 your endpoint pages to the `navigation` field in `mint.json` to display them in your sidebar.
-
+
\ No newline at end of file
diff --git a/api-playground/openapi/setup.mdx b/api-playground/openapi/setup.mdx
index bc24fbbf6..c7f938efa 100644
--- a/api-playground/openapi/setup.mdx
+++ b/api-playground/openapi/setup.mdx
@@ -5,18 +5,19 @@ 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+.
+To get started, you need a valid OpenAPI document (version 3.0+) in either JSON or YAML format that follows the [OpenAPI specification](https://swagger.io/specification/).
-## Auto-populate API pages
+To validate your OpenAPI spec, use: `mintlify openapi-check `
-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.
+## Add OpenAPI to Your Docs
-**Example with Anchors:**
+There are two main ways to include OpenAPI documentation:
-```json {5}
+### 1. Auto-populate API pages
+
+Add an `openapi` field to your `mint.json` to automatically generate pages for each OpenAPI operation. You can specify either a local path or URL to your OpenAPI document:
+
+```json
{
"anchors": [
{
@@ -29,124 +30,43 @@ The fastest way to get started with OpenAPI is to add an `openapi` field to a ta
}
```
-
-
-**Example with Tabs:**
-
-```json {6}
-{
- "tabs": [
- {
- "name": "API Reference",
- "url": "api-reference",
- "openapi": "https://petstore3.swagger.io/api/v3/openapi.json"
- }
- ]
-}
-```
-
-
-
-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.
-
-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.
-
-## Create MDX files for 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).
-
-
-
-### Autogenerate files
+### 2. Create Custom API Pages
-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.
+For more control over your API documentation, you can create individual MDX pages for each operation:
-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
-```
-
-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.
+#### Autogenerate MDX Files
+Use our scraper to generate MDX files from your OpenAPI document:
```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.
-
-
-### 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.
+#### Manual Creation
+Create MDX files manually by referencing OpenAPI operations in the page metadata:
-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"
- ---
- ```
-
- ```md Format
- ---
- title: "title of the page"
- openapi: openapi-file-path method path
- ---
- ```
-
+```md
+---
+title: "Get users"
+openapi: "GET /users"
+---
+```
-
+If you have multiple OpenAPI files, specify the path:
+```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.
+ The method and path must exactly match what's specified in your OpenAPI document.
-## Create MDX files for OpenAPI schemas
-
-Mintlify also allows you to create individual pages for any OpenAPI schema
-defined in an OpenAPI document's `components.schemas` field:
+You can also create pages for OpenAPI schemas defined in `components.schemas`:
-
- ```md Example
- ---
- openapi-schema: OrderItem
- ---
- ```
-
- ```md Format
- ---
- openapi-schema: "schema-key"
- ---
- ```
-
\ No newline at end of file
+```md
+---
+openapi-schema: "SchemaName"
+---
+```
\ No newline at end of file
diff --git a/changelog/overview.mdx b/changelog/overview.mdx
index ad2c56f93..ec747fa47 100644
--- a/changelog/overview.mdx
+++ b/changelog/overview.mdx
@@ -1,346 +1 @@
----
-title: "Product Updates"
-description: "New updates and improvements"
-mode: "center"
----
-
- ## Authentication
-
-
-
- Make docs private by setting up authentication via JWT, OAuth, or a universal password. With this privacy, you can create an internal knowledge base or prevent competitors from seeing your docs.
-
-
-
-
-
-
-
- ## AI Assistant
-
-
-
-
-
- You can now ask AI to make changes to your docs, with the context of all existing documentation. Type in a prompt and the assistant will propose changes by generating a pull request.
-
- ## GitLab Integration Upgrade
-
- We've improved our support for syncing with GitLab, such as enabling automated updates and preview deployments. Check out our [docs on GitLab](/settings/gitlab) to get started.
-
- ## Web Editor
-
-
-
-
-
- We've revamped our web editor so that you can now update docs with a fully WYSIWYG experience, while syncing with markdown.
-
- Check out our [docs on getting started with Web Editor](/web-editor).
-
- ## /llms.txt support
-
-
-
-
-
- All docs instances are now automatically hosted at /llms.txt and /llms-full.txt so that LLMs can easily ingest your documentation. For more information, read the [docs on the new llms.txt standard.](https://llmstxt.org)
-
- ## Localization
-
- You can now localize your docs which operates similarly to versioning. Add a `locale` to a version and fixed content in Mintlify like "Was this page helpful?" will also match the locale.
-
- ### Quality Improvements
-
- * Return chat & search results based on the current version that the user is reading
-
- * Authenticate users with OAuth, in addition to JWT or Shared Session tokens.
-
-
-
- ## Changelogs
-
- Launched a new [Update component](/content/components/update) to make it easier to display and report updates (like this one) to your users.
-
-
-
-
-
- ## Code Line Highlighting
-
- You can now highlight lines of code in your docs to emphasize and bring attention to important parts by adding a special comment after the language identifier. Use curly braces `{}` and specify line numbers or ranges separated by commas.
-
- ```javascript Line Highlighting Example {1,3-5}
- const greeting = "Hello, World!";
- function sayHello() {
- console.log(greeting);
- }
- sayHello();
- ```
-
- ````md
- ```javascript Line Highlighting Example {1,3-5}
- const greeting = "Hello, World!";
- function sayHello() {
- console.log(greeting);
- }
- sayHello();
- ```
- ````
-
- ## Light mode code blocks
-
- Code blocks now have a light mode variant which can be enabled by adding the following to your `mint.json`:
-
- ```json
- "codeBlock": {
- "mode": "auto"
- }
- ```
-
- ## Advanced Footer
-
-
-
-
-
- You can now add more links to the standard footer. This upgrade
- provides more consistency between landing pages and docs, or greater customization
- if you want to spotlight specific pages like socials or status logs.
-
- ## Filter search based on the current user
-
- When personalization is enabled, search results are now filtered based on the current logged in user so that they only see the relevant content.
-
- ## Custom Prompts for AI Chat
-
- You can now customize the prompts for the AI chat. Please reach out to [support](mailto:sales@mintlify.com) if you'd like to customize the prompts.
-
- ## Dashboard Improvements
-
- * Added ability to change custom domain to be /docs directly through dashboard settings.
-
- * Consolidated the login and signup pages to decrease friction and confusion.
-
- * Implemented the discovery login flow so that users that are members of multiple organizations can now switch between them.
-
- * Added login with Google OAuth
-
- * Added ability to add new deployment through dashboard settings.
-
- ## Bug Fixes
-
- * Can now use leading slashes in navigation.
-
- * Can now edit CSS & JS files in the web editor.
-
- * Fixed `suggestEdit` not showing up even when enabled.
-
- * Fixed keyboard navigation for Search and Chat such that you can now use the up and down arrow keys to navigate the results.
-
- * Don't allow search engines to crawl user-auth protected pages.
-
- * Revalidate the cache when an org is deleted.
-
- * We now use the Scalar OpenAPI parser to parse OpenAPI definitions which improves the performance, fixes parsing issues, and surfaces better error messages.
-
- * Top-level descriptions are now supported in API reference pages autogenerated from OpenAPI definitions.
-
- * Add in-line-style support for icons
-
- * Fixed the pop-in of custom CSS in docs.
-
- * Properly show in-line code styling in conjunction with links.
-
- * Maintain scroll position when you click the back button in a browser.
-
-
-
- ## Custom Fonts
-
-
-
-
-
- Personalize the font of your docs to your own font hosted on a CDN or by choosing from Google fonts to match your docs with your brand.
-
- ## Images in Card components
-
- Add an `img` property to a card to display an image on the top of the card. Learn more about it [here](/content/components/cards#image-card).
-
- ## Update Speed Performances
-
-
-
-
-
- For large projects (\~3,000 files), the download step for docs updates is now
- \~440x faster - a 99.8% time reduction. Across the board, file downloads during
- updates are now \~5.5x faster - an 81.8% time reduction.
-
- ## SEO improvements
-
-
-
-
-
- We've fixed both the mobile and desktop layout of our docs so that they are more SEO-friendly - including adding proper aria tags to navbar and toggle elements.
-
- ## Dashboard Improvements
-
- * App router migration in the dashboard.
-
- * Search analytics are now available in the dashboard.
-
- * Delete an org functionality has been added to the dashboard.
-
- * Shipped GitLab connection UI.
-
- * Fix incorrect analytics data.
-
- * Add-on's can now be directly purchased through the dashboard.
-
- ## Bug Fixes
-
- * Fixed a bug where the top bar would not stretch to the width of the screen when it's in custom mode and the sidebar layout is `sidenav`.
-
- * Fix relative positioning of the AI widget.
-
- ## More
-
- * **Troubleshooting for API pages**: API pages could be complicated so we listed
- common issues to help you sort them out quickly —
- [Read the docs](/api-playground/troubleshooting)
-
-
-
- ## OpenAPI Reference Pages
-
- * Endpoints defined by OpenAPI that are complex and recursive are now 98%
- smaller.
-
- * We now show
- [additionalProperties](https://swagger.io/docs/specification/data-models/dictionaries/)
- in OpenAPI pages.
-
- ## File Uploads in API Playground
-
- By default, API playground requests are proxied by Mintlify. Now you can use
- `disableProxy` to disable this behavior and support request types like file
- uploads.
-
- * [Learn more about API configurations](/settings/global#api-configurations)
-
- ## Mobile SEO improvements
-
- We've fixed the mobile layout of our docs so that they are more SEO-friendly -
- including adding proper aria tags to elements.
-
- ## Support Form
-
- We added a more detailed support form to the Mintlify dashboard. You can now
- submit a form to get in touch with us.
-
- ## Bug Fixes
-
- * Fixed a bug for the Segment integration functionality.
-
- * We now raise more granular error messages for GitHub permissions when
- interacting with the editor.
-
- * Fixed bugs where the navigation would not properly expand when a direct link
- was used.
-
-
-
- ## AI Widget
-
-
-
-
-
- For `Pro` users, we introduced Mintlify Widget, an extension of your docs to
- answer your users' questions when and where they asked. You can add this
- AI-powered chatbot to any web page: your landing page, inside your product, or
- on your existing documentation pages.
-
- * [Read the blog announcement](https://mintlify.com/blog/widget)
-
- * [Learn how to install the Widget](/advanced/widget/chat#getting-started)
-
- ## Pro Plan
-
- We also updated our pricing plans for better customizability and scale.
-
- * [Read the blog announcement](https://mintlify.com/blog/pro-plan)
-
- ## API Playground Code Example Sync
-
- When you browse API docs, the selected code example now syncs across your pages.
-
- ## Insights
-
- Currently in beta, this feature summarizes common user questions and patterns
- into easy-to-digest reports with AI-powered suggestions on how to improve your
- product.
-
-
-
-
-## Launch Week Highlights
-* Themes: Customize your styling with pre-configured themes. Just add the theme Quill, Prism, or Venus to your `mint.json` file and it'll update your docs styling.
-* Search V2: directly query OpenAPI endpoint descriptions and titles to reach API Reference pages, remove hidden pages from search, and enjoy our updated searchbar UI.
-* Web Editor branching: create branches in our web editor without an IDE.
-* User Personalization: authenticate users with Shared Session or JWT so that you can show them customized content, such as pre-filling API keys or showing specific content for customers.
-* OepenAPI Automation Upgrades: to auto-populate API Playground pages, you can add an `openapi` field to an object in tabs or anchors arrays in the mint.json.
-
-
-
-
-
-## Okta SSO
-We now support sign-on via Okta SAML and OIDC.
-
-## Mintlify REST API
-Programmatically rigger updates to your documentation.
-
-
-
-
-
-## Custom mode
-Add a configuration to the metadata to remove all elements except for the top bar.
-Example use cases:
-* Create a custom global landing page setup with custom components
-* Add full-screen videos or image galleries
-* Embed custom iFrame demo elements to add intractability to your docs
-
-Check out our [Custom Mode docs](/page#custom-mode).
-
-
-
-
-## Mintlify MDX for VSCode
-Call snippets of our pre-built components an dcallouts without leaving VSCode. [Install the extension here](https://marketplace.visualstudio.com/items?itemName=mintlify.mintlify-snippets).
-
-
-
-
-
-## Quality Improvements
-* Dashboard upgrades: view update logs to see what's changed and status of an update, toggle between Mintlify projects to manage deployments
-* Versioning with tabs fully supported
-* Wildcard redirects now supported
-* CLI Error Detection: we now show the position of invalid frontmatter when there are parsing issues during local development
-
-
-
-
-
-## Launch Week Highlights
-* Preview Deployments: When you create a pull request, we'll generate a unique link that shows a live preview of what your docs look like in prod. You can share this link with teammates.
-* Snippets V2: We now support fully reusable components and variables for snippets.
-* Open-source MDX Engine: We've exposed two APIs—getCompiledMdx and MDXComponent—so you can access Mintlify markdown and code syntax highlighting. [Contributions to the project](https://github.com/mintlify/mdx) are welcome.
-* AI Chat Insights: Segment chat history by date and increase AI Chat quota from the dashboard, and see how often a specific query appears.
-
-
+null
\ No newline at end of file
diff --git a/content/components/code.mdx b/content/components/code.mdx
index d59351bb4..9fc57dc31 100644
--- a/content/components/code.mdx
+++ b/content/components/code.mdx
@@ -6,96 +6,48 @@ icon: "code"
-````md Code Block Example
-```javascript Code Block Example
+```javascript Code Example
const hello = "world";
```
-````
-## Basic Code Block
+## Basic Usage
-Use [fenced code blocks](https://www.markdownguide.org/extended-syntax/#fenced-code-blocks) by enclosing code in three backticks.
+Use three backticks (```) to create code blocks in your documentation:
```
helloWorld();
```
-````md
-```
-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 name after the backticks for syntax highlighting:
-```java
-class HelloWorld {
- public static void main(String[] args) {
- System.out.println("Hello, World!");
- }
-}
-```
-
-````md
-```java
-class HelloWorld {
- public static void main(String[] args) {
- System.out.println("Hello, World!");
- }
-}
+```javascript
+const greeting = "Hello, World!";
+console.log(greeting);
```
-````
-
-## 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.
+## Additional Features
-```javascript Code Block Example
+- **Names**: Add a title after the language name
+```javascript My Example
const hello = "world";
```
-````md Code Block Example
-```javascript Code Block Example
-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.
-
-```javascript Line Highlighting Example {1,3-5}
+- **Line Highlighting**: Highlight specific lines using `{line-numbers}`
+```javascript {2}
const greeting = "Hello, World!";
-function sayHello() {
- console.log(greeting);
-}
-sayHello();
+console.log(greeting);
```
-````md
-```javascript Line Highlighting Example {1,3-5}
-const greeting = "Hello, World!";
-function sayHello() {
- console.log(greeting);
-}
-sayHello();
-```
-````
-
-## Code Groups
-
-Want to display multiple code examples in one code box? Check out the Code Group docs:
+Need to show multiple code examples side by side? Check out our Code Groups:
- Read the reference for the Code Group component
-
+ Read about Code Groups
+
\ No newline at end of file
diff --git a/content/components/mermaid-diagrams.mdx b/content/components/mermaid-diagrams.mdx
index 1334bde52..a62d7c21a 100644
--- a/content/components/mermaid-diagrams.mdx
+++ b/content/components/mermaid-diagrams.mdx
@@ -4,33 +4,10 @@ description: 'Display diagrams using Mermaid'
icon: 'diagram-project'
---
-
-
-````md Mermaid Flowchart Example
-```mermaid
- flowchart LR
- subgraph subgraph1
- direction TB
- top1[top] --> bottom1[bottom]
- end
- subgraph subgraph2
- direction TB
- top2[top] --> bottom2[bottom]
- end
- %% ^ These subgraphs are identical, except for the links to them:
-
- %% Link *to* subgraph1: subgraph1 direction is maintained
- outside --> subgraph1
- %% Link *within* subgraph2:
- %% subgraph2 inherits the direction of the top-level graph (LR)
- outside ---> top2
-```
-````
-
-
-
[Mermaid](https://mermaid.js.org/) lets you create visual diagrams using text and code.
+## Example Diagram
+
```mermaid
flowchart LR
subgraph subgraph1
@@ -41,16 +18,13 @@ icon: 'diagram-project'
direction TB
top2[top] --> bottom2[bottom]
end
- %% ^ These subgraphs are identical, except for the links to them:
-
- %% Link *to* subgraph1: subgraph1 direction is maintained
outside --> subgraph1
- %% Link *within* subgraph2:
- %% subgraph2 inherits the direction of the top-level graph (LR)
outside ---> top2
```
-You can create the following using Mermaid diagrams:
+## Available Diagram Types
+
+You can create various types of diagrams using Mermaid:
- Flowchart
- Sequence diagram
@@ -62,12 +36,12 @@ You can create the following using Mermaid diagrams:
For a complete list of diagrams supported by Mermaid, check out their [website](https://mermaid.js.org/).
-## Syntax for Mermaid diagrams
+## Basic Usage
-To create a flowchart, you can write the Mermaid flowchart inside a Mermaid code block.
+To create a Mermaid diagram, use the following syntax:
````md
```mermaid
-// Your mermaid code block here
+// Your mermaid code here
```
-````
+````
\ No newline at end of file
diff --git a/content/components/steps.mdx b/content/components/steps.mdx
index 09700a488..a1e4f8de6 100644
--- a/content/components/steps.mdx
+++ b/content/components/steps.mdx
@@ -70,4 +70,4 @@ Steps are the best way to display a series of actions of events to your users. Y
The size of the step titles. One of `p`, `h2` and `h3`.
-
+
\ No newline at end of file
diff --git a/integrations/analytics/overview.mdx b/integrations/analytics/overview.mdx
index fe9574b9b..b660ff897 100644
--- a/integrations/analytics/overview.mdx
+++ b/integrations/analytics/overview.mdx
@@ -3,591 +3,82 @@ title: "Analytics Integrations"
description: "Integrate with an analytics platform to track events"
---
-Automatically send data about your documentation engagement to your third party analytics provider.
+Send data about your documentation engagement to your preferred analytics provider.
-## All Integrations
+## Available Integrations
}>
-
+ Industry-standard product analytics
+
-
-
-
-
-
- }
->
-
-
-
-
-
-
-
-
- }
->
-
-
+
-
+
-
-
+
+
-
- }
->
-
-
-
-
-
-
-
-
-
-
- }
->
-
-
-
-
-
- }
->
-
-
-
-
-
-}
-
->
-
-
-
-
-
-
- }
->
-
-
-
-
- >
- }
->
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- }
->
-
-
-
-
-
-
-
-}>
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- }
->
+ }>
+ Most popular web analytics platform
+
-
-
-
-
- }
->
+ }>
+ Open-source analytics platform
+
-
-
-
-
-
-
-
- }
-/>
+
+ View all supported integrations
+
## Enabling Analytics
-Set your analytics keys in `mint.json`. You can add an unlimited number of analytics integrations for free.
+Add your analytics keys to `mint.json`. You can include multiple analytics platforms simultaneously.
-The syntax for `mint.json` is below. You only need to include entries for the platforms you want to connect.
-
-
-
-```json Analytics options in mint.json
-"analytics": {
- "amplitude": {
- "apiKey": "required"
- },
- "clearbit": {
- "publicApiKey": "required"
- },
- "fathom": {
- "siteId": "required"
- },
+```json
+{
+ "analytics": {
"ga4": {
- "measurementId": "required"
- },
- "gtm": {
- "tagId": "required"
+ "measurementId": "G-XXXXXXXX"
},
- "hotjar": {
- "hjid": "required",
- "hjsv": "required"
- },
- "koala": {
- "publicApiKey": "required"
- },
- "logrocket": {
- "appId": "required"
- },
- "mixpanel": {
- "projectToken": "required"
- },
- "pirsch": {
- "id": "required"
- },
- "plausible": {
- "domain": "required"
- },
- "posthog": {
- "apiKey": "required",
- "apiHost": "optional"
+ "amplitude": {
+ "apiKey": "YOUR_API_KEY"
},
+ // Add other platforms as needed
+ }
}
```
-```json Google Analytics 4 Example
-"analytics": {
- "ga4": {
- "measurementId": "G-XXXXXXX"
- }
-}
-```
-
-
-
-## FAQ
+
+ View individual integration pages for platform-specific setup instructions.
+
-
+## Tracked Events
-- `expandable_open`
-- `expandable_close`
-- `accordion_open`
-- `accordion_close`
-- `header_nav_item_click`
-- `cta_click`
-- `scroll_to_bottom`
-- `search_close`
-- `api_playground_call`
-- `search_result_click`
-- `chat_enter`
-- `chat_followup`
-- `chat_completed`
-- `code_block_copy`
-- `chat_shared`
-- `thumb_vote`
-- `powered_by_mintlify_click`
-- `ai_chat_citation_click`
-- `ai_chat_feedback_positive_click`
-- `ai_chat_feedback_negative_click`
+Mintlify automatically tracks key user interactions including:
-
+- Content engagement (expanding/collapsing sections, scrolling)
+- Navigation (header clicks, search usage)
+- API playground usage
+- Chat interactions
+- Code block copying
+- User feedback
\ No newline at end of file
diff --git a/integrations/analytics/posthog.mdx b/integrations/analytics/posthog.mdx
index b78cabb18..c5d507702 100644
--- a/integrations/analytics/posthog.mdx
+++ b/integrations/analytics/posthog.mdx
@@ -2,37 +2,25 @@
title: "PostHog"
---
-Add the following to your `mint.json` file to send analytics to PostHog.
-
-You only need to include `apiHost` if you are self-hosting PostHog. We send events to `https://app.posthog.com` by default.
+To enable PostHog analytics, add the following configuration to your `mint.json`:
-```json Analytics options in mint.json
+```json mint.json
"analytics": {
"posthog": {
"apiKey": "required",
- "apiHost": "optional"
- }
-}
-```
-
-```json Example
-"analytics": {
- "posthog": {
- "apiKey": "phc_TXdpocbYTeZVm5VJmMzHTMrCofBQu3e0kN7HGMNGTVW"
+ "apiHost": "optional" // Only needed for self-hosted PostHog
}
}
```
-
-
- Enabling PostHog analytics will disable the analytics on the Mintlify dashboard.
+ Enabling PostHog analytics will disable the Mintlify dashboard analytics.
## Session Recordings
-You need to add the URL for your docs website to Posthog's "Authorized domains for recordings" before you can receive session recordings. The option to add your URL is in Posthog's project settings.
+To enable session recordings, add your docs website URL to PostHog's "Authorized domains for recordings" in your project settings.
\ No newline at end of file
diff --git a/integrations/privacy/osano.mdx b/integrations/privacy/osano.mdx
index ded3d2d59..7a38e768e 100644
--- a/integrations/privacy/osano.mdx
+++ b/integrations/privacy/osano.mdx
@@ -2,26 +2,16 @@
title: "Osano"
---
-Add the following to your `mint.json` file to add the [Osano](https://www.osano.com/) cookie consent manager.
+To add the [Osano](https://www.osano.com/) cookie consent manager, include the following in your `mint.json` file:
-```json Integration options in mint.json
+```json mint.json
"integrations": {
"osano": "SOURCE"
}
```
-```json Example
-"integrations": {
- "osano": "https://cmp.osano.com/2sUB2dqwqdkks/8dqwd-dwd86£-4a9b/osano.js"
-}
-```
-
-The `SOURCE` can be found as the `src` value in the code snippet generated by Osano. It always starts with `https://cmp.osano.com/`.
-
-```html Code snippet from Osano
-
-```
\ No newline at end of file
+Replace `SOURCE` with your Osano script URL, which can be found in your Osano dashboard. The URL will start with `https://cmp.osano.com/`.
\ No newline at end of file
diff --git a/integrations/sdks/speakeasy.mdx b/integrations/sdks/speakeasy.mdx
index d45628bed..f6273fa0c 100644
--- a/integrations/sdks/speakeasy.mdx
+++ b/integrations/sdks/speakeasy.mdx
@@ -3,11 +3,13 @@ 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.
+You can integrate Speakeasy-generated code snippets from your SDKs directly into your Mintlify API reference documentation. These snippets appear in the [interactive playground](https://mintlify.com/docs/api-playground/overview).
-## Speakeasy SDK Repository Changes
+## Setup Steps
-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.
+### 1. Configure SDK Repositories
+
+Add the following to the `targets` section in your SDK's `.speakeasy/workflow.yaml`:
```yaml .speakeasy/workflow.yaml
targets:
@@ -18,55 +20,40 @@ 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.
-
-## 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.
+### 2. Set Up Mintlify Documentation Repository
-### Interactive CLI Set Up
+You can set up your Mintlify repository either through the CLI or manual configuration.
-Run the following commands to set up the `.speakeasy/workflow.yaml` and `.github/workflows/sdk_generation.yaml` files through the interactive Speakeasy CLI.
+#### Option A: CLI Setup (Recommended)
+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.
-
-
+Follow the prompts to:
+1. Set up your source OpenAPI spec
+2. Add the Speakeasy overlay for code snippets
+3. Configure the output spec path
-Provide a name and path for the OpenAPI spec. This will be the final spec used by Mintlify.
-
-
-
-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.
+#### Option B: Manual Setup
+Create two files in your Mintlify docs repository:
```yaml .speakeasy/workflow.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
- - location: https://raw.githubusercontent.com/{{your_sdk_repo_3}}/codeSamples.yaml
output: openapi.yaml
targets: {}
```
-```yaml .speakeasy/workflows/sdk_generation.yaml
+```yaml .github/workflows/sdk_generation.yaml
name: Generate
permissions:
checks: write
@@ -94,4 +81,8 @@ 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 API Key
+
+Add your `SPEAKEASY_API_KEY` as a repository secret:
+1. Go to your Mintlify repo's `Settings > Secrets & Variables > Actions`
+2. Add the key from your Speakeasy dashboard's **API Keys** tab
\ No newline at end of file
diff --git a/integrations/sdks/stainless.mdx b/integrations/sdks/stainless.mdx
index 8a21bfab4..3a857a103 100644
--- a/integrations/sdks/stainless.mdx
+++ b/integrations/sdks/stainless.mdx
@@ -3,18 +3,21 @@ 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:
+To integrate Stainless with your Mintlify API reference documentation:
+
+1. Add the following to your Stainless config:
```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:
+2. Configure the [OpenAPI setup](/api-playground/openapi/setup#in-the-repo) in your Mintlify docs.
+3. Create or update your GitHub Action to sync the Stainless-enhanced OpenAPI spec:
```yaml
-name: Upload OpenAPI spec to Stainless and (Mintlify) docs repo
+name: Sync OpenAPI Spec
on:
push:
@@ -26,27 +29,26 @@ jobs:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- - name: Push spec and config to Stainless and outputs documented spec
+ - name: Push to Stainless
uses: stainless-api/upload-openapi-spec-action@main
with:
input_path: 'path/to/my-company-openapi.json'
config_path: 'path/to/my-company.stainless.yaml'
output_path: 'path/to/my-company-openapi.documented.json'
project_name: 'my-stainless-project'
- - name: Push documented spec to docs repo
+ - name: Sync with docs repo
uses: dmnemec/copy_file_to_another_repo_action@main
env:
API_TOKEN_GITHUB: ${{ secrets.API_TOKEN_GITHUB }}
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 access
\ No newline at end of file
diff --git a/integrations/support/overview.mdx b/integrations/support/overview.mdx
index 71be4aa65..c0b285ebd 100644
--- a/integrations/support/overview.mdx
+++ b/integrations/support/overview.mdx
@@ -1,19 +1,20 @@
---
title: "Support Integrations"
-description: "Integrate with a support widget"
+description: "Add customer support widgets to your documentation"
---
+## Available Integrations
+
}
horizontal
- >
-
+ />
@@ -28,22 +29,22 @@ description: "Integrate with a support widget"
-
-}
-horizontal
->
-
+}
+ horizontal
+ />
-## Enabling Support Integrations
+## Setup
-You can integrate widgets onto your docs for customer support. Add the `integrations` field into your `mint.json` file with your respective app ID.
+Add your integration details to `mint.json`:
```json
+{
"integrations": {
"intercom": "APP_ID",
"frontchat": "CHAT_ID"
}
+}
```
-If you'd like to request a customer support integration, please let us know in [our community](https://join.slack.com/t/mintlify-users/shared_invite/zt-1xfzz6x35-f4o4WCYfpvLhSj3O7WAOMA).
+Want to suggest a new integration? Join our [community](https://join.slack.com/t/mintlify-users/shared_invite/zt-1xfzz6x35-f4o4WCYfpvLhSj3O7WAOMA).
\ No newline at end of file
diff --git a/migration.mdx b/migration.mdx
index 491e89454..0498d1a3e 100644
--- a/migration.mdx
+++ b/migration.mdx
@@ -4,141 +4,43 @@ description: 'How to migrate documentation from your existing provider'
icon: 'arrow-up-from-bracket'
---
-You can use our [public packages](https://www.npmjs.com/package/@mintlify/scraping) to scrape documentation frameworks to Mintlify.
+You can use our [public packages](https://www.npmjs.com/package/@mintlify/scraping) to scrape documentation from other frameworks to Mintlify.
-We currently support migration for:
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+## Supported Providers
-
-
-
-
-
-} />
-
-
-} />
-
-
-} />
+
+ } />
+ } />
+ } />
-Don't see your docs provider or have a home grown system? We can still help! Please get in touch at sales@mintlify.com.
-
-## Commands
-
-- `mintlify-scrape section [url]` - Scrapes multiple pages in a site.
-- `mintlify-scrape page [url]` - Scrapes a single page in a site.
-
+Don't see your docs provider? Contact us at sales@mintlify.com for support with custom migrations.
-The commands will automatically detect the framework.
+## Quick Start
-## 🚀 Installation
+Install the package:
-First, install the package:
-
-```
+```bash
npm i @mintlify/scraping
```
-One-time use:
-
-```bash Section
+## Usage
+
+Scrape multiple pages:
+```bash
npx @mintlify/scraping@latest section [url]
```
-```bash Page
+Scrape a single page:
+```bash
npx @mintlify/scraping@latest page [url]
```
-
-
-Global installation:
-
-```
-npm install @mintlify/scraping@latest -g
-```
-
-Global usage:
-
-
-```bash Section
-mintlify-scrape section [url]
-```
-```bash Page
-mintlify-scrape page [url]
-```
-
-
-Provide the relative path or URL to the OpenAPI file to generate frontmatter files for each endpoint.
-
-
-```
-mintlify-scrape openapi-file [openApiFilename]
+Generate pages from OpenAPI:
+```bash
+npx @mintlify/scraping@latest openapi-file [filename] [options]
--w, --writeFiles Whether or not to write the frontmatter files [boolean] [default: true]
--o, --outDir The folder in which to write any created frontmatter files [string]
+Options:
+ -w, --writeFiles Write frontmatter files (default: true)
+ -o, --outDir Output directory for frontmatter files
```
\ No newline at end of file
diff --git a/quickstart.mdx b/quickstart.mdx
index fd4ba0858..cd14bc7b3 100644
--- a/quickstart.mdx
+++ b/quickstart.mdx
@@ -4,183 +4,54 @@ description: "Start building modern documentation in under five minutes"
icon: "rocket"
---
-
-
-
-
-
## Getting Started
-Welcome! Follow the instructions below to learn how to deploy, update and
-supercharge your documentation with Mintlify.
-
-### Creating the Repository
-
-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. Onboard through the [dashboard](https://dashboard.mintlify.com) or clone our [starter kit](https://github.com/mintlify/starter) to get started.
+Welcome to Mintlify! Follow these simple steps to create and deploy your documentation.
-
+### 1. Create Your Docs
-
-
- Install our GitHub app to ensure 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.
+Get started by either:
+- Using our [dashboard](https://dashboard.mintlify.com) to create a new project
+- Cloning our [starter kit](https://github.com/mintlify/starter) from GitHub
-
- 
-
+### 2. Set Up Your Repository
-
+Install our GitHub app through the [dashboard](https://dashboard.mintlify.com/settings) to enable automatic deployments when you push changes.
-
- If you want your docs to live alongside your code as a monorepo setup, you
- can: 1. Move your docs content to your monorepo. 2. Specify the path to your
- `mint.json` in the
- [dashboard](https://dashboard.mintlify.com/settings/deployment/git-settings)
-
-
-
-
-
+### 3. Update Your Content
-
-
-### Updating the Content
-
-Mintlify enables you to easily customize the style, structure, and content of
-your docs.
+Choose your preferred editing method:
-
-
- 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`.
-
- Learn more about this in our [local development guide](/development).
-
-
-
-
-
- Learn more about how to use the web editor on our [guide](/web-editor).
-
-
-
-
-
- Easily customize colors, logos and buttons among other configurations in our `mint.json` file. Start with these basic configurations:
-
- ```json
- "name": "Your Company"
- "logo": {
- "light": "/logo/light.svg",
- "dark": "/logo/dark.svg",
- "href": "https://yourcompany.com"
- },
- "favicon": "/favicon.svg",
- "colors": {
- "primary": "#2AB673",
- "light": "#55D799",
- "dark": "#117866",
- },
- ```
-
- A full list of supported configurations can be found at [global settings](/settings/global).
-
-
-
-
-
- Add content with simple MDX files. Initiate your pages with this template:
-
- ```md
- ---
- title: "Page Title"
- sidebarTitle: "Sidebar title (optional - if different from page title)"
- description: "Subtitle (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).
-
-
-
-
-
- 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).
-
-
- 
-
-
-
-
-
-
- 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.
-
- ```json
- "openapi": "link-to-your-openapi-file"
- ```
-
- 2. Use our [scraper](/api-playground/openapi/setup#autogenerate-files-recommended) to autogenerate your OpenAPI endpoints files as:
-
- ```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).
-
+
+ 1. Install the Mintlify CLI: `npm i -g mintlify`
+ 2. Clone your repository
+ 3. Make changes using your favorite IDE
+ 4. Preview changes locally using the CLI
-
-
- 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).
-
+
+ Use our web editor for quick updates. Visit our [web editor guide](/web-editor) to learn more.
-
- 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).
-
-
-### Publishing
-
-
+### 4. Customize Your Docs
-Integrate your docs into your website by hosting them on a custom domain. This is included in the free plan.
+Update your `mint.json` file to match your brand:
-Navigate to your [dashboard settings](https://www.dashboard.mintlify.com/settings) to add a custom domain.
+```json
+"name": "Your Company"
+"logo": {
+ "light": "/logo/light.svg",
+ "dark": "/logo/dark.svg"
+},
+"colors": {
+ "primary": "#2AB673"
+}
+```
-
+### 5. Deploy
-
+Push your changes to GitHub, and they'll automatically deploy to your documentation site. You can also add a custom domain through the [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 contact us at [support@mintlify.com](mailto:support@mintlify.com).
\ No newline at end of file
diff --git a/reusable-snippets.mdx b/reusable-snippets.mdx
index 0ad0ee9ee..dd266c740 100644
--- a/reusable-snippets.mdx
+++ b/reusable-snippets.mdx
@@ -4,153 +4,47 @@ description: 'Reusable, custom snippets to keep content in sync'
icon: 'recycle'
---
-One of the core principles of software development is DRY (Don't Repeat
-Yourself), which applies to documentation as
-well. If you find yourself repeating the same content in multiple places, you
-should create a custom snippet to keep your content in sync.
+Reusable snippets help you maintain consistent content across your documentation by allowing you to write content once and use it in multiple places.
-## Creating a custom snippet
+## Creating a Basic Snippet
-**Pre-condition**: You must create your snippet file in the `snippets` directory in order for the import to work.
-
- Any page in the `snippets` directory will be treated as a snippet and will not
- be rendered into a standalone page. If you want to create a standalone page
- from the snippet, import the snippet into another file and call it as a
- component.
-
-
-### Default export
-
-1. Add content to your snippet file that you want to re-use. Optionally, you can add variables that can be filled in via props
- when you import the snippet. In this example, our variable is word.
+1. Create your snippet file in the `snippets` directory:
```typescript snippets/my-snippet.mdx
Hello world! This is my content I want to reuse across pages.
```
-
-2. Import the snippet into your destination file.
+2. Import and use the snippet in your document:
```typescript destination-file.mdx
----
-title: My title
-description: My Description
----
-
-import MySnippet from '/snippets/path/to/my-snippet.mdx';
-
-## Header
-
-Lorem impsum dolor sit amet.
+import MySnippet from '/snippets/my-snippet.mdx';
-
```
-### Exporting with variables
+## Using Variables in Snippets
-1. Optionally, you can add variables that can be filled in via props when you import the snippet. In this example, our variable is word.
+You can make your snippets dynamic by using variables:
```typescript snippets/my-snippet.mdx
My keyword of the day is {word}.
```
-
-2. Import the snippet into your destination file with the variable. The property will fill in based on your specification.
+Use it in your document with a custom value:
```typescript destination-file.mdx
----
-title: My title
-description: My Description
----
-
-import MySnippet from '/snippets/path/to/my-snippet.mdx';
-
-## Header
-
-Lorem impsum dolor sit amet.
+import MySnippet from '/snippets/my-snippet.mdx';
-
-```
-
-### Reusable variables
-
-1. Export a variable from your snippet file:
-
-```typescript snippets/path/to/custom-variables.mdx
-export const myName = 'my name';
-
-export const myObject = { fruit: 'strawberries' };
-```
-
-2. Import the snippet from your destination file and use the variable:
-
-```typescript destination-file.mdx
----
-title: My title
-description: My Description
----
-
-import { myName, myObject } from '/snippets/path/to/custom-variables.mdx';
-
-Hello, my name is {myName} and I like {myObject.fruit}.
-```
-
-### Reusable components
-
-1. Inside your snippet file, create a component that takes in props by exporting
- your component in the form of an arrow function.
-
-```typescript snippets/custom-component.mdx
-export const MyComponent = ({ title }) => (
-
-
{title}
-
... snippet content ...
-
-);
```
-
- MDX does not compile inside the body of an arrow function. Stick to HTML
- syntax when you can or use a default export if you need to use MDX.
-
-
-2. Import the snippet into your destination file and pass in the props
+## Advanced Usage
-```typescript destination-file.mdx
----
-title: My title
-description: My Description
----
+For more complex use cases, you can also:
+- Export reusable variables
+- Create custom components
+- Handle client-side content
-import { MyComponent } from '/snippets/custom-component.mdx';
-
-Lorem ipsum dolor sit amet.
-
-
-```
-
-### Client-Side Content
-
-By default, Mintlify employs server-side rendering, generating content
-at build time. For client-side content loading, ensure to verify the
-`document` object's availability before initiating the rendering process.
-
-```typescript snippets/client-component.mdx
-{/* `setTimeout` simulates a React.useEffect, which is called after the component is mounted. */}
-export const ClientComponent = () => {
- if (typeof document === "undefined") {
- return null;
- } else {
- setTimeout(() => {
- const clientComponent = document.getElementById("client-component");
- if (clientComponent) {
- clientComponent.innerHTML = "Hello, client-side component!";
- }
- }, 1);
-
- return
- }
-}
-```
+
+ Any file in the `snippets` directory will not be rendered as a standalone page.
+
\ 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..c02a6726a 100644
--- a/settings/authentication-personalization/authentication-setup/jwt.mdx
+++ b/settings/authentication-personalization/authentication-setup/jwt.mdx
@@ -7,42 +7,28 @@ 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.
-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 authentication to implement your own custom login flow for your documentation site.
-## Implementation
+## Quick Setup
-
- 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.
+
+ Generate a private key in your [Mintlify dashboard authentication settings](https://dashboard.mintlify.com/products/authentication).
-
- 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
+
+ Create a login endpoint that:
+ - Authenticates the user
+ - Creates and signs a JWT with the user's info
+ - Redirects to `/login/jwt-callback` with the JWT in the URL 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 to your [authentication settings](https://dashboard.mintlify.com/products/authentication).
-## Example
+## Implementation Example
-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:
+Here's a basic implementation example that shows how to create and sign a JWT for Mintlify authentication:
```ts TypeScript
@@ -55,7 +41,7 @@ const signingKey = await jose.importPKCS8(process.env.MINTLIFY_PRIVATE_KEY, 'EdD
export async function handleRequest(req: Request, res: Response) {
const user = {
- expiresAt: Math.floor((Date.now() + TWO_WEEKS_IN_MS) / 1000), // 2 week session expiration
+ expiresAt: Math.floor((Date.now() + TWO_WEEKS_IN_MS) / 1000),
groups: res.locals.user.groups,
content: {
firstName: res.locals.user.firstName,
@@ -65,7 +51,7 @@ export async function handleRequest(req: Request, res: Response) {
const jwt = await new jose.SignJWT(user)
.setProtectedHeader({ alg: 'EdDSA' })
- .setExpirationTime('10 s') // 10 second JWT expiration
+ .setExpirationTime('10 s')
.sign(signingKey);
return res.redirect(`https://docs.foo.com/login/jwt-callback#${jwt}`);
@@ -85,8 +71,8 @@ private_key = os.getenv(MINTLIFY_JWT_PEM_SECRET_NAME, '')
async def return_mintlify_auth_status(current_user):
jwt_token = jwt.encode(
payload={
- 'exp': int((datetime.now() + timedelta(seconds=10)).timestamp()), # 10 second JWT expiration
- 'expiresAt': int((datetime.now() + timedelta(weeks=2)).timestamp()), # 1 week session expiration
+ 'exp': int((datetime.now() + timedelta(seconds=10)).timestamp()),
+ 'expiresAt': int((datetime.now() + timedelta(weeks=2)).timestamp()),
'groups': ['admin'] if current_user.is_admin else [],
'content': {
'firstName': current_user.first_name,
@@ -99,4 +85,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..b65f21718 100644
--- a/settings/authentication-personalization/authentication-setup/mintlify.mdx
+++ b/settings/authentication-personalization/authentication-setup/mintlify.mdx
@@ -8,39 +8,22 @@ description: "Use Mintlify to authenticate users"
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.
-
-This handshake method also enables private preview deployments, so that only Mintlify authenticated users will be able to access your preview deployments.
+Mintlify Auth Handshake allows you to authenticate and manage access to your documentation. Users with access to your dashboard will automatically have access to your documentation. This method also enables private preview deployments that only authenticated users can access.
Authentication is available only by request. Please{" "}
- contact sales for access. After we've
- enabled access, you can follow the implementation instructions.
+ 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.
-
-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.
-
-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
-
- Go to your [Mintlify dashboard
- settings](https://dashboard.mintlify.com/products/authentication) and select
- the Mintlify Auth Handshake.
+
+ Enable the Mintlify Auth Handshake in your [Mintlify dashboard
+ settings](https://dashboard.mintlify.com/products/authentication).
- Ensure that any users that should be able to view your documentation have
- been added as users in your [Mintlify dashboard
+ Add your team members as users in your [Mintlify dashboard
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..6c706fc82 100644
--- a/settings/authentication-personalization/authentication-setup/oauth.mdx
+++ b/settings/authentication-personalization/authentication-setup/oauth.mdx
@@ -1,49 +1,45 @@
---
title: 'OAuth 2.0 Handshake'
-description: 'Integrate with your OAuth server to enable user login via the Authorization Code flow'
+description: 'Set up user login with OAuth Authorization Code flow'
---
- 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** setup. For OAuth **Personalization** setup, see [this guide](/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.
+
+ Navigate to [Mintlify authentication settings](https://dashboard.mintlify.com/products/authentication) and select OAuth. Enter:
+
+ - **Authorization URL**: Your OAuth authorization endpoint
+ - **Client ID**: Your OAuth client ID
+ - **Scopes**: Required OAuth scopes
+ - **Token URL**: Your token exchange endpoint
+ - **Info API URL** (optional): Endpoint to get user information
-
- 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.
+
+ Add the Redirect URL from your [authentication settings](https://dashboard.mintlify.com/products/authentication) 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.
+
+ To use authentication customization:
+ 1. Create an API endpoint accessible with OAuth tokens
+ 2. Make it return user data in the [User](../sending-data) format
+ 3. Add this endpoint URL as your Info API URL in the authentication settings
-## 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.
+## Example Configuration
-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`
+Here's a sample setup for docs hosted at `foo.com/docs`:
-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.
+```json
+{
+ "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"
+}
+```
\ No newline at end of file
diff --git a/settings/authentication-personalization/personalization-setup/jwt.mdx b/settings/authentication-personalization/personalization-setup/jwt.mdx
index 3e4fe195a..de86e4f85 100644
--- a/settings/authentication-personalization/personalization-setup/jwt.mdx
+++ b/settings/authentication-personalization/personalization-setup/jwt.mdx
@@ -8,7 +8,7 @@ description: 'Use a customized login flow to authenticate users'
-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 send user info to your docs via a JWT in the URL.
+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 send user info to your docs via a JWT in the URL.
## Implementation
@@ -31,12 +31,12 @@ If you don’t have a dashboard, or if you want to keep your dashboard and docs
## Example
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 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 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#{SIGNED_JWT}`, and redirect the user.
@@ -80,4 +80,4 @@ Post-login, if you'd like to redirect to a specific anchor on the page, you can
Example:
- Original: `https://docs.foo.com/quickstart#step-one`
-- Redirect: `https://docs.foo.com/quickstart#jwt={SIGNED_JWT}&anchor=step-one`
+- Redirect: `https://docs.foo.com/quickstart#jwt={SIGNED_JWT}&anchor=step-one`
\ 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..85871f1da 100644
--- a/settings/authentication-personalization/personalization-setup/oauth.mdx
+++ b/settings/authentication-personalization/personalization-setup/oauth.mdx
@@ -4,42 +4,43 @@ description: 'Integrate with your OAuth server to enable user login via the PKCE
---
- 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 documentation covers the OAuth **Personalization** Handshake. For the [OAuth **Authentication** Handshake](/settings/authentication-personalization/authentication-setup/oauth), see the separate guide.
-If you have an existing OAuth server that supports the PKCE flow, you can integrate with Mintlify for a seamless login experience.
-
-## Implementation
+## Setup Guide
-
- 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.
+
+ Create an API endpoint that:
+ - Accepts an OAuth access token
+ - Returns user data in the [User](../sending-data) format
+ - Has defined scope requirements
-
- 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 your [Mintlify dashboard](https://dashboard.mintlify.com/products/authentication):
+ 1. Select OAuth option
+ 2. Fill in:
+ - Authorization URL
+ - Client ID
+ - Required scopes
+ - Token URL
+ - Info API URL
-
- 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 your Mintlify dashboard as an authorized redirect URL in your OAuth server settings.
-## 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`.
-
-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.
+## Example Configuration
-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`
+```json
+{
+ "authorizationUrl": "https://auth.foo.com/authorization",
+ "clientId": "ydybo4SD8PR73vzWWd6S0ObH",
+ "scopes": ["docs-user-info"],
+ "tokenUrl": "https://auth.foo.com/exchange",
+ "infoApiUrl": "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.
+This example shows configuration for docs hosted at `foo.com/docs` with an info endpoint at `api.foo.com/docs/user-info` requiring the `docs-user-info` scope.
\ 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..e42a250a0 100644
--- a/settings/authentication-personalization/personalization-setup/shared-session.mdx
+++ b/settings/authentication-personalization/personalization-setup/shared-session.mdx
@@ -7,48 +7,35 @@ description: 'Seamlessly share user sessions between your dashboard and your doc
This is the documentation for the Shared Session **Personalization** Handshake. The Shared Session Handshake is not available for Authentication.
-This method utilizes the session authentication info already stored in your user’s browser to create a seamless documentation experience.
+Use the session authentication info already stored in your user's browser to create a seamless documentation experience.
## Implementation
- Create an API endpoint that uses session authentication to identify users, and responds with a JSON payload following 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`
-
- 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.
-
+ Create an API endpoint that uses session authentication to identify users and returns a JSON payload following the [User](../sending-data) format.
+
+ If your API domain differs from your docs domain:
+ - Add the docs domain to `Access-Control-Allow-Origin`
+ - Set `Access-Control-Allow-Credentials` to `true`
+
+
+ Only enable these CORS settings on the user info endpoint, not all dashboard endpoints.
+
- 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.
+ Go to your [Mintlify dashboard settings](https://dashboard.mintlify.com/products/authentication) and add your API URL and Login URL to the Personalization settings.
-## Examples
+## Example Setup
-### Dashboard at subdomain, docs at subdomain
+Let's say you have:
+- Dashboard at `dash.foo.com` with API routes at `dash.foo.com/api`
+- Docs hosted at `docs.foo.com`
-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`.
-
-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**.
-
-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 subdomain, docs at root
-
-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
+1. Create an endpoint at `dash.foo.com/api/docs/user-info`
+2. Configure CORS for this endpoint:
+ - Add `https://docs.foo.com` to `Access-Control-Allow-Origin`
+ - Set `Access-Control-Allow-Credentials` to `true`
+3. In Mintlify dashboard settings, set the API URL to `https://dash.foo.com/api/docs/user-info`
\ No newline at end of file
diff --git a/settings/gitlab.mdx b/settings/gitlab.mdx
index 01c0b82bf..3595aaff6 100644
--- a/settings/gitlab.mdx
+++ b/settings/gitlab.mdx
@@ -4,90 +4,66 @@ description: "Sync your docs with a GitLab repo"
icon: "gitlab"
---
-We use a combination of Access tokens and Webhooks to authenticate and sync
-changes between GitLab and Mintlify.
-
-- We use Access tokens to pull information from GitLab.
-- We use Webhooks so GitLab can notify Mintlify when changes are made.
- - This allows Mintlify to create preview deployments when a MR is created.
+Connect your GitLab repository to Mintlify using Access tokens for authentication and Webhooks for sync notifications.
## Set up the connection
- Within your GitLab project, navigate to `Settings` > `General` and find the `Project ID`.
+ Go to `Settings` > `General` and locate your `Project ID`.
-
- a. Navigate to `Settings` > `Access Tokens`.
-
- b. Select `Add new token`.
- 1. Name the token "Mintlify".
- 2. If you have a private repo, you must set the role as `Maintainer`.
- 3. Choose `api` and `read_api` for the scopes.
-
- c. Finally click `Create project access token` and copy the token.
+
+ 1. Go to `Settings` > `Access Tokens`
+ 2. Click `Add new token`
+ 3. Configure the token:
+ - Name: "Mintlify"
+ - Role: `Maintainer` (required for private repos)
+ - Scopes: Select `api` and `read_api`
+ 4. Click `Create project access token` and copy it
-
-
- Within the [Mintlify dashboard](https://dashboard.mintlify.com/settings/deployment/git-settings), add the project ID and access token from the previous steps alongside the other configurations. Click "Save Changes" when you're done.
+
+ Enter your project ID and access token in the [Mintlify dashboard](https://dashboard.mintlify.com/settings/deployment/git-settings) and save changes.
-## Create the webhook
-
-Webhooks allow us to receive events when changes are made so that we can
-automatically trigger deployments.
+## Set up webhook
-
+
+ Go to `Settings` > `Webhooks` and click `Add new Webhook`
-
- In the "URL" field, enter the endpoint `https://leaves.mintlify.com/gitlab-webhook` and name the webhook "Mintlify".
-
-
-
- Paste the Webhook token generated after setting up the connection.
-
-
-
-
-
- Select the events you want to trigger the webhook:
- - Push events (All branches)
- - Merge requests events
-
- When you're done it should look like this:
+
+ 1. URL: `https://leaves.mintlify.com/gitlab-webhook`
+ 2. Name: "Mintlify"
+ 3. Token: Paste the Webhook token from Mintlify dashboard
+ 4. Select events:
+ - Push events (All branches)
+ - Merge requests events
-
- After creating the Webhook, click the "Test" dropdown and select "Push events" to send a sample payload to ensure it's configured correctly. It'll say "Hook executed successfully: HTTP 200" if configured correctly.
-
- This will help you verify that everything is working correctly and that your documentation will sync properly with your GitLab repository.
+
+ Click "Test" > "Push events" to verify the setup. You should see "Hook executed successfully: HTTP 200".
-
- Reach out to the Mintlify team if you need help. Contact us
- [here](https://mintlify.com/enterprise).
-
-
-[git-settings]: https://dashboard.mintlify.com/settings/deployment/git-settings
+ Need help? Contact us [here](https://mintlify.com/enterprise).
+
\ No newline at end of file