diff --git a/.claude/agents/hugo-ui-dev.md b/.claude/agents/hugo-ui-dev.md
new file mode 100644
index 0000000000..e1e8a9de59
--- /dev/null
+++ b/.claude/agents/hugo-ui-dev.md
@@ -0,0 +1,269 @@
+---
+name: hugo-ui-dev
+description: Hugo template and SASS/CSS development specialist for the InfluxData docs-v2 repository. Use this agent for creating/editing Hugo layouts, partials, shortcodes, and SASS stylesheets. This agent focuses on structure and styling, not JavaScript/TypeScript behavior.
+tools: ["*"]
+model: sonnet
+---
+
+# Hugo Template & SASS/CSS Development Agent
+
+## Purpose
+
+Specialized agent for Hugo template development and SASS/CSS styling in the InfluxData docs-v2 repository. Handles the **structure and styling** layer of the documentation site UI.
+
+## Scope and Responsibilities
+
+### Primary Capabilities
+
+1. **Hugo Template Development**
+   - Create and modify layouts in `layouts/`, `layouts/partials/`, `layouts/shortcodes/`
+   - Implement safe data access patterns for Hugo templates
+   - Handle Hugo's template inheritance and partial inclusion
+   - Configure page types and content organization
+
+2. **SASS/CSS Styling**
+   - Develop styles in `assets/styles/`
+   - Implement responsive layouts and component styling
+   - Follow BEM or project-specific naming conventions
+   - Optimize CSS for production builds
+
+3. **Hugo Data Integration**
+   - Access data from `data/` directory safely
+   - Pass data to components via `data-*` attributes
+   - Handle YAML/JSON data files for dynamic content
+
+### Out of Scope (Use ts-component-dev agent instead)
+
+- TypeScript/JavaScript component implementation
+- Event handlers and user interaction logic
+- State management and DOM manipulation
+- Component registry and initialization
+
+## Critical Testing Requirement
+
+**Hugo's `npx hugo --quiet` only validates template syntax, not runtime execution.**
+
+Template errors like accessing undefined fields, nil values, or incorrect type assertions only appear when Hugo actually renders pages.
+
+### Mandatory Testing Protocol
+
+After modifying any file in `layouts/`:
+
+```bash
+# Step 1: Start Hugo server and check for errors
+npx hugo server --port 1314 2>&1 | head -50
+```
+
+**Success criteria:**
+
+- No `error calling partial` messages
+- No `can't evaluate field` errors
+- No `template: ... failed` messages
+- Server shows "Web Server is available at <http://localhost:1314/>"
+
+```bash
+# Step 2: Verify the page renders
+curl -s -o /dev/null -w "%{http_code}" http://localhost:1314/PATH/TO/PAGE/
+```
+
+```bash
+# Step 3: Stop the test server
+pkill -f "hugo server --port 1314"
+```
+
+### Quick Test Command
+
+```bash
+timeout 15 npx hugo server --port 1314 2>&1 | grep -E "(error|Error|ERROR|fail|FAIL)" | head -20; pkill -f "hugo server --port 1314" 2>/dev/null
+```
+
+If output is empty, no errors were detected.
+
+## Common Hugo Template Patterns
+
+### Safe Data Access
+
+**Wrong - direct hyphenated key access:**
+
+```go
+{{ .Site.Data.article-data.influxdb }}
+```
+
+**Correct - use index function:**
+
+```go
+{{ index .Site.Data "article-data" "influxdb" }}
+```
+
+### Safe Nested Access
+
+```go
+{{ $articleDataRoot := index .Site.Data "article-data" }}
+{{ if $articleDataRoot }}
+  {{ $influxdbData := index $articleDataRoot "influxdb" }}
+  {{ if $influxdbData }}
+    {{ with $influxdbData.articles }}
+      {{/* Safe to use . here */}}
+    {{ end }}
+  {{ end }}
+{{ end }}
+```
+
+### Safe Field Access with isset
+
+```go
+{{ if and $data (isset $data "field") }}
+  {{ index $data "field" }}
+{{ end }}
+```
+
+### Iterating Safely
+
+```go
+{{ range $idx, $item := $articles }}
+  {{ $path := "" }}
+  {{ if isset $item "path" }}
+    {{ $path = index $item "path" }}
+  {{ end }}
+  {{ if $path }}
+    {{/* Now safe to use $path */}}
+  {{ end }}
+{{ end }}
+```
+
+## Template-to-TypeScript Communication
+
+Pass data via `data-*` attributes - **never use inline JavaScript**:
+
+**Template:**
+
+```html
+<div
+  data-component="api-nav"
+  data-headings="{{ .headings | jsonify | safeHTMLAttr }}"
+  data-scroll-offset="80"
+>
+  {{/* HTML structure only - no onclick handlers */}}
+</div>
+```
+
+The TypeScript component (handled by ts-component-dev agent) will read these attributes.
+
+## File Organization
+
+```
+layouts/
+├── _default/           # Default templates
+├── partials/           # Reusable template fragments
+│   └── api/            # API-specific partials
+├── shortcodes/         # Content shortcodes
+└── TYPE/               # Type-specific templates
+    └── single.html     # Single page template
+
+assets/styles/
+├── styles-default.scss # Main stylesheet
+└── layouts/
+    └── _api-layout.scss # Layout-specific styles
+```
+
+### Partial Naming
+
+- Use descriptive names: `api/sidebar-nav.html`, not `nav.html`
+- Group related partials in subdirectories
+- Include comments at the top describing purpose and required context
+
+## Debugging Templates
+
+### Print Variables for Debugging
+
+```go
+{{/* Temporary debugging - REMOVE before committing */}}
+<pre>{{ printf "%#v" $myVariable }}</pre>
+```
+
+### Enable Verbose Mode
+
+```bash
+npx hugo server --port 1314 --verbose 2>&1 | head -100
+```
+
+### Check Data File Loading
+
+```bash
+cat data/article-data/influxdb/influxdb3-core/articles.yml | head -20
+```
+
+## SASS/CSS Guidelines
+
+### File Organization
+
+- Component styles in `assets/styles/layouts/`
+- Use SASS variables from existing theme
+- Follow mobile-first responsive design
+
+### Naming Conventions
+
+- Use BEM or project conventions
+- Prefix component styles (e.g., `.api-nav`, `.api-toc`)
+- Use state classes: `.is-active`, `.is-open`, `.is-hidden`
+
+### Common Patterns
+
+```scss
+// Component container
+.api-nav {
+  // Base styles
+
+  &-group-header {
+    // Child element
+  }
+
+  &.is-open {
+    // State modifier
+  }
+}
+```
+
+## Workflow
+
+1. **Understand Requirements**
+   - What page type or layout is being modified?
+   - What data does the template need?
+   - Does this require styling changes?
+
+2. **Implement Template**
+   - Use safe data access patterns
+   - Add `data-component` attributes for interactive elements
+   - Do not add inline JavaScript
+
+3. **Add Styling**
+   - Create/modify SCSS files as needed
+   - Follow existing patterns and variables
+
+4. **Test Runtime**
+   - Run Hugo server (not just build)
+   - Verify page renders without errors
+   - Check styling in browser
+
+5. **Clean Up**
+   - Remove debug statements
+   - Stop test server
+
+## Quality Checklist
+
+Before considering template work complete:
+
+- [ ] No inline `<script>` tags or `onclick` handlers in templates
+- [ ] All data access uses safe patterns with `isset` and `index`
+- [ ] Hugo server starts without errors
+- [ ] Target pages render with HTTP 200
+- [ ] Debug statements removed
+- [ ] SCSS follows project conventions
+- [ ] Test server stopped after verification
+
+## Communication Style
+
+- Ask for clarification on data structure if unclear
+- Explain template patterns when they might be unfamiliar
+- Warn about common pitfalls (hyphenated keys, nil access)
+- Always report runtime test results, not just build success
diff --git a/.claude/agents/ts-component-dev.md b/.claude/agents/ts-component-dev.md
new file mode 100644
index 0000000000..2f202d96ea
--- /dev/null
+++ b/.claude/agents/ts-component-dev.md
@@ -0,0 +1,403 @@
+---
+name: ts-component-dev
+description: TypeScript component development specialist for the InfluxData docs-v2 repository. Use this agent for creating/editing TypeScript components that handle user interaction, state management, and DOM manipulation. This agent focuses on behavior and interactivity, not HTML structure or styling.
+tools: ["*"]
+model: sonnet
+---
+
+# TypeScript Component Development Agent
+
+## Purpose
+
+Specialized agent for TypeScript component development in the InfluxData docs-v2 repository. Handles the **behavior and interactivity** layer of the documentation site UI.
+
+## Scope and Responsibilities
+
+### Primary Capabilities
+
+1. **TypeScript Component Implementation**
+   - Create component modules in `assets/js/components/`
+   - Implement user interaction handlers (click, scroll, keyboard)
+   - Manage component state and DOM updates
+   - Handle data parsed from Hugo `data-*` attributes
+
+2. **Component Architecture**
+   - Follow the established component registry pattern
+   - Define TypeScript interfaces for options and data
+   - Export initializer functions for registration
+   - Maintain type safety throughout
+
+3. **Hugo Integration**
+   - Parse data from `data-*` attributes set by Hugo templates
+   - Handle Hugo's security placeholders (`#ZgotmplZ`)
+   - Register components in `main.js` componentRegistry
+
+### Out of Scope (Use hugo-ui-dev agent instead)
+
+- Hugo template HTML structure
+- SASS/CSS styling
+- Data file organization in `data/`
+- Partial and shortcode implementation
+
+## Component Architecture Pattern
+
+### Standard Component Structure
+
+```typescript
+// assets/js/components/my-component.ts
+
+interface MyComponentOptions {
+  component: HTMLElement;
+}
+
+interface MyComponentData {
+  items: string[];
+  scrollOffset: number;
+}
+
+class MyComponent {
+  private container: HTMLElement;
+  private data: MyComponentData;
+
+  constructor(options: MyComponentOptions) {
+    this.container = options.component;
+    this.data = this.parseData();
+    this.init();
+  }
+
+  private parseData(): MyComponentData {
+    const itemsRaw = this.container.dataset.items;
+    const items = itemsRaw && itemsRaw !== '#ZgotmplZ'
+      ? JSON.parse(itemsRaw)
+      : [];
+    const scrollOffset = parseInt(
+      this.container.dataset.scrollOffset || '0',
+      10
+    );
+    return { items, scrollOffset };
+  }
+
+  private init(): void {
+    this.bindEvents();
+  }
+
+  private bindEvents(): void {
+    // Event handlers
+  }
+}
+
+export default function initMyComponent(
+  options: MyComponentOptions
+): MyComponent {
+  return new MyComponent(options);
+}
+```
+
+### Registration in main.js
+
+```javascript
+import initMyComponent from './components/my-component.js';
+
+const componentRegistry = {
+  'my-component': initMyComponent,
+  // ... other components
+};
+```
+
+### HTML Integration (handled by hugo-ui-dev)
+
+```html
+<div
+  data-component="my-component"
+  data-items="{{ .items | jsonify | safeHTMLAttr }}"
+  data-scroll-offset="80"
+>
+  <!-- Structure handled by hugo-ui-dev -->
+</div>
+```
+
+## TypeScript Standards
+
+### Type Safety
+
+```typescript
+// Always define interfaces for component options
+interface ComponentOptions {
+  component: HTMLElement;
+}
+
+// Define interfaces for parsed data
+interface ParsedData {
+  products?: string[];
+  influxdbUrls?: Record<string, string>;
+}
+```
+
+### DOM Type Safety
+
+```typescript
+// Use type assertions for DOM queries
+const input = this.container.querySelector('#search') as HTMLInputElement;
+
+// Check existence before use
+const button = this.container.querySelector('.submit-btn');
+if (button instanceof HTMLButtonElement) {
+  button.disabled = true;
+}
+```
+
+### Event Handling
+
+```typescript
+// Properly type event handlers
+private handleClick = (e: Event): void => {
+  const target = e.target as HTMLElement;
+  if (target.matches('.nav-item')) {
+    this.activateItem(target);
+  }
+};
+
+// Use event delegation
+private bindEvents(): void {
+  this.container.addEventListener('click', this.handleClick);
+}
+
+// Clean up if needed
+public destroy(): void {
+  this.container.removeEventListener('click', this.handleClick);
+}
+```
+
+### Hugo Data Handling
+
+```typescript
+// Handle Hugo's security measures for JSON data
+private parseData(): ParsedData {
+  const rawData = this.container.getAttribute('data-products');
+
+  // Check for Hugo's security placeholder
+  if (rawData && rawData !== '#ZgotmplZ') {
+    try {
+      return JSON.parse(rawData);
+    } catch (error) {
+      console.warn('Failed to parse data:', error);
+      return {};
+    }
+  }
+  return {};
+}
+```
+
+## File Organization
+
+```
+assets/js/
+├── main.js                    # Entry point, component registry
+├── components/
+│   ├── api-nav.ts             # API navigation behavior
+│   ├── api-toc.ts             # Table of contents
+│   ├── api-tabs.ts            # Tab switching
+│   └── api-scalar.ts          # Scalar/RapiDoc integration
+└── utils/
+    ├── dom-helpers.ts         # Shared DOM utilities
+    └── debug-helpers.js       # Debugging utilities
+```
+
+### Naming Conventions
+
+- Component files: `kebab-case.ts` matching the `data-component` value
+- Interfaces: `PascalCase` with descriptive names
+- Private methods: `camelCase` with meaningful verbs
+
+## Development Workflow
+
+### Build Commands
+
+```bash
+# Compile TypeScript
+yarn build:ts
+
+# Watch mode for development
+yarn build:ts:watch
+
+# Type checking without emit
+npx tsc --noEmit
+```
+
+### Development Process
+
+1. **Create Component File**
+   - Define interfaces for options and data
+   - Implement component class
+   - Export initializer function
+
+2. **Register Component**
+   - Import in `main.js` with `.js` extension (Hugo requirement)
+   - Add to `componentRegistry`
+
+3. **Test Component**
+   - Start Hugo server: `npx hugo server`
+   - Open page with component in browser
+   - Use browser DevTools for debugging
+
+4. **Write Cypress Tests**
+   - Create test in `cypress/e2e/content/`
+   - Test user interactions
+   - Verify state changes
+
+## Common Patterns
+
+### Collapsible Sections
+
+```typescript
+private toggleSection(header: HTMLElement): void {
+  const isOpen = header.classList.toggle('is-open');
+  header.setAttribute('aria-expanded', String(isOpen));
+
+  const content = header.nextElementSibling;
+  if (content) {
+    content.classList.toggle('is-open', isOpen);
+  }
+}
+```
+
+### Active State Management
+
+```typescript
+private activateItem(item: HTMLElement): void {
+  // Remove active from siblings
+  this.container
+    .querySelectorAll('.nav-item.is-active')
+    .forEach(el => el.classList.remove('is-active'));
+
+  // Add active to current
+  item.classList.add('is-active');
+}
+```
+
+### Scroll Observation
+
+```typescript
+private observeScrollPosition(): void {
+  const observer = new IntersectionObserver(
+    (entries) => {
+      entries.forEach(entry => {
+        if (entry.isIntersecting) {
+          this.updateActiveSection(entry.target.id);
+        }
+      });
+    },
+    { rootMargin: `-${this.data.scrollOffset}px 0px 0px 0px` }
+  );
+
+  this.sections.forEach(section => observer.observe(section));
+}
+```
+
+## Debugging
+
+### Using Debug Helpers
+
+```typescript
+import { debugLog, debugBreak, debugInspect } from '../utils/debug-helpers.js';
+
+// Log with context
+debugLog('Processing items', 'MyComponent.init');
+
+// Inspect data
+const data = debugInspect(this.data, 'Component Data');
+
+// Add breakpoint
+debugBreak();
+```
+
+### Browser DevTools
+
+- Access registry: `window.influxdatadocs.componentRegistry`
+- Check component initialization in console
+- Use source maps for TypeScript debugging
+
+### TypeScript Compiler
+
+```bash
+# Detailed error reporting
+npx tsc --noEmit --pretty
+
+# Check specific file
+npx tsc --noEmit assets/js/components/my-component.ts
+```
+
+## Testing Requirements
+
+### Cypress E2E Tests
+
+```javascript
+// cypress/e2e/content/my-component.cy.js
+describe('MyComponent', () => {
+  beforeEach(() => {
+    cy.visit('/path/to/page/with/component/');
+  });
+
+  it('initializes correctly', () => {
+    cy.get('[data-component="my-component"]').should('be.visible');
+  });
+
+  it('responds to user interaction', () => {
+    cy.get('.nav-item').first().click();
+    cy.get('.nav-item.is-active').should('have.length', 1);
+  });
+
+  it('updates state on scroll', () => {
+    cy.scrollTo('bottom');
+    cy.get('.toc-item.is-active').should('exist');
+  });
+});
+```
+
+### Run Tests
+
+```bash
+# Run specific test
+node cypress/support/run-e2e-specs.js \
+  --spec "cypress/e2e/content/my-component.cy.js" \
+  content/path/to/page.md
+
+# Run all E2E tests
+yarn test:e2e
+```
+
+## Quality Checklist
+
+Before considering component work complete:
+
+- [ ] Interfaces defined for all options and data
+- [ ] Handles missing/invalid data gracefully
+- [ ] Hugo `#ZgotmplZ` placeholder handled
+- [ ] Event listeners use proper typing
+- [ ] Component registered in `main.js`
+- [ ] TypeScript compiles without errors (`yarn build:ts`)
+- [ ] No `any` types unless absolutely necessary
+- [ ] Cypress tests cover main functionality
+- [ ] Debug statements removed before commit
+- [ ] JSDoc comments on public methods
+
+## Import Requirements
+
+**Critical:** Use `.js` extensions for imports even for TypeScript files - this is required for Hugo's module system:
+
+```typescript
+// Correct
+import { helper } from '../utils/dom-helpers.js';
+
+// Wrong - will fail in Hugo
+import { helper } from '../utils/dom-helpers';
+import { helper } from '../utils/dom-helpers.ts';
+```
+
+## Communication Style
+
+- Ask for clarification on expected behavior
+- Explain component patterns and TypeScript concepts
+- Recommend type-safe approaches over shortcuts
+- Report test results and any type errors
+- Suggest Cypress test scenarios for new features
diff --git a/.claude/agents/ui-dev.md b/.claude/agents/ui-dev.md
deleted file mode 100644
index aeaa0fb9ef..0000000000
--- a/.claude/agents/ui-dev.md
+++ /dev/null
@@ -1,253 +0,0 @@
----
-name: ui-dev
-description: UI TypeScript, Hugo, and SASS (CSS) development specialist for the InfluxData docs-v2 repository
-tools: ["*"]
-author: InfluxData
-version: "1.0"
----
-
-# UI TypeScript & Hugo Development Agent
-
-## Purpose
-
-Specialized agent for TypeScript and Hugo development in the InfluxData docs-v2 repository. Assists with implementing TypeScript for new documentation site features while maintaining compatibility with the existing JavaScript ecosystem.
-
-## Scope and Responsibilities
-
-### Workflow
-
-- Start by verifying a clear understanding of the requested feature or fix.
-- Ask if there's an existing plan to follow.
-- Verify any claimed changes by reading the actual files.
-
-### Primary Capabilities
-
-1. **TypeScript Implementation**
-   - Convert existing JavaScript modules to TypeScript
-   - Implement new features using TypeScript best practices
-   - Maintain type safety while preserving Hugo integration
-   - Configure TypeScript for Hugo's asset pipeline
-
-2. **Component Development**
-   - Create new component-based modules following the established registry pattern
-   - Implement TypeScript interfaces for component options and state
-   - Ensure proper integration with Hugo's data attributes system
-   - Maintain backwards compatibility with existing JavaScript components
-
-3. **Hugo Asset Pipeline Integration**
-   - Configure TypeScript compilation for Hugo's build process
-   - Manage module imports and exports for Hugo's ES6 module system
-   - Optimize TypeScript output for production builds
-   - Handle Hugo template data integration with TypeScript
-
-4. **Testing and Quality Assurance**
-   - Write and maintain Cypress e2e tests for TypeScript components
-   - Configure ESLint rules for TypeScript code
-   - Ensure proper type checking in CI/CD pipeline
-   - Debug TypeScript compilation issues
-
-### Technical Expertise
-
-- **TypeScript Configuration**: Advanced `tsconfig.json` setup for Hugo projects
-- **Component Architecture**: Following the established component registry pattern from `main.js`
-- **Hugo Integration**: Understanding Hugo's asset pipeline and template system
-- **Module Systems**: ES6 modules, imports/exports, and Hugo's asset bundling
-- **Type Definitions**: Creating interfaces for Hugo data, component options, and external libraries
-
-## Current Project Context
-
-### Existing Infrastructure
-
-- **Build System**: Hugo extended with PostCSS and TypeScript compilation
-- **Module Entry Point**: `assets/js/main.js` with component registry pattern
-- **TypeScript Config**: `tsconfig.json` configured for ES2020 with DOM types
-- **Testing**: Cypress for e2e testing, ESLint for code quality
-- **Component Pattern**: Data-attribute based component initialization
-
-### Key Files and Patterns
-
-- **Component Registry**: `main.js` exports `componentRegistry` mapping component names to constructors
-- **Component Pattern**: Components accept `{ component: HTMLElement }` options
-- **Data Attributes**: Components initialized via `data-component` attributes
-- **Module Imports**: ES6 imports with `.js` extensions for Hugo compatibility
-
-### Current TypeScript Usage
-
-- **Single TypeScript File**: `assets/js/influxdb-version-detector.ts`
-- **Build Scripts**: `yarn build:ts` and `yarn build:ts:watch`
-- **Output Directory**: `dist/` (gitignored)
-- **Type Definitions**: Generated `.d.ts` files for all modules
-
-## Development Guidelines
-
-### TypeScript Standards
-
-1. **Type Safety**
-   ```typescript
-   // Always define interfaces for component options
-   interface ComponentOptions {
-     component: HTMLElement;
-     // Add specific component options
-   }
-
-   // Use strict typing for Hugo data
-   interface HugoDataAttribute {
-     products?: string;
-     influxdbUrls?: string;
-   }
-   ```
-
-2. **Component Architecture**
-   ```typescript
-   // Follow the established component pattern
-   class MyComponent {
-     private container: HTMLElement;
-
-     constructor(options: ComponentOptions) {
-       this.container = options.component;
-       this.init();
-     }
-
-     private init(): void {
-       // Component initialization
-     }
-   }
-
-   // Export as component initializer
-   export default function initMyComponent(options: ComponentOptions): MyComponent {
-     return new MyComponent(options);
-   }
-   ```
-
-3. **Hugo Data Integration**
-   ```typescript
-   // Parse Hugo data attributes safely
-   private parseComponentData(): ParsedData {
-     const rawData = this.container.getAttribute('data-products');
-     if (rawData && rawData !== '#ZgotmplZ') {
-       try {
-         return JSON.parse(rawData);
-       } catch (error) {
-         console.warn('Failed to parse data:', error);
-         return {};
-       }
-     }
-     return {};
-   }
-   ```
-
-### File Organization
-
-- **TypeScript Files**: Place in `assets/js/` alongside JavaScript files
-- **Type Definitions**: Auto-generated in `dist/` directory
-- **Naming Convention**: Use same naming as JavaScript files, with `.ts` extension
-- **Imports**: Use `.js` extensions even for TypeScript files (Hugo requirement)
-
-### Integration with Existing System
-
-1. **Component Registry**: Add TypeScript components to the registry in `main.js`
-2. **HTML Integration**: Use `data-component` attributes to initialize components
-3. **Global Namespace**: Expose components via `window.influxdatadocs` if needed
-4. **Backwards Compatibility**: Ensure TypeScript components work with existing patterns
-
-### Testing Requirements
-
-1. **Cypress Tests**: Create e2e tests for TypeScript components
-2. **Type Checking**: Run `tsc --noEmit` in CI pipeline
-3. **ESLint**: Configure TypeScript-specific linting rules
-4. **Manual Testing**: Test components in Hugo development server
-
-## Build and Development Workflow
-
-### Development Commands
-
-```bash
-# Start TypeScript compilation in watch mode
-yarn build:ts:watch
-
-# Start Hugo development server
-npx hugo server
-
-# Run e2e tests
-yarn test:e2e
-
-# Run linting
-yarn lint
-```
-
-### Component Development Process
-
-1. **Create TypeScript Component**
-   - Define interfaces for options and data
-   - Implement component class with proper typing
-   - Export initializer function
-
-2. **Register Component**
-   - Add to `componentRegistry` in `main.js`
-   - Import with `.js` extension (Hugo requirement)
-
-3. **HTML Implementation**
-   - Add `data-component` attribute to trigger elements
-   - Include necessary Hugo data attributes
-
-4. **Testing**
-   - Write Cypress tests for component functionality
-   - Test Hugo data integration
-   - Verify TypeScript compilation
-
-### Common Patterns and Solutions
-
-1. **Hugo Template Data**
-   ```typescript
-   // Handle Hugo's security measures for JSON data
-   if (dataAttribute && dataAttribute !== '#ZgotmplZ') {
-     // Safe to parse
-   }
-   ```
-
-2. **DOM Type Safety**
-   ```typescript
-   // Use type assertions for DOM queries
-   const element = this.container.querySelector('#input') as HTMLInputElement;
-   ```
-
-3. **Event Handling**
-   ```typescript
-   // Properly type event targets
-   private handleClick = (e: Event): void => {
-     const target = e.target as HTMLElement;
-     // Handle event
-   };
-   ```
-
-## Error Handling and Debugging
-
-### Common Issues
-
-1. **Module Resolution**: Use `.js` extensions in imports even for TypeScript files
-2. **Hugo Data Attributes**: Handle `#ZgotmplZ` security placeholders
-3. **Type Definitions**: Ensure proper typing for external libraries used in Hugo context
-4. **Compilation Errors**: Check `tsconfig.json` settings for Hugo compatibility
-
-### Debugging Tools
-
-- **VS Code TypeScript**: Use built-in TypeScript language server
-- **Hugo DevTools**: Browser debugging with source maps
-- **Component Registry**: Access `window.influxdatadocs.componentRegistry` for debugging
-- **TypeScript Compiler**: Use `tsc --noEmit --pretty` for detailed error reporting
-
-## Future Considerations
-
-### Migration Strategy
-
-1. **Gradual Migration**: Convert JavaScript modules to TypeScript incrementally
-2. **Type Definitions**: Add type definitions for existing JavaScript modules
-3. **Shared Interfaces**: Create common interfaces for Hugo data and component patterns
-4. **Documentation**: Update component documentation with TypeScript examples
-
-### Enhancement Opportunities
-
-1. **Strict Type Checking**: Enable stricter TypeScript compiler options
-2. **Advanced Types**: Use utility types for Hugo-specific patterns
-3. **Build Optimization**: Optimize TypeScript compilation for Hugo builds
-4. **Developer Experience**: Improve tooling and IDE support for Hugo + TypeScript development
\ No newline at end of file
diff --git a/.claude/agents/ui-testing.md b/.claude/agents/ui-testing.md
new file mode 100644
index 0000000000..eea687edb3
--- /dev/null
+++ b/.claude/agents/ui-testing.md
@@ -0,0 +1,442 @@
+---
+name: ui-testing
+description: UI testing specialist for the InfluxData docs-v2 repository using Cypress. Use this agent for writing, debugging, and running E2E tests for documentation UI components, page rendering, navigation, and interactive features.
+tools: ["*"]
+model: sonnet
+---
+
+# UI Testing Agent
+
+## Purpose
+
+Specialized agent for Cypress E2E testing in the InfluxData docs-v2 repository. Handles test creation, debugging, and validation of UI components and documentation pages.
+
+## Scope and Responsibilities
+
+### Primary Capabilities
+
+1. **Cypress Test Development**
+   - Write E2E tests for UI components and features
+   - Test page rendering and navigation
+   - Validate interactive elements and state changes
+   - Test responsive behavior and accessibility
+
+2. **Test Debugging**
+   - Diagnose failing tests
+   - Fix flaky tests and timing issues
+   - Improve test reliability and performance
+
+3. **Test Infrastructure**
+   - Configure Cypress for specific test scenarios
+   - Create reusable test utilities and commands
+   - Manage test fixtures and data
+
+### Out of Scope
+
+- Hugo template implementation (use hugo-ui-dev agent)
+- TypeScript component code (use ts-component-dev agent)
+- CI/CD pipeline configuration (use ci-automation-engineer agent)
+
+## Running Tests
+
+### Basic Test Commands
+
+```bash
+# Run specific test file against content file
+node cypress/support/run-e2e-specs.js \
+  --spec "cypress/e2e/content/my-test.cy.js" \
+  content/path/to/page.md
+
+# Run against a URL (for running server)
+node cypress/support/run-e2e-specs.js \
+  --spec "cypress/e2e/content/my-test.cy.js" \
+  http://localhost:<port>/path/to/page/
+
+# Run all E2E tests
+yarn test:e2e
+
+# Run shortcode example tests
+yarn test:shortcode-examples
+```
+
+### Test File Organization
+
+```
+cypress/
+├── e2e/
+│   └── content/
+│       ├── index.cy.js           # General content tests
+│       ├── api-reference.cy.js   # API docs tests
+│       ├── navigation.cy.js      # Navigation tests
+│       └── my-component.cy.js    # Component-specific tests
+├── fixtures/
+│   └── test-data.json            # Test data files
+├── support/
+│   ├── commands.js               # Custom Cypress commands
+│   ├── e2e.js                    # E2E support file
+│   └── run-e2e-specs.js          # Test runner script
+└── cypress.config.js             # Cypress configuration
+```
+
+## Writing Tests
+
+### Basic Test Structure
+
+```javascript
+describe('Feature Name', () => {
+  beforeEach(() => {
+    cy.visit('/path/to/page/');
+  });
+
+  it('describes expected behavior', () => {
+    cy.get('.selector').should('be.visible');
+    cy.get('.button').click();
+    cy.get('.result').should('contain', 'expected text');
+  });
+});
+```
+
+### Component Testing Pattern
+
+```javascript
+describe('API Navigation Component', () => {
+  beforeEach(() => {
+    cy.visit('/influxdb3/core/reference/api/');
+  });
+
+  describe('Initial State', () => {
+    it('renders navigation container', () => {
+      cy.get('[data-component="api-nav"]').should('exist');
+    });
+
+    it('displays all navigation groups', () => {
+      cy.get('.api-nav-group').should('have.length.at.least', 1);
+    });
+  });
+
+  describe('User Interactions', () => {
+    it('expands group on header click', () => {
+      cy.get('.api-nav-group-header').first().as('header');
+      cy.get('@header').click();
+      cy.get('@header').should('have.attr', 'aria-expanded', 'true');
+      cy.get('@header').next('.api-nav-group-items')
+        .should('be.visible');
+    });
+
+    it('collapses expanded group on second click', () => {
+      cy.get('.api-nav-group-header').first().as('header');
+      cy.get('@header').click(); // expand
+      cy.get('@header').click(); // collapse
+      cy.get('@header').should('have.attr', 'aria-expanded', 'false');
+    });
+  });
+
+  describe('Keyboard Navigation', () => {
+    it('supports Enter key to toggle', () => {
+      cy.get('.api-nav-group-header').first()
+        .focus()
+        .type('{enter}');
+      cy.get('.api-nav-group-header').first()
+        .should('have.attr', 'aria-expanded', 'true');
+    });
+  });
+});
+```
+
+### Page Layout Testing
+
+```javascript
+describe('API Reference Page Layout', () => {
+  beforeEach(() => {
+    cy.visit('/influxdb3/core/reference/api/');
+  });
+
+  it('displays 3-column layout on desktop', () => {
+    cy.viewport(1280, 800);
+    cy.get('.sidebar').should('be.visible');
+    cy.get('.api-content').should('be.visible');
+    cy.get('.api-toc').should('be.visible');
+  });
+
+  it('collapses to single column on mobile', () => {
+    cy.viewport(375, 667);
+    cy.get('.sidebar').should('not.be.visible');
+    cy.get('.api-content').should('be.visible');
+  });
+});
+```
+
+### Tab Component Testing
+
+```javascript
+describe('Tab Navigation', () => {
+  beforeEach(() => {
+    cy.visit('/page/with/tabs/');
+  });
+
+  it('shows first tab content by default', () => {
+    cy.get('.tab-content').first().should('be.visible');
+    cy.get('.tab-content').eq(1).should('not.be.visible');
+  });
+
+  it('switches tab content on click', () => {
+    cy.get('.tabs a').eq(1).click();
+    cy.get('.tab-content').first().should('not.be.visible');
+    cy.get('.tab-content').eq(1).should('be.visible');
+  });
+
+  it('updates active tab styling', () => {
+    cy.get('.tabs a').eq(1).click();
+    cy.get('.tabs a').first().should('not.have.class', 'is-active');
+    cy.get('.tabs a').eq(1).should('have.class', 'is-active');
+  });
+});
+```
+
+### Scroll Behavior Testing
+
+```javascript
+describe('Table of Contents Scroll Sync', () => {
+  beforeEach(() => {
+    cy.visit('/page/with/toc/');
+  });
+
+  it('highlights current section in TOC on scroll', () => {
+    // Scroll to a specific section
+    cy.get('#section-two').scrollIntoView();
+
+    // Wait for scroll handler
+    cy.wait(100);
+
+    // Verify TOC highlight
+    cy.get('.toc-nav a[href="#section-two"]')
+      .should('have.class', 'is-active');
+  });
+
+  it('scrolls to section when TOC link clicked', () => {
+    cy.get('.toc-nav a[href="#section-three"]').click();
+    cy.get('#section-three').should('be.visible');
+  });
+});
+```
+
+## Common Testing Patterns
+
+### Waiting for Dynamic Content
+
+```javascript
+// Wait for element to appear
+cy.get('.dynamic-content', { timeout: 10000 }).should('exist');
+
+// Wait for network request
+cy.intercept('GET', '/api/data').as('getData');
+cy.wait('@getData');
+
+// Wait for animation
+cy.get('.animated-element').should('be.visible');
+cy.wait(300); // animation duration
+```
+
+### Testing Data Attributes
+
+```javascript
+it('component receives correct data', () => {
+  cy.get('[data-component="my-component"]')
+    .should('have.attr', 'data-items')
+    .and('not.be.empty')
+    .and('not.equal', '#ZgotmplZ');
+});
+```
+
+### Testing Accessibility
+
+```javascript
+describe('Accessibility', () => {
+  it('has proper ARIA attributes', () => {
+    cy.get('.expandable-header')
+      .should('have.attr', 'aria-expanded');
+    cy.get('.nav-item')
+      .should('have.attr', 'role', 'menuitem');
+  });
+
+  it('is keyboard navigable', () => {
+    cy.get('.nav-item').first().focus();
+    cy.focused().type('{downarrow}');
+    cy.focused().should('have.class', 'nav-item');
+  });
+});
+```
+
+### Testing Responsive Behavior
+
+```javascript
+const viewports = [
+  { name: 'mobile', width: 375, height: 667 },
+  { name: 'tablet', width: 768, height: 1024 },
+  { name: 'desktop', width: 1280, height: 800 },
+];
+
+viewports.forEach(({ name, width, height }) => {
+  describe(`${name} viewport`, () => {
+    beforeEach(() => {
+      cy.viewport(width, height);
+      cy.visit('/path/to/page/');
+    });
+
+    it('renders correctly', () => {
+      cy.get('.main-content').should('be.visible');
+    });
+  });
+});
+```
+
+## Debugging Failing Tests
+
+### Enable Debug Mode
+
+```javascript
+// Add .debug() to pause and inspect
+cy.get('.element').debug().should('be.visible');
+
+// Log intermediate values
+cy.get('.element').then($el => {
+  cy.log('Element classes:', $el.attr('class'));
+});
+```
+
+### Screenshot on Failure
+
+```javascript
+// Automatic (configure in cypress.config.js)
+screenshotOnRunFailure: true
+
+// Manual screenshot
+cy.screenshot('debug-state');
+```
+
+### Interactive Mode
+
+```bash
+# Open Cypress Test Runner for interactive debugging
+npx cypress open
+```
+
+### Common Issues
+
+**Timing Issues:**
+
+```javascript
+// Wrong - may fail due to timing
+cy.get('.element').click();
+cy.get('.result').should('exist');
+
+// Better - wait for element
+cy.get('.element').click();
+cy.get('.result', { timeout: 5000 }).should('exist');
+```
+
+**Element Not Interactable:**
+
+```javascript
+// Force click when element is covered
+cy.get('.element').click({ force: true });
+
+// Scroll into view first
+cy.get('.element').scrollIntoView().click();
+```
+
+**Stale Element Reference:**
+
+```javascript
+// Re-query element after DOM changes
+cy.get('.container').within(() => {
+  cy.get('.item').click();
+  cy.get('.item').should('have.class', 'active'); // Re-queries
+});
+```
+
+## Custom Commands
+
+### Creating Custom Commands
+
+```javascript
+// cypress/support/commands.js
+
+// Check page loads without errors
+Cypress.Commands.add('pageLoadsSuccessfully', () => {
+  cy.get('body').should('exist');
+  cy.get('.error-page').should('not.exist');
+});
+
+// Visit and wait for component
+Cypress.Commands.add('visitWithComponent', (url, component) => {
+  cy.visit(url);
+  cy.get(`[data-component="${component}"]`).should('exist');
+});
+
+// Expand all collapsible sections
+Cypress.Commands.add('expandAllSections', () => {
+  cy.get('[aria-expanded="false"]').each($el => {
+    cy.wrap($el).click();
+  });
+});
+```
+
+### Using Custom Commands
+
+```javascript
+describe('My Test', () => {
+  it('uses custom commands', () => {
+    cy.visitWithComponent('/api/', 'api-nav');
+    cy.expandAllSections();
+    cy.pageLoadsSuccessfully();
+  });
+});
+```
+
+## Test Data Management
+
+### Fixtures
+
+```json
+// cypress/fixtures/api-endpoints.json
+{
+  "endpoints": [
+    { "path": "/write", "method": "POST" },
+    { "path": "/query", "method": "GET" }
+  ]
+}
+```
+
+```javascript
+// Using fixtures
+cy.fixture('api-endpoints').then((data) => {
+  data.endpoints.forEach(endpoint => {
+    it(`documents ${endpoint.method} ${endpoint.path}`, () => {
+      cy.contains(`${endpoint.method} ${endpoint.path}`).should('exist');
+    });
+  });
+});
+```
+
+## Quality Checklist
+
+Before considering tests complete:
+
+- [ ] Tests cover main user flows
+- [ ] Tests are reliable (no flaky failures)
+- [ ] Appropriate timeouts for async operations
+- [ ] Meaningful assertions with clear failure messages
+- [ ] Tests organized by feature/component
+- [ ] Common patterns extracted to custom commands
+- [ ] Tests run successfully: `node cypress/support/run-e2e-specs.js --spec "path/to/test.cy.js" content/path.md`
+- [ ] No hardcoded waits (use cy.wait() with aliases or assertions)
+- [ ] Accessibility attributes tested where applicable
+
+## Communication Style
+
+- Report test results clearly (pass/fail counts)
+- Explain failure reasons and debugging steps
+- Suggest test coverage improvements
+- Recommend patterns for common scenarios
+- Ask for clarification on expected behavior when writing new tests
diff --git a/.claude/skills/hugo-template-dev/SKILL.md b/.claude/skills/hugo-template-dev/SKILL.md
new file mode 100644
index 0000000000..db71e1a99c
--- /dev/null
+++ b/.claude/skills/hugo-template-dev/SKILL.md
@@ -0,0 +1,508 @@
+---
+name: hugo-template-dev
+description: Hugo template development skill for InfluxData docs-v2. Enforces proper build and runtime testing to catch template errors that build-only validation misses.
+author: InfluxData
+version: "1.0"
+---
+
+# Hugo Template Development Skill
+
+## Purpose
+
+This skill enforces proper Hugo template development practices, including **mandatory runtime testing** to catch errors that static builds miss.
+
+## Critical Testing Requirement
+
+**Hugo's `npx hugo --quiet` only validates template syntax, not runtime execution.**
+
+Template errors like accessing undefined fields, nil values, or incorrect type assertions only appear when Hugo actually renders pages. You MUST test templates by running the server.
+
+## Mandatory Testing Protocol
+
+### For ANY Hugo Template Change
+
+After modifying files in `layouts/`, `layouts/partials/`, or `layouts/shortcodes/`:
+
+```bash
+# Step 1: Start Hugo server and capture output
+npx hugo server --port 1314 2>&1 | head -50
+```
+
+**Success criteria:**
+
+- No `error calling partial` messages
+- No `can't evaluate field` errors
+- No `template: ... failed` messages
+- Server shows "Web Server is available at <http://localhost:1314/>"
+
+**If errors appear:** Fix the template and repeat Step 1 before proceeding.
+
+```bash
+# Step 2: Verify the page renders (only after Step 1 passes)
+curl -s -o /dev/null -w "%{http_code}" http://localhost:1314/PATH/TO/PAGE/
+```
+
+**Expected:** HTTP 200 status code
+
+```bash
+# Step 3: Stop the test server
+pkill -f "hugo server --port 1314"
+```
+
+### Quick Test Command
+
+Use this one-liner to test and get immediate feedback:
+
+```bash
+timeout 15 npx hugo server --port 1314 2>&1 | grep -E "(error|Error|ERROR|fail|FAIL)" | head -20; pkill -f "hugo server --port 1314" 2>/dev/null
+```
+
+If output is empty, no errors were detected.
+
+## Common Hugo Template Errors
+
+### 1. Accessing Hyphenated Keys
+
+**Wrong:**
+
+```go
+{{ .Site.Data.article-data.influxdb }}
+```
+
+**Correct:**
+
+```go
+{{ index .Site.Data "article-data" "influxdb" }}
+```
+
+### 2. Nil Field Access
+
+**Wrong:**
+
+```go
+{{ range $articles }}
+  {{ .path }}  {{/* Fails if item is nil or wrong type */}}
+{{ end }}
+```
+
+**Correct:**
+
+```go
+{{ range $articles }}
+  {{ if . }}
+    {{ with index . "path" }}
+      {{ . }}
+    {{ end }}
+  {{ end }}
+{{ end }}
+```
+
+### 3. Type Assertion on Interface{}
+
+**Wrong:**
+
+```go
+{{ range $data }}
+  {{ .fields.menuName }}
+{{ end }}
+```
+
+**Correct:**
+
+```go
+{{ range $data }}
+  {{ if isset . "fields" }}
+    {{ $fields := index . "fields" }}
+    {{ if isset $fields "menuName" }}
+      {{ index $fields "menuName" }}
+    {{ end }}
+  {{ end }}
+{{ end }}
+```
+
+### 4. Empty Map vs Nil Check
+
+**Problem:** Hugo's `{{ if . }}` passes for empty maps `{}`:
+
+```go
+{{/* This doesn't catch empty maps */}}
+{{ if $data }}
+  {{ .field }}  {{/* Still fails if $data is {} */}}
+{{ end }}
+```
+
+**Solution:** Check for specific keys:
+
+```go
+{{ if and $data (isset $data "field") }}
+  {{ index $data "field" }}
+{{ end }}
+```
+
+## Hugo Data Access Patterns
+
+### Safe Nested Access
+
+```go
+{{/* Build up access with nil checks at each level */}}
+{{ $articleDataRoot := index .Site.Data "article-data" }}
+{{ if $articleDataRoot }}
+  {{ $influxdbData := index $articleDataRoot "influxdb" }}
+  {{ if $influxdbData }}
+    {{ $productData := index $influxdbData $dataKey }}
+    {{ if $productData }}
+      {{ with $productData.articles }}
+        {{/* Safe to use . here */}}
+      {{ end }}
+    {{ end }}
+  {{ end }}
+{{ end }}
+```
+
+### Iterating Over Data Safely
+
+```go
+{{ range $idx, $item := $articles }}
+  {{/* Declare variables with defaults */}}
+  {{ $path := "" }}
+  {{ $name := "" }}
+
+  {{/* Safely extract values */}}
+  {{ if isset $item "path" }}
+    {{ $path = index $item "path" }}
+  {{ end }}
+
+  {{ if $path }}
+    {{/* Now safe to use $path */}}
+  {{ end }}
+{{ end }}
+```
+
+## File Organization
+
+### Layouts Directory Structure
+
+```
+layouts/
+├── _default/           # Default templates
+├── partials/           # Reusable template fragments
+│   └── api/            # API-specific partials
+├── shortcodes/         # Content shortcodes
+└── TYPE/               # Type-specific templates (api/, etc.)
+    └── single.html     # Single page template
+```
+
+### Partial Naming
+
+- Use descriptive names: `api/sidebar-nav.html`, not `nav.html`
+- Group related partials in subdirectories
+- Include comments at the top describing purpose and required context
+
+## Separation of Concerns: Templates vs TypeScript
+
+**Principle:** Hugo templates handle structure and data binding. TypeScript handles behavior and interactivity.
+
+### What Goes Where
+
+| Concern          | Location                    | Example                             |
+| ---------------- | --------------------------- | ----------------------------------- |
+| HTML structure   | `layouts/**/*.html`         | Navigation markup, tab containers   |
+| Data binding     | `layouts/**/*.html`         | `{{ .Title }}`, `{{ range .Data }}` |
+| Static styling   | `assets/styles/**/*.scss`   | Layout, colors, typography          |
+| User interaction | `assets/js/components/*.ts` | Click handlers, scroll behavior     |
+| State management | `assets/js/components/*.ts` | Active tabs, collapsed sections     |
+| DOM manipulation | `assets/js/components/*.ts` | Show/hide, class toggling           |
+
+### Anti-Pattern: Inline JavaScript in Templates
+
+**Wrong - JavaScript mixed with template:**
+
+```html
+{{/* DON'T DO THIS */}}
+<nav class="api-nav">
+  {{ range $articles }}
+    <button onclick="toggleSection('{{ .id }}')">{{ .name }}</button>
+  {{ end }}
+</nav>
+
+<script>
+function toggleSection(id) {
+  document.getElementById(id).classList.toggle('is-open');
+}
+</script>
+```
+
+**Correct - Clean separation:**
+
+Template (`layouts/partials/api/sidebar-nav.html`):
+
+```html
+<nav class="api-nav" data-component="api-nav">
+  {{ range $articles }}
+    <button class="api-nav-group-header" aria-expanded="false">
+      {{ .name }}
+    </button>
+    <ul class="api-nav-group-items">
+      {{/* items */}}
+    </ul>
+  {{ end }}
+</nav>
+```
+
+TypeScript (`assets/js/components/api-nav.ts`):
+
+```typescript
+interface ApiNavOptions {
+  component: HTMLElement;
+}
+
+export default function initApiNav({ component }: ApiNavOptions): void {
+  const headers = component.querySelectorAll('.api-nav-group-header');
+
+  headers.forEach((header) => {
+    header.addEventListener('click', () => {
+      const isOpen = header.classList.toggle('is-open');
+      header.setAttribute('aria-expanded', String(isOpen));
+      header.nextElementSibling?.classList.toggle('is-open', isOpen);
+    });
+  });
+}
+```
+
+Register in `main.js`:
+
+```javascript
+import initApiNav from './components/api-nav.js';
+
+const componentRegistry = {
+  'api-nav': initApiNav,
+  // ... other components
+};
+```
+
+### Data Passing Pattern
+
+Pass Hugo data to TypeScript via `data-*` attributes:
+
+Template:
+
+```html
+<div
+  data-component="api-toc"
+  data-headings="{{ .headings | jsonify | safeHTMLAttr }}"
+  data-scroll-offset="80"
+>
+</div>
+```
+
+TypeScript:
+
+```typescript
+interface TocOptions {
+  component: HTMLElement;
+}
+
+interface TocData {
+  headings: string[];
+  scrollOffset: number;
+}
+
+function parseData(component: HTMLElement): TocData {
+  const headingsRaw = component.dataset.headings;
+  const headings = headingsRaw ? JSON.parse(headingsRaw) : [];
+  const scrollOffset = parseInt(component.dataset.scrollOffset || '0', 10);
+
+  return { headings, scrollOffset };
+}
+
+export default function initApiToc({ component }: TocOptions): void {
+  const data = parseData(component);
+  // Use data.headings and data.scrollOffset
+}
+```
+
+### Minimal Inline Scripts (Exception)
+
+The **only** acceptable inline scripts are minimal initialization that MUST run before component registration:
+
+```html
+{{/* Acceptable: Critical path, no logic, runs immediately */}}
+<script>
+  document.documentElement.dataset.theme =
+    localStorage.getItem('theme') || 'light';
+</script>
+```
+
+Everything else belongs in `assets/js/`.
+
+### File Organization for Components
+
+```
+assets/
+├── js/
+│   ├── main.js                    # Entry point, component registry
+│   ├── components/
+│   │   ├── api-nav.ts             # API navigation behavior
+│   │   ├── api-toc.ts             # Table of contents
+│   │   ├── api-tabs.ts            # Tab switching (if needed beyond CSS)
+│   │   └── api-scalar.ts          # Scalar/RapiDoc integration
+│   └── utils/
+│       └── dom-helpers.ts         # Shared DOM utilities
+└── styles/
+    └── layouts/
+        └── _api-layout.scss       # API-specific styles
+```
+
+### TypeScript Component Checklist
+
+When creating a new interactive feature:
+
+1. [ ] Create TypeScript file in `assets/js/components/`
+2. [ ] Define interface for component options
+3. [ ] Export default initializer function
+4. [ ] Register in `main.js` componentRegistry
+5. [ ] Add `data-component` attribute to HTML element
+6. [ ] Pass data via `data-*` attributes (not inline JS)
+7. [ ] Write Cypress tests for the component
+8. [ ] **NO inline `<script>` tags in templates**
+
+## Debugging Templates
+
+### Enable Verbose Mode
+
+```bash
+npx hugo server --port 1314 --verbose 2>&1 | head -100
+```
+
+### Print Variables for Debugging
+
+```go
+{{/* Temporary debugging - REMOVE before committing */}}
+<pre>{{ printf "%#v" $myVariable }}</pre>
+```
+
+### Check Data File Loading
+
+```bash
+# Verify data files exist and are valid YAML
+cat data/article-data/influxdb/influxdb3-core/articles.yml | head -20
+```
+
+## Integration with CI/CD
+
+### Pre-commit Hook (Recommended)
+
+Add to `.lefthook.yml` or pre-commit configuration:
+
+```yaml
+pre-commit:
+  commands:
+    hugo-template-test:
+      glob: "layouts/**/*.html"
+      run: |
+        timeout 20 npx hugo server --port 1314 2>&1 | grep -E "error|Error" && exit 1 || exit 0
+        pkill -f "hugo server --port 1314" 2>/dev/null
+```
+
+### GitHub Actions Workflow
+
+```yaml
+- name: Test Hugo templates
+  run: |
+    npx hugo server --port 1314 &
+    sleep 10
+    curl -f http://localhost:1314/ || exit 1
+    pkill -f hugo
+```
+
+### Cypress E2E Tests for UI Features
+
+After template changes that affect UI functionality, run Cypress tests to verify:
+
+**Run a specific test file against a content page:**
+
+```bash
+node cypress/support/run-e2e-specs.js \
+  --spec "cypress/e2e/content/api-reference.cy.js" \
+  content/influxdb3/core/reference/api/_index.md
+```
+
+**Run tests against a URL (for deployed or running server):**
+
+```bash
+node cypress/support/run-e2e-specs.js \
+  --spec "cypress/e2e/content/api-reference.cy.js" \
+  http://localhost:<port>/influxdb3/core/reference/api/
+```
+
+**Example Cypress test structure for API reference:**
+
+```javascript
+// cypress/e2e/content/api-reference.cy.js
+describe('API Reference Documentation', () => {
+  beforeEach(() => {
+    cy.visit('/influxdb3/core/reference/api/');
+  });
+
+  it('displays 3-column layout with sidebar, content, and TOC', () => {
+    cy.get('.sidebar').should('be.visible');
+    cy.get('.api-content').should('be.visible');
+    cy.get('.api-toc').should('be.visible');
+  });
+
+  it('switches tabs correctly', () => {
+    cy.get('.tabs a').contains('Authentication').click();
+    cy.get('.tab-content').contains('Bearer Token').should('be.visible');
+  });
+
+  it('displays API navigation in sidebar', () => {
+    cy.get('.api-nav').should('be.visible');
+    cy.get('.api-nav').contains('API v3');
+  });
+
+  it('TOC updates highlight on scroll', () => {
+    cy.get('.api-toc-nav a').first().click();
+    cy.get('.api-toc-nav a.is-active').should('exist');
+  });
+});
+```
+
+**Integrate Cypress into development workflow:**
+
+1. Create test file in `cypress/e2e/content/` for your feature
+2. Run tests after template changes to verify UI behavior
+3. Include test execution in PR checklist
+
+**Quick Cypress commands:**
+
+| Purpose                | Command                                                                                     |
+| ---------------------- | ------------------------------------------------------------------------------------------- |
+| Run specific spec      | `node cypress/support/run-e2e-specs.js --spec "path/to/spec.cy.js" content/path/to/page.md` |
+| Run all E2E tests      | `yarn test:e2e`                                                                             |
+| Run shortcode examples | `yarn test:shortcode-examples`                                                              |
+
+## Quick Reference
+
+| Action                    | Command                                                              |
+| ------------------------- | -------------------------------------------------------------------- |
+| Test templates (runtime)  | `npx hugo server --port 1314 2>&1 \| head -50`                       |
+| Build only (insufficient) | `npx hugo --quiet`                                                   |
+| Check specific page       | `curl -s -o /dev/null -w "%{http_code}" http://localhost:1314/path/` |
+| Stop test server          | `pkill -f "hugo server --port 1314"`                                 |
+| Debug data access         | `<pre>{{ printf "%#v" $var }}</pre>`                                 |
+
+## Remember
+
+1. **Never trust `npx hugo --quiet` alone** - it only checks syntax
+2. **Always run the server** to test template changes
+3. **Check error output first** before declaring success
+4. **Use `isset` and `index`** for safe data access
+5. **Hyphenated keys require `index` function** - dot notation fails
+
+## Related Agents
+
+This skill focuses on Hugo template development practices. For specialized tasks, use:
+
+- **hugo-ui-dev** - Hugo templates and SASS/CSS styling
+- **ts-component-dev** - TypeScript component behavior and interactivity
+- **ui-testing** - Cypress E2E testing for UI components
diff --git a/.gitignore b/.gitignore
index 5b5487a3d5..7a973e3116 100644
--- a/.gitignore
+++ b/.gitignore
@@ -12,8 +12,20 @@ package-lock.json
 
 # Content generation
 /content/influxdb*/**/api/**/*.html
+/content/influxdb*/**/api/**/*.md
 !api-docs/**/.config.yml
 /api-docs/redoc-static.html*
+
+# API documentation generation (generated by api-docs/scripts/)
+/content/influxdb/*/api/**
+/content/influxdb3/*/api/**
+/content/influxdb3/*/reference/api/**
+/static/openapi
+
+# Exception: hand-crafted API conceptual pages (not generated)
+!/content/influxdb3/*/api/administration/
+!/content/influxdb3/*/api/administration/_index.md
+
 /helper-scripts/output/*
 /telegraf-build
 !telegraf-build/templates
@@ -38,6 +50,8 @@ tmp
 
 # TypeScript build output
 **/dist/
+# Exception: include compiled API doc scripts for easier use
+!api-docs/scripts/dist/
 **/dist-lambda/
 
 # User context files for AI assistant tools
diff --git a/api-docs/influxdb3/core/v3/ref.yml b/api-docs/influxdb3/core/v3/ref.yml
index 2d8a66b4ad..8a2d1d1031 100644
--- a/api-docs/influxdb3/core/v3/ref.yml
+++ b/api-docs/influxdb3/core/v3/ref.yml
@@ -49,12 +49,13 @@ tags:
       Depending on your workflow, use one of the following schemes to authenticate to the InfluxDB 3 API:
 
       | Authentication scheme | Works with |
-      |:-------------------|:-----------|
-      | [Bearer authentication](#section/Authentication/BearerAuthentication) | All endpoints |
-      | [Token authentication](#section/Authentication/TokenAuthentication) | v1, v2 endpoints |
-      | [Basic authentication](#section/Authentication/BasicAuthentication) | v1 endpoints |
-      | [Querystring authentication](#section/Authentication/QuerystringAuthentication) | v1 endpoints |
-      <!-- ReDoc-Inject: <security-definitions> -->
+      |:----------------------|:-----------|
+      | Bearer authentication | All endpoints |
+      | Token authentication  | v1, v2 endpoints |
+      | Basic authentication  | v1 endpoints |
+      | Querystring authentication | v1 endpoints |
+
+      See the **Security Schemes** section below for details on each authentication method.
     x-traitTag: true
   - name: Cache data
     description: |
@@ -89,33 +90,20 @@ tags:
 
       - [Manage the Distinct Value Cache](/influxdb3/core/admin/distinct-value-cache/)
       - [Manage the Last Value Cache](/influxdb3/core/admin/last-value-cache/)
-  - name: Compatibility endpoints
+  - name: Migrate from InfluxDB v1 or v2
+    x-traitTag: true
     description: |
-      InfluxDB 3 provides compatibility endpoints for InfluxDB 1.x and InfluxDB 2.x workloads and clients.
-
-      ### Write data using v1- or v2-compatible endpoints
-
-      - [`/api/v2/write` endpoint](#operation/PostV2Write)
-          for InfluxDB v2 clients and when you bring existing InfluxDB v2 write workloads to InfluxDB 3.
-      - [`/write` endpoint](#operation/PostV1Write) for InfluxDB v1 clients and when you bring existing InfluxDB v1 write workloads to InfluxDB 3.
-
-      For new workloads, use the [`/api/v3/write_lp` endpoint](#operation/PostWriteLP).
-
-      All endpoints accept the same line protocol format.
-
-      ### Query data
-
-      Use the HTTP [`/query`](#operation/GetV1ExecuteQuery) endpoint for InfluxDB v1 clients and v1 query workloads using InfluxQL.
-
-      For new workloads, use one of the following:
+      Migrate your existing InfluxDB v1 or v2 workloads to InfluxDB 3.
 
-      - HTTP [`/api/v3/query_sql` endpoint](#operation/GetExecuteQuerySQL) for new query workloads using SQL.
-      - HTTP [`/api/v3/query_influxql` endpoint](#operation/GetExecuteInfluxQLQuery) for new query workloads using InfluxQL.
-      - Flight SQL and InfluxDB 3 _Flight+gRPC_ APIs for querying with SQL or InfluxQL. For more information about using Flight APIs, see [InfluxDB 3 client libraries](https://github.com/InfluxCommunity?q=influxdb3&type=public&language=&sort=).
+      InfluxDB 3 provides compatibility endpoints that work with InfluxDB 1.x and 2.x client libraries and tools.
+      Operations marked with <span class="api-compat-badge api-compat-badge--v1">v1</span> or <span class="api-compat-badge api-compat-badge--v2">v2</span> badges are compatible with the respective InfluxDB version.
 
-      ### Server information
+      ### Migration guides
 
-      Server information endpoints such as `/health` and `metrics` are compatible with InfluxDB 1.x and InfluxDB 2.x clients.
+      - [Migrate from InfluxDB v1](/influxdb3/core/guides/migrate/influxdb-1x/) - For users migrating from InfluxDB 1.x
+      - [Migrate from InfluxDB v2](/influxdb3/core/guides/migrate/influxdb-2x/) - For users migrating from InfluxDB 2.x or Cloud
+      - [Use compatibility APIs to write data](/influxdb3/core/write-data/http-api/compatibility-apis/) - v1 and v2 write endpoints
+      - [Use the v1 HTTP query API](/influxdb3/core/query-data/execute-queries/influxdb-v1-api/) - InfluxQL queries via HTTP
   - name: Database
     description: Manage databases
   - description: |
@@ -201,7 +189,7 @@ tags:
     description: Retrieve server metrics, status, and version information
   - name: Table
     description: Manage table schemas and data
-  - name: Token
+  - name: Auth token
     description: Manage tokens for authentication and authorization
   - name: Write data
     description: |
@@ -229,17 +217,13 @@ paths:
     post:
       operationId: PostV1Write
       summary: Write line protocol (v1-compatible)
+      x-compatibility-version: v1
       description: |
         Writes line protocol to the specified database.
-
-        This endpoint provides backward compatibility for InfluxDB 1.x write workloads using tools such as InfluxDB 1.x client libraries, the Telegraf `outputs.influxdb` output plugin, or third-party tools.
-
-        Use this endpoint to send data in [line protocol](https://docs.influxdata.com/influxdb3/core/reference/syntax/line-protocol/) format to InfluxDB.
-        Use query parameters to specify options for writing data.
-
-        #### Related
-
-        - [Use compatibility APIs to write data](/influxdb3/core/write-data/http-api/compatibility-apis/)
+        Use this endpoint to send data in [line protocol](/influxdb3/core/reference/syntax/line-protocol/) format to InfluxDB.
+      externalDocs:
+        description: Use compatibility APIs to write data
+        url: /influxdb3/core/write-data/http-api/compatibility-apis/
       parameters:
         - $ref: '#/components/parameters/dbWriteParam'
         - $ref: '#/components/parameters/compatibilityPrecisionParam'
@@ -343,7 +327,6 @@ paths:
         '413':
           description: Request entity too large.
       tags:
-        - Compatibility endpoints
         - Write data
       x-influxdata-guides:
         - title: Use compatibility APIs to write data
@@ -352,17 +335,13 @@ paths:
     post:
       operationId: PostV2Write
       summary: Write line protocol (v2-compatible)
+      x-compatibility-version: v2
       description: |
         Writes line protocol to the specified database.
-
-        This endpoint provides backward compatibility for InfluxDB 2.x write workloads using tools such as InfluxDB 2.x client libraries, the Telegraf `outputs.influxdb_v2` output plugin, or third-party tools.
-
         Use this endpoint to send data in [line protocol](/influxdb3/core/reference/syntax/line-protocol/) format to InfluxDB.
-        Use query parameters to specify options for writing data.
-
-        #### Related
-
-        - [Use compatibility APIs to write data](/influxdb3/core/write-data/http-api/compatibility-apis/)
+      externalDocs:
+        description: Use compatibility APIs to write data
+        url: /influxdb3/core/write-data/http-api/compatibility-apis/
       parameters:
         - name: Content-Type
           in: header
@@ -436,7 +415,6 @@ paths:
         '413':
           description: Request entity too large.
       tags:
-        - Compatibility endpoints
         - Write data
       x-influxdata-guides:
         - title: Use compatibility APIs to write data
@@ -735,15 +713,13 @@ paths:
     get:
       operationId: GetV1ExecuteQuery
       summary: Execute InfluxQL query (v1-compatible)
+      x-compatibility-version: v1
       description: |
         Executes an InfluxQL query to retrieve data from the specified database.
-
-        This endpoint is compatible with InfluxDB 1.x client libraries and third-party integrations such as Grafana.
-        Use query parameters to specify the database and the InfluxQL query.
-
-        #### Related
-
-        - [Use the InfluxDB v1 HTTP query API and InfluxQL to query data](/influxdb3/core/query-data/execute-queries/influxdb-v1-api/)
+        Compatible with InfluxDB 1.x client libraries and third-party integrations such as Grafana.
+      externalDocs:
+        description: Use the InfluxDB v1 HTTP query API and InfluxQL to query data
+        url: /influxdb3/core/query-data/execute-queries/influxdb-v1-api/
       parameters:
         - name: Accept
           in: header
@@ -861,19 +837,17 @@ paths:
           description: Unprocessable entity.
       tags:
         - Query data
-        - Compatibility endpoints
       x-influxdata-guides:
         - title: Use the InfluxDB v1 HTTP query API and InfluxQL to query data
           href: /influxdb3/core/query-data/execute-queries/influxdb-v1-api/
     post:
       operationId: PostExecuteV1Query
       summary: Execute InfluxQL query (v1-compatible)
-      description: |
-        Executes an InfluxQL query to retrieve data from the specified database.
-
-        #### Related
-
-        - [Use the InfluxDB v1 HTTP query API and InfluxQL to query data](/influxdb3/core/query-data/execute-queries/influxdb-v1-api/)
+      x-compatibility-version: v1
+      description: Executes an InfluxQL query to retrieve data from the specified database.
+      externalDocs:
+        description: Use the InfluxDB v1 HTTP query API and InfluxQL to query data
+        url: /influxdb3/core/query-data/execute-queries/influxdb-v1-api/
       requestBody:
         content:
           application/json:
@@ -980,7 +954,6 @@ paths:
           description: Unprocessable entity.
       tags:
         - Query data
-        - Compatibility endpoints
       x-influxdata-guides:
         - title: Use the InfluxDB v1 HTTP query API and InfluxQL to query data
           href: /influxdb3/core/query-data/execute-queries/influxdb-v1-api/
@@ -999,7 +972,8 @@ paths:
   /api/v1/health:
     get:
       operationId: GetHealthV1
-      summary: Health check (v1)
+      summary: Health check (v1-compatible)
+      x-compatibility-version: v1
       description: Checks the status of the service.
       responses:
         '200':
@@ -1008,7 +982,6 @@ paths:
           description: Service is unavailable.
       tags:
         - Server information
-        - Compatibility endpoints
   /ping:
     get:
       operationId: GetPing
@@ -1196,7 +1169,6 @@ paths:
       description: Creates a distinct cache for a table.
       tags:
         - Cache data
-        - Table
       requestBody:
         required: true
         content:
@@ -1242,7 +1214,6 @@ paths:
           description: Cache not found.
       tags:
         - Cache data
-        - Table
   /api/v3/configure/last_cache:
     post:
       operationId: PostConfigureLastCache
@@ -1267,7 +1238,6 @@ paths:
           description: Cache already exists.
       tags:
         - Cache data
-        - Table
     delete:
       operationId: DeleteConfigureLastCache
       summary: Delete last cache
@@ -1297,7 +1267,6 @@ paths:
           description: Cache not found.
       tags:
         - Cache data
-        - Table
   /api/v3/configure/processing_engine_trigger:
     post:
       operationId: PostConfigureProcessingEngineTrigger
@@ -1712,7 +1681,7 @@ paths:
           $ref: '#/components/responses/Unauthorized'
       tags:
         - Authentication
-        - Token
+        - Auth token
   /api/v3/configure/token/admin/regenerate:
     post:
       operationId: PostRegenerateAdminToken
@@ -1731,7 +1700,7 @@ paths:
           $ref: '#/components/responses/Unauthorized'
       tags:
         - Authentication
-        - Token
+        - Auth token
   /api/v3/configure/token:
     delete:
       operationId: DeleteToken
@@ -1755,7 +1724,7 @@ paths:
           description: Token not found.
       tags:
         - Authentication
-        - Token
+        - Auth token
   /api/v3/configure/token/named_admin:
     post:
       operationId: PostCreateNamedAdminToken
@@ -1786,7 +1755,7 @@ paths:
           description: A token with this name already exists.
       tags:
         - Authentication
-        - Token
+        - Auth token
   /api/v3/plugins/files:
     put:
       operationId: PutPluginFile
@@ -2631,19 +2600,3 @@ components:
       in: header
       name: Authorization
       type: apiKey
-x-tagGroups:
-  - name: Using the InfluxDB HTTP API
-    tags:
-      - Quick start
-      - Authentication
-      - Cache data
-      - Common parameters
-      - Response codes
-      - Compatibility endpoints
-      - Database
-      - Processing engine
-      - Server information
-      - Table
-      - Token
-      - Query data
-      - Write data
diff --git a/api-docs/influxdb3/enterprise/v3/ref.yml b/api-docs/influxdb3/enterprise/v3/ref.yml
index 4b2122d944..3fbeef5596 100644
--- a/api-docs/influxdb3/enterprise/v3/ref.yml
+++ b/api-docs/influxdb3/enterprise/v3/ref.yml
@@ -5,18 +5,15 @@ info:
     The InfluxDB HTTP API for InfluxDB 3 Enterprise provides a programmatic interface for
     interacting with InfluxDB 3 Enterprise databases and resources.
     Use this API to:
-
     - Write data to InfluxDB 3 Enterprise databases
     - Query data using SQL or InfluxQL
     - Process data using Processing engine plugins
     - Manage databases, tables, and Processing engine triggers
     - Perform administrative tasks and access system information
-
     The API includes endpoints under the following paths:
     - `/api/v3`: InfluxDB 3 Enterprise native endpoints
     - `/`: Compatibility endpoints for InfluxDB v1 workloads and clients
     - `/api/v2/write`: Compatibility endpoint for InfluxDB v2 workloads and clients
-
     <!-- TODO: verify where to host the spec that users can download.
     This documentation is generated from the
     [InfluxDB OpenAPI specification](https://raw.githubusercontent.com/influxdata/).
@@ -47,95 +44,65 @@ tags:
   - name: Authentication
     description: |
       Depending on your workflow, use one of the following schemes to authenticate to the InfluxDB 3 API:
-
       | Authentication scheme | Works with |
-      |:-------------------|:-----------|
-      | [Bearer authentication](#section/Authentication/BearerAuthentication) | All endpoints |
-      | [Token authentication](#section/Authentication/TokenAuthentication) | v1, v2 endpoints |
-      | [Basic authentication](#section/Authentication/BasicAuthentication) | v1 endpoints |
-      | [Querystring authentication](#section/Authentication/QuerystringAuthentication) | v1 endpoints |
-      <!-- ReDoc-Inject: <security-definitions> -->
+      |:----------------------|:-----------|
+      | Bearer authentication | All endpoints |
+      | Token authentication  | v1, v2 endpoints |
+      | Basic authentication  | v1 endpoints |
+      | Querystring authentication | v1 endpoints |
+      See the **Security Schemes** section below for details on each authentication method.
     x-traitTag: true
   - name: Cache data
     description: |
       Manage the in-memory cache.
-
       #### Distinct Value Cache
-
       The Distinct Value Cache (DVC) lets you cache distinct
       values of one or more columns in a table, improving the performance of
       queries that return distinct tag and field values. 
-
       The DVC is an in-memory cache that stores distinct values for specific columns
       in a table. When you create an DVC, you can specify what columns' distinct
       values to cache, the maximum number of distinct value combinations to cache, and
       the maximum age of cached values. A DVC is associated with a table, which can
       have multiple DVCs.
-
       #### Last value cache
-
       The Last Value Cache (LVC) lets you cache the most recent
       values for specific fields in a table, improving the performance of queries that
       return the most recent value of a field for specific series or the last N values
       of a field.
-
       The LVC is an in-memory cache that stores the last N number of values for
       specific fields of series in a table. When you create an LVC, you can specify
       what fields to cache, what tags to use to identify each series, and the
       number of values to cache for each unique series.
       An LVC is associated with a table, which can have multiple LVCs.
-
       #### Related guides
-
       - [Manage the Distinct Value Cache](/influxdb3/enterprise/admin/distinct-value-cache/)
       - [Manage the Last Value Cache](/influxdb3/enterprise/admin/last-value-cache/)
-  - name: Compatibility endpoints
+  - name: Migrate from InfluxDB v1 or v2
+    x-traitTag: true
     description: |
-      InfluxDB 3 provides compatibility endpoints for InfluxDB 1.x and InfluxDB 2.x workloads and clients.
-
-      ### Write data using v1- or v2-compatible endpoints
-
-      - [`/api/v2/write` endpoint](#operation/PostV2Write)
-          for InfluxDB v2 clients and when you bring existing InfluxDB v2 write workloads to InfluxDB 3.
-      - [`/write` endpoint](#operation/PostV1Write) for InfluxDB v1 clients and when you bring existing InfluxDB v1 write workloads to InfluxDB 3.
-
-      For new workloads, use the [`/api/v3/write_lp` endpoint](#operation/PostWriteLP).
-
-      All endpoints accept the same line protocol format.
-
-      ### Query data
-
-      Use the HTTP [`/query`](#operation/GetV1ExecuteQuery) endpoint for InfluxDB v1 clients and v1 query workloads using InfluxQL.
-
-      For new workloads, use one of the following:
-
-      - HTTP [`/api/v3/query_sql` endpoint](#operation/GetExecuteQuerySQL) for new query workloads using SQL.
-      - HTTP [`/api/v3/query_influxql` endpoint](#operation/GetExecuteInfluxQLQuery) for new query workloads using InfluxQL.
-      - Flight SQL and InfluxDB 3 _Flight+gRPC_ APIs for querying with SQL or InfluxQL. For more information about using Flight APIs, see [InfluxDB 3 client libraries](https://github.com/InfluxCommunity?q=influxdb3&type=public&language=&sort=).
-
-      ### Server information
-
-      Server information endpoints such as `/health` and `metrics` are compatible with InfluxDB 1.x and InfluxDB 2.x clients.
+      Migrate your existing InfluxDB v1 or v2 workloads to InfluxDB 3.
+      InfluxDB 3 provides compatibility endpoints that work with InfluxDB 1.x and 2.x client libraries and tools.
+      Operations marked with <span class="api-compat-badge api-compat-badge--v1">v1</span> or <span class="api-compat-badge api-compat-badge--v2">v2</span> badges are compatible with the respective InfluxDB version.
+      ### Migration guides
+      - [Migrate from InfluxDB v1](/influxdb3/enterprise/guides/migrate/influxdb-1x/) - For users migrating from InfluxDB 1.x
+      - [Migrate from InfluxDB v2](/influxdb3/enterprise/guides/migrate/influxdb-2x/) - For users migrating from InfluxDB 2.x or Cloud
+      - [Use compatibility APIs to write data](/influxdb3/enterprise/write-data/http-api/compatibility-apis/) - v1 and v2 write endpoints
+      - [Use the v1 HTTP query API](/influxdb3/enterprise/query-data/execute-queries/influxdb-v1-api/) - InfluxQL queries via HTTP
   - name: Database
     description: Manage databases
   - description: |
       Most InfluxDB API endpoints require parameters in the request--for example, specifying the database to use.
-
       ### Common parameters
-
       The following table shows common parameters used by many InfluxDB API endpoints.
       Many endpoints may require other parameters in the query string or in the
       request body that perform functions specific to those endpoints.
-
       | Query parameter          | Value type            | Description                                |
       |:------------------------ |:--------------------- |:-------------------------------------------|
       | `db`                 | string                | The database name |
-
       InfluxDB HTTP API endpoints use standard HTTP request and response headers.
       The following table shows common headers used by many InfluxDB API endpoints.
       Some endpoints may use other headers that perform functions more specific to those endpoints--for example,
       the write endpoints accept the `Content-Encoding` header to indicate that line protocol is compressed in the request body.
-
       | Header                   | Value type            | Description                                |
       |:------------------------ |:--------------------- |:-------------------------------------------|
       | `Accept`                 | string                | The content type that the client can understand. |
@@ -147,40 +114,31 @@ tags:
   - name: Processing engine
     description: |
       Manage Processing engine triggers, test plugins, and send requests to trigger On Request plugins.
-
       InfluxDB 3 Enterprise provides the InfluxDB 3 processing engine, an embedded Python VM that can dynamically load and trigger Python plugins in response to events in your database.
       Use Processing engine plugins and triggers to run code and perform tasks for different database events.
-
       To get started with the processing engine, see the [Processing engine and Python plugins](/influxdb3/enterprise/processing-engine/) guide.
   - name: Query data
     description: Query data using SQL or InfluxQL
   - name: Quick start
     description: |
       1. [Create an admin token](#section/Authentication) to authorize API requests.
-
          ```bash
          curl -X POST "http://localhost:8181/api/v3/configure/token/admin"
          ```
       2. [Check the status](#section/Server-information) of the InfluxDB server.
-
          ```bash
          curl "http://localhost:8181/health" \
             --header "Authorization: Bearer ADMIN_TOKEN"
          ```
-
       3. [Write data](#operation/PostWriteLP) to InfluxDB.
-
          ```bash
          curl "http://localhost:8181/api/v3/write_lp?db=sensors&precision=auto"
            --header "Authorization: Bearer ADMIN_TOKEN" \
            --data-raw "home,room=Kitchen temp=72.0
           home,room=Living\ room temp=71.5"
          ```
-
          If all data is written, the response is `204 No Content`.
-
       4. [Query data](#operation/GetExecuteQuerySQL) from InfluxDB.
-
          ```bash
          curl -G "http://localhost:8181/api/v3/query_sql" \
            --header "Authorization: Bearer ADMIN_TOKEN" \
@@ -190,7 +148,6 @@ tags:
          ```
          
          Output:
-
          ```jsonl
          {"room":"Living room","temp":71.5,"time":"2025-02-25T20:19:34.984098"}
          ```
@@ -201,17 +158,14 @@ tags:
     description: Retrieve server metrics, status, and version information
   - name: Table
     description: Manage table schemas and data
-  - name: Token
+  - name: Auth token
     description: Manage tokens for authentication and authorization
   - name: Write data
     description: |
       Write data to InfluxDB 3 using line protocol format.
-
       #### Timestamp precision across write APIs
-
       InfluxDB 3 provides multiple write endpoints for compatibility with different InfluxDB versions.
       The following table compares timestamp precision support across v1, v2, and v3 write APIs:
-
       | Precision | v1 (`/write`) | v2 (`/api/v2/write`) | v3 (`/api/v3/write_lp`) |
       |-----------|---------------|----------------------|-------------------------|
       | **Auto detection** | ❌ No | ❌ No | ✅ `auto` (default) |
@@ -222,24 +176,19 @@ tags:
       | **Minutes** | ✅ `m` | ❌ No | ❌ No |
       | **Hours** | ✅ `h` | ❌ No | ❌ No |
       | **Default** | Nanosecond | Nanosecond | **Auto** (guessed) |
-
       All timestamps are stored internally as nanoseconds.
 paths:
   /write:
     post:
       operationId: PostV1Write
       summary: Write line protocol (v1-compatible)
+      x-compatibility-version: v1
       description: |
         Writes line protocol to the specified database.
-
-        This endpoint provides backward compatibility for InfluxDB 1.x write workloads using tools such as InfluxDB 1.x client libraries, the Telegraf `outputs.influxdb` output plugin, or third-party tools.
-
-        Use this endpoint to send data in [line protocol](https://docs.influxdata.com/influxdb3/enterprise/reference/syntax/line-protocol/) format to InfluxDB.
-        Use query parameters to specify options for writing data.
-
-        #### Related
-
-        - [Use compatibility APIs to write data](/influxdb3/enterprise/write-data/http-api/compatibility-apis/)
+        Use this endpoint to send data in [line protocol](/influxdb3/enterprise/reference/syntax/line-protocol/) format to InfluxDB.
+      externalDocs:
+        description: Use compatibility APIs to write data
+        url: /influxdb3/enterprise/write-data/http-api/compatibility-apis/
       parameters:
         - $ref: '#/components/parameters/dbWriteParam'
         - $ref: '#/components/parameters/compatibilityPrecisionParam'
@@ -303,7 +252,6 @@ paths:
           description: |
             Bad request. Some (a _partial write_) or all of the data from the batch was rejected and not written.
             If a partial write occurred, then some points from the batch are written and queryable.
-
             The response body:
               - indicates if a partial write occurred or all data was rejected.
               - contains details about the [rejected points](/influxdb3/enterprise/write-data/troubleshoot/#troubleshoot-rejected-points), up to 100 points.
@@ -343,7 +291,6 @@ paths:
         '413':
           description: Request entity too large.
       tags:
-        - Compatibility endpoints
         - Write data
       x-influxdata-guides:
         - title: Use compatibility APIs to write data
@@ -352,17 +299,13 @@ paths:
     post:
       operationId: PostV2Write
       summary: Write line protocol (v2-compatible)
+      x-compatibility-version: v2
       description: |
         Writes line protocol to the specified database.
-
-        This endpoint provides backward compatibility for InfluxDB 2.x write workloads using tools such as InfluxDB 2.x client libraries, the Telegraf `outputs.influxdb_v2` output plugin, or third-party tools.
-
         Use this endpoint to send data in [line protocol](/influxdb3/enterprise/reference/syntax/line-protocol/) format to InfluxDB.
-        Use query parameters to specify options for writing data.
-
-        #### Related
-
-        - [Use compatibility APIs to write data](/influxdb3/enterprise/write-data/http-api/compatibility-apis/)
+      externalDocs:
+        description: Use compatibility APIs to write data
+        url: /influxdb3/enterprise/write-data/http-api/compatibility-apis/
       parameters:
         - name: Content-Type
           in: header
@@ -436,7 +379,6 @@ paths:
         '413':
           description: Request entity too large.
       tags:
-        - Compatibility endpoints
         - Write data
       x-influxdata-guides:
         - title: Use compatibility APIs to write data
@@ -447,31 +389,22 @@ paths:
       summary: Write line protocol
       description: |
         Writes line protocol to the specified database.
-
         This is the native InfluxDB 3 Enterprise write endpoint that provides enhanced control 
         over write behavior with advanced parameters for high-performance and fault-tolerant operations.
-
         Use this endpoint to send data in [line protocol](/influxdb3/enterprise/reference/syntax/line-protocol/) format to InfluxDB.
         Use query parameters to specify options for writing data.
-
         #### Features
-
         - **Partial writes**: Use `accept_partial=true` to allow partial success when some lines in a batch fail
         - **Asynchronous writes**: Use `no_sync=true` to skip waiting for WAL synchronization, allowing faster response times but sacrificing durability guarantees
         - **Flexible precision**: Automatic timestamp precision detection with `precision=auto` (default)
-
         #### Auto precision detection
-
         When you use `precision=auto` or omit the precision parameter, InfluxDB 3 automatically detects
         the timestamp precision based on the magnitude of the timestamp value:
-
         - Timestamps < 5e9 → Second precision (multiplied by 1,000,000,000 to convert to nanoseconds)
         - Timestamps < 5e12 → Millisecond precision (multiplied by 1,000,000)
         - Timestamps < 5e15 → Microsecond precision (multiplied by 1,000)
         - Larger timestamps → Nanosecond precision (no conversion needed)
-
         #### Related
-
         - [Use the InfluxDB v3 write_lp API to write data](/influxdb3/enterprise/write-data/http-api/v3-write-lp/)
       parameters:
         - $ref: '#/components/parameters/dbWriteParam'
@@ -735,15 +668,13 @@ paths:
     get:
       operationId: GetV1ExecuteQuery
       summary: Execute InfluxQL query (v1-compatible)
+      x-compatibility-version: v1
       description: |
         Executes an InfluxQL query to retrieve data from the specified database.
-
-        This endpoint is compatible with InfluxDB 1.x client libraries and third-party integrations such as Grafana.
-        Use query parameters to specify the database and the InfluxQL query.
-
-        #### Related
-
-        - [Use the InfluxDB v1 HTTP query API and InfluxQL to query data](/influxdb3/enterprise/query-data/execute-queries/influxdb-v1-api/)
+        Compatible with InfluxDB 1.x client libraries and third-party integrations such as Grafana.
+      externalDocs:
+        description: Use the InfluxDB v1 HTTP query API and InfluxQL to query data
+        url: /influxdb3/enterprise/query-data/execute-queries/influxdb-v1-api/
       parameters:
         - name: Accept
           in: header
@@ -757,9 +688,7 @@ paths:
           required: false
           description: |
             The content type that the client can understand.
-
             If `text/csv` is specified, the `Content-type` response header is `application/csv` and the response is formatted as CSV.
-
             Returns an error if the format is invalid or non-UTF8.
         - in: query
           name: chunked
@@ -838,7 +767,6 @@ paths:
               description: |
                 The content type of the response.
                 Default is `application/json`.
-
                 If the `Accept` request header is `application/csv` or `text/csv`, the `Content-type` response header is `application/csv`
                 and the response is formatted as CSV.
               schema:
@@ -861,19 +789,17 @@ paths:
           description: Unprocessable entity.
       tags:
         - Query data
-        - Compatibility endpoints
       x-influxdata-guides:
         - title: Use the InfluxDB v1 HTTP query API and InfluxQL to query data
           href: /influxdb3/enterprise/query-data/execute-queries/influxdb-v1-api/
     post:
       operationId: PostExecuteV1Query
       summary: Execute InfluxQL query (v1-compatible)
-      description: |
-        Executes an InfluxQL query to retrieve data from the specified database.
-
-        #### Related
-
-        - [Use the InfluxDB v1 HTTP query API and InfluxQL to query data](/influxdb3/enterprise/query-data/execute-queries/influxdb-v1-api/)
+      x-compatibility-version: v1
+      description: Executes an InfluxQL query to retrieve data from the specified database.
+      externalDocs:
+        description: Use the InfluxDB v1 HTTP query API and InfluxQL to query data
+        url: /influxdb3/enterprise/query-data/execute-queries/influxdb-v1-api/
       requestBody:
         content:
           application/json:
@@ -899,14 +825,12 @@ paths:
                 epoch:
                   description: |
                     A unix timestamp precision.
-
                     - `h` for hours
                     - `m` for minutes
                     - `s` for seconds
                     - `ms` for milliseconds
                     - `u` or `µ` for microseconds
                     - `ns` for nanoseconds
-
                     Formats timestamps as [unix (epoch) timestamps](/influxdb3/enterprise/reference/glossary/#unix-timestamp) with the specified precision
                     instead of [RFC3339 timestamps](/influxdb3/enterprise/reference/glossary/#rfc3339-timestamp) with nanosecond precision.
                   enum:
@@ -937,9 +861,7 @@ paths:
           required: false
           description: |
             The content type that the client can understand.
-
             If `text/csv` is specified, the `Content-type` response header is `application/csv` and the response is formatted as CSV.
-
             Returns an error if the format is invalid or non-UTF8.
       responses:
         '200':
@@ -957,7 +879,6 @@ paths:
               description: |
                 The content type of the response.
                 Default is `application/json`.
-
                 If the `Accept` request header is `application/csv` or `text/csv`, the `Content-type` response header is `application/csv`
                 and the response is formatted as CSV.
               schema:
@@ -980,7 +901,6 @@ paths:
           description: Unprocessable entity.
       tags:
         - Query data
-        - Compatibility endpoints
       x-influxdata-guides:
         - title: Use the InfluxDB v1 HTTP query API and InfluxQL to query data
           href: /influxdb3/enterprise/query-data/execute-queries/influxdb-v1-api/
@@ -999,7 +919,8 @@ paths:
   /api/v1/health:
     get:
       operationId: GetHealthV1
-      summary: Health check (v1)
+      summary: Health check (v1-compatible)
+      x-compatibility-version: v1
       description: Checks the status of the service.
       responses:
         '200':
@@ -1008,7 +929,6 @@ paths:
           description: Service is unavailable.
       tags:
         - Server information
-        - Compatibility endpoints
   /ping:
     get:
       operationId: GetPing
@@ -1097,9 +1017,7 @@ paths:
             Schedule the database for hard deletion at the specified time.
             If not provided, the database will be soft deleted.
             Use ISO 8601 date-time format (for example, "2025-12-31T23:59:59Z").
-
             #### Deleting a database cannot be undone
-
             Deleting a database is a destructive action.
             Once a database is deleted, data stored in that database cannot be recovered.
       responses:
@@ -1157,9 +1075,7 @@ paths:
         Soft deletes a table.
         The table is scheduled for deletion and unavailable for querying.
         Use the `hard_delete_at` parameter to schedule a hard deletion.
-
         #### Deleting a table cannot be undone
-
         Deleting a table is a destructive action.
         Once a table is deleted, data stored in that table cannot be recovered.
       parameters:
@@ -1266,7 +1182,6 @@ paths:
       description: Creates a distinct cache for a table.
       tags:
         - Cache data
-        - Table
       requestBody:
         required: true
         content:
@@ -1281,7 +1196,6 @@ paths:
         '400':
           description: |
             Bad request.
-
             The server responds with status `400` if the request would overwrite an existing cache with a different configuration.
     delete:
       operationId: DeleteConfigureDistinctCache
@@ -1312,7 +1226,6 @@ paths:
           description: Cache not found.
       tags:
         - Cache data
-        - Table
   /api/v3/configure/last_cache:
     post:
       operationId: PostConfigureLastCache
@@ -1337,7 +1250,6 @@ paths:
           description: Cache already exists.
       tags:
         - Cache data
-        - Table
     delete:
       operationId: DeleteConfigureLastCache
       summary: Delete last cache
@@ -1367,16 +1279,13 @@ paths:
           description: Cache not found.
       tags:
         - Cache data
-        - Table
   /api/v3/configure/processing_engine_trigger:
     post:
       operationId: PostConfigureProcessingEngineTrigger
       summary: Create processing engine trigger
       description: |
         Creates a processing engine trigger with the specified plugin file and trigger specification.
-
         ### Related guides
-
         - [Processing engine and Python plugins](/influxdb3/enterprise/plugins/)
       requestBody:
         required: true
@@ -1561,11 +1470,8 @@ paths:
       summary: Install plugin packages
       description: |
         Installs the specified Python packages into the processing engine plugin environment.
-
         This endpoint is synchronous and blocks until the packages are installed.
-
         ### Related guides
-
         - [Processing engine and Python plugins](/influxdb3/enterprise/plugins/)
       parameters:
         - $ref: '#/components/parameters/ContentType'
@@ -1611,11 +1517,8 @@ paths:
       summary: Install plugin requirements
       description: |
         Installs requirements from a requirements file (also known as a "pip requirements file") into the processing engine plugin environment.
-
         This endpoint is synchronous and blocks until the requirements are installed.
-
         ### Related
-
         - [Processing engine and Python plugins](/influxdb3/enterprise/plugins/)
         - [Python requirements file format](https://pip.pypa.io/en/stable/reference/requirements-file-format/)
       parameters:
@@ -1683,13 +1586,10 @@ paths:
       - name: request_path
         description: |
           The path configured in the request trigger specification for the plugin.
-
           For example, if you define a trigger with the following:
-
           ```json
           trigger_specification: "request:hello-world"
           ```
-
           then, the HTTP API exposes the following plugin endpoint:
             
           ```
@@ -1705,13 +1605,10 @@ paths:
       description: |
         Executes the On Request processing engine plugin specified in the trigger's `plugin_filename`.
         The request can include request headers, query string parameters, and a request body, which InfluxDB passes to the plugin.
-
         An On Request plugin implements the following signature:
-
         ```python
         def process_request(influxdb3_local, query_parameters, request_headers, request_body, args=None)
         ```
-
         The response depends on the plugin implementation.
       responses:
         '200':
@@ -1732,13 +1629,10 @@ paths:
       description: |
         Executes the On Request processing engine plugin specified in the trigger's `plugin_filename`.
         The request can include request headers, query string parameters, and a request body, which InfluxDB passes to the plugin.
-
         An On Request plugin implements the following signature:
-
         ```python
         def process_request(influxdb3_local, query_parameters, request_headers, request_body, args=None)
         ```
-
         The response depends on the plugin implementation.
       parameters:
         - $ref: '#/components/parameters/ContentType'
@@ -1769,7 +1663,6 @@ paths:
       description: |
         Creates a resource (fine-grained permissions) token.
         A resource token is a token that has access to specific resources in the system.
-
         This endpoint is only available in InfluxDB 3 Enterprise.
       responses:
         '201':
@@ -1784,7 +1677,7 @@ paths:
           $ref: '#/components/responses/Unauthorized'
       tags:
         - Authentication
-        - Token
+        - Auth token
   /api/v3/configure/token/admin:
     post:
       operationId: PostCreateAdminToken
@@ -1805,7 +1698,7 @@ paths:
           $ref: '#/components/responses/Unauthorized'
       tags:
         - Authentication
-        - Token
+        - Auth token
   /api/v3/configure/token/admin/regenerate:
     post:
       operationId: PostRegenerateAdminToken
@@ -1824,7 +1717,7 @@ paths:
           $ref: '#/components/responses/Unauthorized'
       tags:
         - Authentication
-        - Token
+        - Auth token
   /api/v3/configure/token:
     delete:
       operationId: DeleteToken
@@ -1847,7 +1740,7 @@ paths:
           description: Token not found.
       tags:
         - Authentication
-        - Token
+        - Auth token
   /api/v3/configure/token/named_admin:
     post:
       operationId: PostCreateNamedAdminToken
@@ -1877,7 +1770,7 @@ paths:
           description: A token with this name already exists.
       tags:
         - Authentication
-        - Token
+        - Auth token
   /api/v3/plugins/files:
     put:
       operationId: PutPluginFile
@@ -1978,7 +1871,6 @@ components:
         type: string
       description: |
         The name of the database.
-
         If you provide a query that specifies the database, you can omit the 'db' parameter from your request.
     accept_partial:
       name: accept_partial
@@ -2133,9 +2025,7 @@ components:
       description: |
         Content coding.
         Use `gzip` for compressed data or `identity` for unmodified, uncompressed data.
-
         #### Multi-member gzip support
-
         InfluxDB 3 supports multi-member gzip payloads (concatenated gzip files per [RFC 1952](https://www.rfc-editor.org/rfc/rfc1952)).
         This allows you to:
         - Concatenate multiple gzip files and send them in a single request
@@ -2173,9 +2063,7 @@ components:
       default: false
       description: |
         Acknowledges a successful write without waiting for WAL persistence.
-
         #### Related
-
         - [Use the HTTP API and client libraries to write data](/influxdb3/enterprise/write-data/api-client-libraries/)
         - [Data durability](/influxdb3/enterprise/reference/internals/durability/)
     PrecisionWriteCompatibility:
@@ -2198,7 +2086,6 @@ components:
       type: string
       description: |
         The precision for unix timestamps in the line protocol batch.
-
         Supported values:
         - `auto` (default): Automatically detects precision based on timestamp magnitude
         - `nanosecond`: Nanoseconds
@@ -2376,19 +2263,15 @@ components:
             The path and filename of the plugin to execute--for example,
             `schedule.py` or `endpoints/report.py`.
             The path can be absolute or relative to the `--plugins-dir` directory configured when starting InfluxDB 3.
-
             The plugin file must implement the trigger interface associated with the trigger's specification.
         trigger_name:
           type: string
         trigger_specification:
           description: |
             Specifies when and how the processing engine trigger should be invoked.
-
             ## Supported trigger specifications:
-
             ### Cron-based scheduling
             Format: `cron:CRON_EXPRESSION`
-
             Uses extended (6-field) cron format (second minute hour day_of_month month day_of_week):
             ```
             ┌───────────── second (0-59)
@@ -2404,10 +2287,8 @@ components:
             - `cron:0 0 6 * * 1-5` - Every weekday at 6:00 AM
             - `cron:0 30 14 * * 5` - Every Friday at 2:30 PM
             - `cron:0 0 0 1 * *` - First day of every month at midnight
-
             ### Interval-based scheduling  
             Format: `every:DURATION`
-
             Supported durations: `s` (seconds), `m` (minutes), `h` (hours), `d` (days), `w` (weeks), `M` (months), `y` (years):
             - `every:30s` - Every 30 seconds
             - `every:5m` - Every 5 minutes
@@ -2416,16 +2297,12 @@ components:
             - `every:1w` - Every week
             - `every:1M` - Every month
             - `every:1y` - Every year
-
             **Maximum interval**: 1 year
-
             ### Table-based triggers
             - `all_tables` - Triggers on write events to any table in the database
             - `table:TABLE_NAME` - Triggers on write events to a specific table
-
             ### On-demand triggers
             Format: `request:REQUEST_PATH`
-
             Creates an HTTP endpoint `/api/v3/engine/REQUEST_PATH` for manual invocation:
             - `request:hello-world` - Creates endpoint `/api/v3/engine/hello-world`
             - `request:data-export` - Creates endpoint `/api/v3/engine/data-export`
@@ -2595,7 +2472,6 @@ components:
     BadRequest:
       description: |
         Request failed. Possible reasons:
-
           - Invalid database name
           - Malformed request body
           - Invalid timestamp precision
@@ -2633,34 +2509,24 @@ components:
       scheme: basic
       description: |
         Use the `Authorization` header with the `Basic` scheme to authenticate v1 API requests.
-
         Works with v1 compatibility [`/write`](#operation/PostV1Write) and [`/query`](#operation/GetV1Query) endpoints in InfluxDB 3.
-
         When authenticating requests, InfluxDB 3 checks that the `password` part of the decoded credential is an authorized token
         and ignores the `username` part of the decoded credential.
-
         ### Syntax
-
         ```http
         Authorization: Basic <base64-encoded [USERNAME]:AUTH_TOKEN>
         ```
-
         ### Example
-
         ```bash
         curl "http://localhost:8181/write?db=DATABASE_NAME&precision=s" \
           --user "":"AUTH_TOKEN" \
           --header "Content-type: text/plain; charset=utf-8" \
           --data-binary 'home,room=kitchen temp=72 1641024000'
         ```
-
         Replace the following:
-
         - **`DATABASE_NAME`**: your InfluxDB 3 Enterprise database
         - **`AUTH_TOKEN`**: an admin token or database token authorized for the database
-
         #### Related guides
-
         - [Authenticate v1 API requests](/influxdb3/enterprise/guides/api-compatibility/v1/)
         - [Manage tokens](/influxdb3/enterprise/admin/tokens/)
     QuerystringAuthentication:
@@ -2669,32 +2535,23 @@ components:
       name: u=&p=
       description: |
         Use InfluxDB 1.x API parameters to provide credentials through the query string for v1 API requests.
-
         Querystring authentication works with v1-compatible [`/write`](#operation/PostV1Write) and [`/query`](#operation/GetV1Query) endpoints.
-
         When authenticating requests, InfluxDB 3 checks that the `p` (_password_) query parameter is an authorized token
         and ignores the `u` (_username_) query parameter.
-
         ### Syntax
-
         ```http
         https://localhost:8181/query/?[u=any]&p=AUTH_TOKEN
         https://localhost:8181/write/?[u=any]&p=AUTH_TOKEN
         ```
-
         ### Examples
-
         ```bash
         curl "http://localhost:8181/write?db=DATABASE_NAME&precision=s&p=AUTH_TOKEN" \
           --header "Content-type: text/plain; charset=utf-8" \
           --data-binary 'home,room=kitchen temp=72 1641024000'
         ```
-
         Replace the following:
-
         - **`DATABASE_NAME`**: your InfluxDB 3 Enterprise database
         - **`AUTH_TOKEN`**: an admin token or database token authorized for the database
-
         ```bash
         #######################################
         # Use an InfluxDB 1.x compatible username and password
@@ -2703,20 +2560,15 @@ components:
         # Use authentication query parameters:
         #   ?p=AUTH_TOKEN
         #######################################
-
         curl --get "http://localhost:8181/query" \
           --data-urlencode "p=AUTH_TOKEN" \
           --data-urlencode "db=DATABASE_NAME" \
           --data-urlencode "q=SELECT * FROM MEASUREMENT"
         ```
-
         Replace the following:
-
         - **`DATABASE_NAME`**: the database to query
         - **`AUTH_TOKEN`**: a database token with sufficient permissions to the database
-
         #### Related guides
-
         - [Authenticate v1 API requests](/influxdb3/enterprise/guides/api-compatibility/v1/)
         - [Manage tokens](/influxdb3/enterprise/admin/tokens/)
     BearerAuthentication:
@@ -2724,23 +2576,16 @@ components:
       scheme: bearer
       bearerFormat: JWT
       description: |
-
         Use the OAuth Bearer authentication
         scheme to provide an authorization token to InfluxDB 3.
-
         Bearer authentication works with all endpoints.
-
         In your API requests, send an `Authorization` header.
         For the header value, provide the word `Bearer` followed by a space and a database token.
-
         ### Syntax
-
         ```http
         Authorization: Bearer AUTH_TOKEN
         ```
-
         ### Example
-
         ```bash
         curl http://localhost:8181/api/v3/query_influxql \
           --header "Authorization: Bearer AUTH_TOKEN"
@@ -2748,51 +2593,26 @@ components:
     TokenAuthentication:
       description: |
         Use InfluxDB v2 Token authentication to provide an authorization token to InfluxDB 3.
-
         The v2 Token scheme works with v1 and v2 compatibility endpoints in InfluxDB 3.
-
         In your API requests, send an `Authorization` header.
         For the header value, provide the word `Token` followed by a space and a database token.
         The word `Token` is case-sensitive.
-
         ### Syntax
-
         ```http
         Authorization: Token AUTH_TOKEN
         ```
-
         ### Example
-
         ```sh
         ########################################################
         # Use the Token authentication scheme with /api/v2/write
         # to write data.
         ########################################################
-
         curl --request post "http://localhost:8181/api/v2/write?bucket=DATABASE_NAME&precision=s" \
           --header "Authorization: Token AUTH_TOKEN" \
           --data-binary 'home,room=kitchen temp=72 1463683075'
         ```
-
         ### Related guides
-
         - [Manage tokens](/influxdb3/enterprise/admin/tokens/)
       in: header
       name: Authorization
       type: apiKey
-x-tagGroups:
-  - name: Using the InfluxDB HTTP API
-    tags:
-      - Quick start
-      - Authentication
-      - Cache data
-      - Common parameters
-      - Response codes
-      - Compatibility endpoints
-      - Database
-      - Processing engine
-      - Server information
-      - Table
-      - Token
-      - Query data
-      - Write data
diff --git a/api-docs/scripts/README.md b/api-docs/scripts/README.md
new file mode 100644
index 0000000000..2ea5f440d1
--- /dev/null
+++ b/api-docs/scripts/README.md
@@ -0,0 +1,390 @@
+# API Documentation Generation Scripts
+
+TypeScript-based scripts for generating Hugo data files and content pages from OpenAPI specifications.
+
+## Overview
+
+These scripts convert OpenAPI v3 specifications into Hugo-compatible data files and content pages for all InfluxDB products.
+
+### What Gets Generated
+
+For each product, the scripts generate:
+
+1. **OpenAPI Spec Copies** (static directory):
+   - `influxdb-{product}.yml` - YAML version of the spec
+   - `influxdb-{product}.json` - JSON version of the spec
+
+2. **Path Group Fragments** (static/openapi/{product}/paths/):
+   - Separate YAML and JSON files for each API path group
+   - Example: `ref-api-v2-buckets.yaml` and `ref-api-v2-buckets.json`
+
+3. **Article Metadata** (data/article-data/influxdb/{product}/):
+   - `articles.yml` - Hugo data file with article metadata
+   - `articles.json` - JSON version for programmatic access
+
+4. **Hugo Content Pages** (content/{product}/api/):
+   - Markdown files generated from article data
+   - One page per API path group
+
+## Quick Start
+
+### Build Scripts
+
+Compile TypeScript to JavaScript (required before running):
+
+```bash
+yarn build:api-scripts
+```
+
+### Generate API Pages
+
+**Generate all products:**
+
+```bash
+yarn build:api-pages
+```
+
+**Generate specific product(s):**
+
+```bash
+yarn build:api-pages:product cloud-v2
+yarn build:api-pages:product cloud-v2 oss-v2
+```
+
+## Supported Products
+
+| Product ID             | Description               | Spec File                                        | Content Path                                 |
+| ---------------------- | ------------------------- | ------------------------------------------------ | -------------------------------------------- |
+| `cloud-v2`             | InfluxDB Cloud (v2 API)   | `api-docs/cloud/v2/ref.yml`                      | `content/influxdb/cloud/api/v2`              |
+| `oss-v2`               | InfluxDB OSS v2           | `api-docs/v2/ref.yml`                            | `content/influxdb/v2/api/v2`                 |
+| `influxdb3-core`       | InfluxDB 3 Core           | `api-docs/influxdb3/core/v3/ref.yml`             | `content/influxdb3/core/reference/api`       |
+| `influxdb3-enterprise` | InfluxDB 3 Enterprise     | `api-docs/influxdb3/enterprise/v3/ref.yml`       | `content/influxdb3/enterprise/reference/api` |
+| `cloud-dedicated`      | InfluxDB Cloud Dedicated  | `api-docs/influxdb3/cloud-dedicated/v2/ref.yml`  | `content/influxdb/cloud-dedicated/api`       |
+| `cloud-serverless`     | InfluxDB Cloud Serverless | `api-docs/influxdb3/cloud-serverless/v2/ref.yml` | `content/influxdb/cloud-serverless/api`      |
+| `clustered`            | InfluxDB Clustered        | `api-docs/influxdb3/clustered/v2/ref.yml`        | `content/influxdb/clustered/api`             |
+
+## Architecture
+
+### TypeScript Files
+
+```
+api-docs/scripts/
+├── tsconfig.json                              # TypeScript configuration
+├── generate-openapi-articles.ts               # Main orchestration script
+└── openapi-paths-to-hugo-data/
+    ├── index.ts                               # Core conversion logic
+    └── package.json                           # Module dependencies
+```
+
+### Compiled JavaScript
+
+After running `yarn build:api-scripts`, compiled files are in:
+
+```
+api-docs/scripts/dist/
+├── generate-openapi-articles.js
+├── generate-openapi-articles.d.ts
+└── openapi-paths-to-hugo-data/
+    ├── index.js
+    └── index.d.ts
+```
+
+## Script Details
+
+### generate-openapi-articles.ts
+
+Main orchestration script that processes products.
+
+**For each product, it:**
+
+1. Runs `getswagger.sh` to fetch/bundle the OpenAPI spec
+2. Copies spec to `static/openapi/influxdb-{product}.yml`
+3. Generates JSON version at `static/openapi/influxdb-{product}.json`
+4. Generates path group fragments (YAML and JSON)
+5. Creates article metadata (YAML and JSON)
+6. Generates Hugo content pages
+
+**Usage:**
+
+```bash
+node api-docs/scripts/dist/generate-openapi-articles.js [product-ids...]
+
+# Examples:
+node api-docs/scripts/dist/generate-openapi-articles.js                    # All products
+node api-docs/scripts/dist/generate-openapi-articles.js cloud-v2           # Single product
+node api-docs/scripts/dist/generate-openapi-articles.js cloud-v2 oss-v2    # Multiple products
+```
+
+**Output:**
+
+```
+📋 Processing all products...
+
+================================================================================
+Processing InfluxDB Cloud (v2 API)
+================================================================================
+
+Fetching OpenAPI spec for cloud-v2...
+✓ Copied spec to static/openapi/influxdb-cloud-v2.yml
+✓ Generated JSON spec at static/openapi/influxdb-cloud-v2.json
+
+Generating OpenAPI path files in static/openapi/influxdb-cloud-v2/paths....
+Generated: ref-api-v2-buckets.yaml and ref-api-v2-buckets.json
+...
+
+Generating OpenAPI article data in data/article-data/influxdb/cloud-v2...
+Generated 32 articles in data/article-data/influxdb/cloud-v2
+
+✅ Successfully processed InfluxDB Cloud (v2 API)
+```
+
+### openapi-paths-to-hugo-data/index.ts
+
+Core conversion library that processes OpenAPI specs.
+
+**Key Functions:**
+
+- `generateHugoData(options)` - Main entry point
+- `writePathOpenapis()` - Groups paths and writes fragments
+- `createArticleDataForPathGroup()` - Generates article metadata
+
+**Path Grouping Logic:**
+
+Paths are grouped by their base path (first 3-4 segments, excluding placeholders):
+
+```
+/api/v2/buckets           → api-v2-buckets
+/api/v2/buckets/{id}      → api-v2-buckets (same group)
+/api/v2/authorizations    → api-v2-authorizations
+```
+
+**Output Formats:**
+
+- **YAML**: Hugo-compatible data files
+- **JSON**: Programmatic access and tooling
+
+## Development
+
+### Prerequisites
+
+- Node.js >= 16.0.0
+- Yarn package manager
+- TypeScript installed (via root package.json)
+
+### Setup
+
+```bash
+# Install dependencies (from repo root)
+yarn install
+
+# Or install in the openapi-paths-to-hugo-data module
+cd api-docs/scripts/openapi-paths-to-hugo-data
+yarn install
+```
+
+### TypeScript Configuration
+
+The scripts use a dedicated `tsconfig.json` with CommonJS output:
+
+```json
+{
+  "compilerOptions": {
+    "target": "ES2021",
+    "module": "CommonJS",
+    "outDir": "./dist",
+    "strict": true,
+    ...
+  }
+}
+```
+
+### Making Changes
+
+1. Edit TypeScript files in `api-docs/scripts/`
+2. Compile: `yarn build:api-scripts`
+3. Test: `yarn build:api-pages:product cloud-v2`
+
+### Watch Mode
+
+For active development:
+
+```bash
+cd api-docs/scripts/openapi-paths-to-hugo-data
+yarn build:watch
+```
+
+## Testing
+
+### Unit Test Example
+
+```javascript
+const converter = require('./api-docs/scripts/dist/openapi-paths-to-hugo-data/index.js');
+
+converter.generateHugoData({
+  specFile: 'api-docs/influxdb/cloud/v2/ref.yml',
+  dataOutPath: './test-output/paths',
+  articleOutPath: './test-output/articles'
+});
+```
+
+### Verify Output
+
+After generation, check:
+
+1. **Path fragments exist:**
+   ```bash
+   ls -l static/openapi/influxdb-cloud-v2/paths/
+   ```
+
+2. **Both formats generated:**
+   ```bash
+   ls -l static/openapi/influxdb-cloud-v2/paths/*.{yaml,json}
+   ```
+
+3. **Article data created:**
+   ```bash
+   cat data/article-data/influxdb/cloud-v2/articles.yml
+   cat data/article-data/influxdb/cloud-v2/articles.json
+   ```
+
+4. **Hugo pages generated:**
+   ```bash
+   ls -l content/influxdb/cloud/api/v2/
+   ```
+
+## Troubleshooting
+
+### TypeScript Compilation Errors
+
+```bash
+# Clean and rebuild
+rm -rf api-docs/scripts/dist
+yarn build:api-scripts
+```
+
+### Missing Type Definitions
+
+```bash
+cd api-docs/scripts/openapi-paths-to-hugo-data
+yarn add --dev @types/js-yaml @types/node
+```
+
+### Spec File Not Found
+
+Make sure to run `getswagger.sh` first:
+
+```bash
+cd api-docs
+./getswagger.sh cloud-v2 -B
+```
+
+### Path Grouping Issues
+
+The script groups paths by their first 3-4 segments. If you need different grouping:
+
+1. Edit `writePathOpenapis()` in `openapi-paths-to-hugo-data/index.ts`
+2. Modify the `key.slice(0, 4)` logic
+3. Rebuild: `yarn build:api-scripts`
+
+## Migration from JavaScript
+
+The original JavaScript files are preserved for reference:
+
+- `api-docs/scripts/generate-openapi-articles.js` (original)
+- `api-docs/scripts/openapi-paths-to-hugo-data/index.js` (original)
+
+### Key Improvements
+
+1. **TypeScript**: Full type safety and IDE support
+2. **Dual Formats**: Generates both YAML and JSON
+3. **All Products**: Includes all 7 InfluxDB products
+4. **Better Errors**: Clear error messages with product validation
+5. **CLI Arguments**: Support for processing specific products
+6. **Comprehensive Logging**: Progress indicators and status messages
+
+## Related Documentation
+
+- **API Docs README**: `api-docs/README.md` - Complete API documentation workflow
+- **OpenAPI Plugins**: `api-docs/openapi/plugins/` - Custom processing plugins
+- **Hugo Data to Pages**: `hugo-data-to-pages/` - Page generation from data files
+
+## Examples
+
+### Generate Only Cloud Products
+
+```bash
+yarn build:api-pages:product cloud-v2 cloud-dedicated cloud-serverless
+```
+
+### Generate Only InfluxDB 3 Products
+
+```bash
+yarn build:api-pages:product influxdb3-core influxdb3-enterprise
+```
+
+### Process Single Product Manually
+
+```bash
+# Compile first
+yarn build:api-scripts
+
+# Run for specific product
+node api-docs/scripts/dist/generate-openapi-articles.js oss-v2
+```
+
+## API Reference
+
+### generateHugoData(options)
+
+Generate Hugo data files from an OpenAPI specification.
+
+**Parameters:**
+
+- `options.specFile` (string) - Path to the OpenAPI spec file
+- `options.dataOutPath` (string) - Output path for OpenAPI path fragments
+- `options.articleOutPath` (string) - Output path for article metadata
+
+**Example:**
+
+```javascript
+const { generateHugoData } = require('./api-docs/scripts/dist/openapi-paths-to-hugo-data/index.js');
+
+generateHugoData({
+  specFile: 'api-docs/influxdb/cloud/v2/ref.yml',
+  dataOutPath: 'static/openapi/influxdb-cloud-v2/paths',
+  articleOutPath: 'data/article-data/influxdb/cloud-v2'
+});
+```
+
+### productConfigs
+
+Map of product configurations exported from `generate-openapi-articles.ts`.
+
+**Type:**
+
+```typescript
+type ProductConfig = {
+  specFile: string;      // Path to OpenAPI spec
+  pagesDir: string;      // Hugo content directory
+  description?: string;  // Product description
+};
+
+const productConfigs: Record<string, ProductConfig>;
+```
+
+**Usage:**
+
+```javascript
+const { productConfigs } = require('./api-docs/scripts/dist/generate-openapi-articles.js');
+
+console.log(productConfigs['cloud-v2']);
+// {
+//   specFile: 'api-docs/cloud/v2/ref.yml',
+//   pagesDir: 'content/influxdb/cloud/api/v2',
+//   description: 'InfluxDB Cloud (v2 API)'
+// }
+```
+
+## License
+
+Same as parent docs-v2 repository (MIT).
diff --git a/api-docs/scripts/dist/generate-openapi-articles.js b/api-docs/scripts/dist/generate-openapi-articles.js
new file mode 100644
index 0000000000..46f2cd46d5
--- /dev/null
+++ b/api-docs/scripts/dist/generate-openapi-articles.js
@@ -0,0 +1,706 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * Generate OpenAPI Articles Script
+ *
+ * Generates Hugo data files and content pages from OpenAPI specifications
+ * for all InfluxDB products.
+ *
+ * This script:
+ * 1. Runs getswagger.sh to fetch/bundle OpenAPI specs
+ * 2. Copies specs to static directory for download
+ * 3. Generates path group fragments (YAML and JSON)
+ * 4. Creates article metadata (YAML and JSON)
+ * 5. Generates Hugo content pages from article data
+ *
+ * Usage:
+ *   node generate-openapi-articles.js                    # Generate all products
+ *   node generate-openapi-articles.js cloud-v2           # Generate single product
+ *   node generate-openapi-articles.js cloud-v2 oss-v2    # Generate multiple products
+ *
+ * @module generate-openapi-articles
+ */
+var __createBinding =
+  (this && this.__createBinding) ||
+  (Object.create
+    ? function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        var desc = Object.getOwnPropertyDescriptor(m, k);
+        if (
+          !desc ||
+          ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)
+        ) {
+          desc = {
+            enumerable: true,
+            get: function () {
+              return m[k];
+            },
+          };
+        }
+        Object.defineProperty(o, k2, desc);
+      }
+    : function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        o[k2] = m[k];
+      });
+var __setModuleDefault =
+  (this && this.__setModuleDefault) ||
+  (Object.create
+    ? function (o, v) {
+        Object.defineProperty(o, 'default', { enumerable: true, value: v });
+      }
+    : function (o, v) {
+        o['default'] = v;
+      });
+var __importStar =
+  (this && this.__importStar) ||
+  (function () {
+    var ownKeys = function (o) {
+      ownKeys =
+        Object.getOwnPropertyNames ||
+        function (o) {
+          var ar = [];
+          for (var k in o)
+            if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+          return ar;
+        };
+      return ownKeys(o);
+    };
+    return function (mod) {
+      if (mod && mod.__esModule) return mod;
+      var result = {};
+      if (mod != null)
+        for (var k = ownKeys(mod), i = 0; i < k.length; i++)
+          if (k[i] !== 'default') __createBinding(result, mod, k[i]);
+      __setModuleDefault(result, mod);
+      return result;
+    };
+  })();
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.productConfigs = void 0;
+exports.processProduct = processProduct;
+exports.generateDataFromOpenAPI = generateDataFromOpenAPI;
+exports.generatePagesFromArticleData = generatePagesFromArticleData;
+const child_process_1 = require('child_process');
+const path = __importStar(require('path'));
+const fs = __importStar(require('fs'));
+// Import the OpenAPI to Hugo converter
+const openapiPathsToHugo = require('./openapi-paths-to-hugo-data/index.js');
+// Calculate the relative paths
+const DOCS_ROOT = '.';
+const API_DOCS_ROOT = 'api-docs';
+/**
+ * Execute a shell command and handle errors
+ *
+ * @param command - Command to execute
+ * @param description - Human-readable description of the command
+ * @throws Exits process with code 1 on error
+ */
+function execCommand(command, description) {
+  try {
+    if (description) {
+      console.log(`\n${description}...`);
+    }
+    console.log(`Executing: ${command}\n`);
+    (0, child_process_1.execSync)(command, { stdio: 'inherit' });
+  } catch (error) {
+    console.error(`\n❌ Error executing command: ${command}`);
+    if (error instanceof Error) {
+      console.error(error.message);
+    }
+    process.exit(1);
+  }
+}
+/**
+ * Generate a clean static directory name from a product key.
+ * Handles the influxdb3_* products to avoid redundant 'influxdb-influxdb3' prefixes.
+ *
+ * @param productKey - Product identifier (e.g., 'cloud-v2', 'influxdb3_core')
+ * @returns Clean directory name (e.g., 'influxdb-cloud-v2', 'influxdb3-core')
+ */
+function getStaticDirName(productKey) {
+  // For influxdb3_* products, convert underscore to hyphen and don't add prefix
+  if (productKey.startsWith('influxdb3_')) {
+    return productKey.replace('_', '-');
+  }
+  // For other products, add 'influxdb-' prefix
+  return `influxdb-${productKey}`;
+}
+/**
+ * Generate Hugo data files from OpenAPI specification
+ *
+ * @param specFile - Path to the OpenAPI spec file
+ * @param dataOutPath - Output path for OpenAPI path fragments
+ * @param articleOutPath - Output path for article metadata
+ */
+function generateDataFromOpenAPI(specFile, dataOutPath, articleOutPath) {
+  if (!fs.existsSync(dataOutPath)) {
+    fs.mkdirSync(dataOutPath, { recursive: true });
+  }
+  openapiPathsToHugo.generateHugoData({
+    dataOutPath,
+    articleOutPath,
+    specFile,
+  });
+}
+/**
+ * Generate Hugo content pages from article data
+ *
+ * Creates markdown files with frontmatter from article metadata.
+ * Each article becomes a page with type: api that renders via Scalar.
+ *
+ * @param options - Generation options
+ */
+function generatePagesFromArticleData(options) {
+  const {
+    articlesPath,
+    contentPath,
+    menuKey,
+    menuParent,
+    productDescription,
+    skipParentMenu,
+  } = options;
+  const yaml = require('js-yaml');
+  const articlesFile = path.join(articlesPath, 'articles.yml');
+  if (!fs.existsSync(articlesFile)) {
+    console.warn(`⚠️  Articles file not found: ${articlesFile}`);
+    return;
+  }
+  // Read articles data
+  const articlesContent = fs.readFileSync(articlesFile, 'utf8');
+  const data = yaml.load(articlesContent);
+  if (!data.articles || !Array.isArray(data.articles)) {
+    console.warn(`⚠️  No articles found in ${articlesFile}`);
+    return;
+  }
+  // Ensure content directory exists
+  if (!fs.existsSync(contentPath)) {
+    fs.mkdirSync(contentPath, { recursive: true });
+  }
+  // Determine the API parent directory from the first article's path
+  // e.g., if article path is "api/v1/health", the API root is "api"
+  const firstArticlePath = data.articles[0]?.path || '';
+  const apiRootDir = firstArticlePath.split('/')[0];
+  // Generate parent _index.md for the API section
+  if (apiRootDir) {
+    const apiParentDir = path.join(contentPath, apiRootDir);
+    const parentIndexFile = path.join(apiParentDir, '_index.md');
+    if (!fs.existsSync(apiParentDir)) {
+      fs.mkdirSync(apiParentDir, { recursive: true });
+    }
+    if (!fs.existsSync(parentIndexFile)) {
+      const parentFrontmatter = {
+        title: menuParent || 'HTTP API',
+        description:
+          productDescription ||
+          'API reference documentation for all available endpoints.',
+        weight: 104,
+      };
+      // Add menu entry for parent page (unless skipParentMenu is true)
+      if (menuKey && !skipParentMenu) {
+        parentFrontmatter.menu = {
+          [menuKey]: {
+            name: menuParent || 'HTTP API',
+          },
+        };
+      }
+      const parentContent = `---
+${yaml.dump(parentFrontmatter)}---
+`;
+      fs.writeFileSync(parentIndexFile, parentContent);
+      console.log(`✓ Generated parent index at ${parentIndexFile}`);
+    }
+  }
+  // Generate a page for each article
+  for (const article of data.articles) {
+    const pagePath = path.join(contentPath, article.path);
+    const pageFile = path.join(pagePath, '_index.md');
+    // Create directory if needed
+    if (!fs.existsSync(pagePath)) {
+      fs.mkdirSync(pagePath, { recursive: true });
+    }
+    // Build frontmatter object
+    // Use menuName for display (actual endpoint path like /health)
+    // Fall back to name or path if menuName is not set
+    const displayName =
+      article.fields.menuName || article.fields.name || article.path;
+    const frontmatter = {
+      title: displayName,
+      description: `API reference for ${displayName}`,
+      type: 'api',
+      // Use explicit layout to override Hugo's default section template lookup
+      // (Hugo's section lookup ignores `type`, so we need `layout` for the 3-column API layout)
+      layout: 'list',
+      staticFilePath: article.fields.staticFilePath,
+      weight: 100,
+    };
+    // Add menu entry if menuKey is provided
+    // Use menuName for menu display (shows actual endpoint path like /health)
+    if (menuKey) {
+      frontmatter.menu = {
+        [menuKey]: {
+          name: displayName,
+          ...(menuParent && { parent: menuParent }),
+        },
+      };
+    }
+    // Add related links if present in article fields
+    if (
+      article.fields.related &&
+      Array.isArray(article.fields.related) &&
+      article.fields.related.length > 0
+    ) {
+      frontmatter.related = article.fields.related;
+    }
+    // Add OpenAPI tags if present in article fields (for frontmatter metadata)
+    if (
+      article.fields.apiTags &&
+      Array.isArray(article.fields.apiTags) &&
+      article.fields.apiTags.length > 0
+    ) {
+      frontmatter.api_tags = article.fields.apiTags;
+    }
+    const pageContent = `---
+${yaml.dump(frontmatter)}---
+`;
+    fs.writeFileSync(pageFile, pageContent);
+  }
+  console.log(
+    `✓ Generated ${data.articles.length} content pages in ${contentPath}`
+  );
+}
+/**
+ * Generate Hugo content pages from tag-based article data
+ *
+ * Creates markdown files with frontmatter from article metadata.
+ * Each article becomes a page with type: api that renders via RapiDoc.
+ * Includes operation metadata for TOC generation.
+ *
+ * @param options - Generation options
+ */
+function generateTagPagesFromArticleData(options) {
+  const {
+    articlesPath,
+    contentPath,
+    menuKey,
+    menuParent,
+    productDescription,
+    skipParentMenu,
+  } = options;
+  const yaml = require('js-yaml');
+  const articlesFile = path.join(articlesPath, 'articles.yml');
+  if (!fs.existsSync(articlesFile)) {
+    console.warn(`⚠️  Articles file not found: ${articlesFile}`);
+    return;
+  }
+  // Read articles data
+  const articlesContent = fs.readFileSync(articlesFile, 'utf8');
+  const data = yaml.load(articlesContent);
+  if (!data.articles || !Array.isArray(data.articles)) {
+    console.warn(`⚠️  No articles found in ${articlesFile}`);
+    return;
+  }
+  // Ensure content directory exists
+  if (!fs.existsSync(contentPath)) {
+    fs.mkdirSync(contentPath, { recursive: true });
+  }
+  // Generate parent _index.md for the API section
+  const apiParentDir = path.join(contentPath, 'api');
+  const parentIndexFile = path.join(apiParentDir, '_index.md');
+  if (!fs.existsSync(apiParentDir)) {
+    fs.mkdirSync(apiParentDir, { recursive: true });
+  }
+  if (!fs.existsSync(parentIndexFile)) {
+    const parentFrontmatter = {
+      title: menuParent || 'HTTP API',
+      description:
+        productDescription ||
+        'API reference documentation for all available endpoints.',
+      weight: 104,
+    };
+    // Add menu entry for parent page (unless skipParentMenu is true)
+    if (menuKey && !skipParentMenu) {
+      parentFrontmatter.menu = {
+        [menuKey]: {
+          name: menuParent || 'HTTP API',
+        },
+      };
+    }
+    const parentContent = `---
+${yaml.dump(parentFrontmatter)}---
+`;
+    fs.writeFileSync(parentIndexFile, parentContent);
+    console.log(`✓ Generated parent index at ${parentIndexFile}`);
+  }
+  // Generate a page for each article (tag)
+  for (const article of data.articles) {
+    const pagePath = path.join(contentPath, article.path);
+    const pageFile = path.join(pagePath, '_index.md');
+    // Create directory if needed
+    if (!fs.existsSync(pagePath)) {
+      fs.mkdirSync(pagePath, { recursive: true });
+    }
+    // Build frontmatter object
+    const title = article.fields.title || article.fields.name || article.path;
+    const isConceptual = article.fields.isConceptual === true;
+    const frontmatter = {
+      title,
+      description: article.fields.description || `API reference for ${title}`,
+      type: 'api',
+      layout: isConceptual ? 'single' : 'list',
+      staticFilePath: article.fields.staticFilePath,
+      weight: 100,
+      // Tag-based fields
+      tag: article.fields.tag,
+      isConceptual,
+      menuGroup: article.fields.menuGroup,
+    };
+    // Add operations for TOC generation (only for non-conceptual pages)
+    if (
+      !isConceptual &&
+      article.fields.operations &&
+      article.fields.operations.length > 0
+    ) {
+      frontmatter.operations = article.fields.operations;
+    }
+    // Add tag description for conceptual pages
+    if (isConceptual && article.fields.tagDescription) {
+      frontmatter.tagDescription = article.fields.tagDescription;
+    }
+    // Note: We deliberately don't add menu entries for tag-based API pages.
+    // The API sidebar navigation (api/sidebar-nav.html) handles navigation
+    // for API reference pages, avoiding conflicts with existing menu items
+    // like "Query data" and "Write data" that exist in the main sidebar.
+    // Add related links if present in article fields
+    if (
+      article.fields.related &&
+      Array.isArray(article.fields.related) &&
+      article.fields.related.length > 0
+    ) {
+      frontmatter.related = article.fields.related;
+    }
+    const pageContent = `---
+${yaml.dump(frontmatter)}---
+`;
+    fs.writeFileSync(pageFile, pageContent);
+  }
+  console.log(
+    `✓ Generated ${data.articles.length} tag-based content pages in ${contentPath}`
+  );
+  // Generate individual operation pages for standalone URLs
+  generateOperationPages({
+    articlesPath,
+    contentPath,
+  });
+}
+/**
+ * Convert API path to URL-safe slug
+ *
+ * Transforms an API path like "/api/v3/write_lp" to a URL-friendly format.
+ * Removes leading slash and uses the path as-is (underscores are URL-safe).
+ *
+ * @param apiPath - The API path (e.g., "/write", "/api/v3/write_lp")
+ * @returns URL-safe path slug (e.g., "write", "api/v3/write_lp")
+ */
+function apiPathToSlug(apiPath) {
+  // Remove leading slash, keep underscores (they're URL-safe)
+  return apiPath.replace(/^\//, '');
+}
+/**
+ * Generate standalone Hugo content pages for each API operation
+ *
+ * Creates individual pages at path-based URLs like /api/write/post/
+ * for each operation, using RapiDoc Mini with tag-level specs.
+ *
+ * @param options - Generation options
+ */
+function generateOperationPages(options) {
+  const { articlesPath, contentPath } = options;
+  const yaml = require('js-yaml');
+  const articlesFile = path.join(articlesPath, 'articles.yml');
+  if (!fs.existsSync(articlesFile)) {
+    console.warn(`⚠️  Articles file not found: ${articlesFile}`);
+    return;
+  }
+  // Read articles data
+  const articlesContent = fs.readFileSync(articlesFile, 'utf8');
+  const data = yaml.load(articlesContent);
+  if (!data.articles || !Array.isArray(data.articles)) {
+    console.warn(`⚠️  No articles found in ${articlesFile}`);
+    return;
+  }
+  let operationCount = 0;
+  // Process each article (tag) and generate pages for its operations
+  for (const article of data.articles) {
+    // Skip conceptual articles (they don't have operations)
+    if (article.fields.isConceptual) {
+      continue;
+    }
+    const operations = article.fields.operations || [];
+    const tagSpecFile = article.fields.staticFilePath;
+    const tagName = article.fields.tag || article.fields.name || '';
+    for (const op of operations) {
+      // Build operation page path: api/{path}/{method}/
+      // e.g., /write -> api/write/post/
+      // e.g., /api/v3/write_lp -> api/api/v3/write_lp/post/
+      const pathSlug = apiPathToSlug(op.path);
+      const method = op.method.toLowerCase();
+      const operationDir = path.join(contentPath, 'api', pathSlug, method);
+      const operationFile = path.join(operationDir, '_index.md');
+      // Create directory if needed
+      if (!fs.existsSync(operationDir)) {
+        fs.mkdirSync(operationDir, { recursive: true });
+      }
+      // Build frontmatter
+      const title = op.summary || `${op.method} ${op.path}`;
+      const frontmatter = {
+        title,
+        description: `API reference for ${op.method} ${op.path}`,
+        type: 'api-operation',
+        layout: 'operation',
+        // RapiDoc Mini configuration
+        specFile: tagSpecFile,
+        // RapiDoc match-paths format: "method /path" (e.g., "post /write")
+        matchPaths: `${method} ${op.path}`,
+        // Operation metadata
+        operationId: op.operationId,
+        method: op.method,
+        apiPath: op.path,
+        tag: tagName,
+      };
+      // Add compatibility version if present
+      if (op.compatVersion) {
+        frontmatter.compatVersion = op.compatVersion;
+      }
+      // Add related links from operation's externalDocs
+      if (op.externalDocs?.url) {
+        frontmatter.related = [op.externalDocs.url];
+      }
+      const pageContent = `---
+${yaml.dump(frontmatter)}---
+`;
+      fs.writeFileSync(operationFile, pageContent);
+      operationCount++;
+    }
+  }
+  console.log(
+    `✓ Generated ${operationCount} operation pages in ${contentPath}/api/`
+  );
+}
+/**
+ * Product configurations for all InfluxDB editions
+ *
+ * Maps product identifiers to their OpenAPI specs and content directories
+ */
+const productConfigs = {
+  // TODO: v2 products (cloud-v2, oss-v2) are disabled for now because they
+  // have existing Redoc-based API reference at /reference/api/
+  // Uncomment when ready to migrate v2 products to Scalar
+  // 'cloud-v2': {
+  //   specFile: path.join(API_DOCS_ROOT, 'influxdb/cloud/v2/ref.yml'),
+  //   pagesDir: path.join(DOCS_ROOT, 'content/influxdb/cloud/api'),
+  //   description: 'InfluxDB Cloud (v2 API)',
+  //   menuKey: 'influxdb_cloud',
+  // },
+  // 'oss-v2': {
+  //   specFile: path.join(API_DOCS_ROOT, 'influxdb/v2/v2/ref.yml'),
+  //   pagesDir: path.join(DOCS_ROOT, 'content/influxdb/v2/api'),
+  //   description: 'InfluxDB OSS v2',
+  //   menuKey: 'influxdb_v2',
+  // },
+  // InfluxDB 3 products use tag-based generation for better UX
+  // Keys use underscores to match Hugo data directory structure
+  influxdb3_core: {
+    specFile: path.join(API_DOCS_ROOT, 'influxdb3/core/v3/ref.yml'),
+    pagesDir: path.join(DOCS_ROOT, 'content/influxdb3/core'),
+    description: 'InfluxDB 3 Core',
+    menuKey: 'influxdb3_core',
+    useTagBasedGeneration: true,
+  },
+  influxdb3_enterprise: {
+    specFile: path.join(API_DOCS_ROOT, 'influxdb3/enterprise/v3/ref.yml'),
+    pagesDir: path.join(DOCS_ROOT, 'content/influxdb3/enterprise'),
+    description: 'InfluxDB 3 Enterprise',
+    menuKey: 'influxdb3_enterprise',
+    useTagBasedGeneration: true,
+  },
+  // Note: Cloud Dedicated, Serverless, and Clustered use management APIs
+  // with paths like /accounts/{accountId}/... so we put them under /api/
+  // These products have existing /reference/api/ pages with menu entries,
+  // so we skip adding menu entries to the generated parent pages.
+  'cloud-dedicated': {
+    specFile: path.join(
+      API_DOCS_ROOT,
+      'influxdb3/cloud-dedicated/management/openapi.yml'
+    ),
+    pagesDir: path.join(DOCS_ROOT, 'content/influxdb3/cloud-dedicated/api'),
+    description: 'InfluxDB Cloud Dedicated',
+    menuKey: 'influxdb3_cloud_dedicated',
+    skipParentMenu: true,
+  },
+  'cloud-serverless': {
+    specFile: path.join(
+      API_DOCS_ROOT,
+      'influxdb3/cloud-serverless/management/openapi.yml'
+    ),
+    pagesDir: path.join(DOCS_ROOT, 'content/influxdb3/cloud-serverless/api'),
+    description: 'InfluxDB Cloud Serverless',
+    menuKey: 'influxdb3_cloud_serverless',
+    skipParentMenu: true,
+  },
+  clustered: {
+    specFile: path.join(
+      API_DOCS_ROOT,
+      'influxdb3/clustered/management/openapi.yml'
+    ),
+    pagesDir: path.join(DOCS_ROOT, 'content/influxdb3/clustered/api'),
+    description: 'InfluxDB Clustered',
+    menuKey: 'influxdb3_clustered',
+    skipParentMenu: true,
+  },
+};
+exports.productConfigs = productConfigs;
+/**
+ * Process a single product: fetch spec, generate data, and create pages
+ *
+ * @param productKey - Product identifier (e.g., 'cloud-v2')
+ * @param config - Product configuration
+ */
+function processProduct(productKey, config) {
+  console.log('\n' + '='.repeat(80));
+  console.log(`Processing ${config.description || productKey}`);
+  console.log('='.repeat(80));
+  const staticPath = path.join(DOCS_ROOT, 'static/openapi');
+  const staticDirName = getStaticDirName(productKey);
+  const staticSpecPath = path.join(staticPath, `${staticDirName}.yml`);
+  const staticJsonSpecPath = path.join(staticPath, `${staticDirName}.json`);
+  const staticPathsPath = path.join(staticPath, `${staticDirName}/paths`);
+  const articlesPath = path.join(
+    DOCS_ROOT,
+    `data/article_data/influxdb/${productKey}`
+  );
+  // Check if spec file exists
+  if (!fs.existsSync(config.specFile)) {
+    console.warn(`⚠️  Spec file not found: ${config.specFile}`);
+    console.log('Skipping this product. Run getswagger.sh first if needed.\n');
+    return;
+  }
+  try {
+    // Step 1: Execute the getswagger.sh script to fetch/bundle the spec
+    // Note: getswagger.sh must run from api-docs/ because it uses relative paths
+    const getswaggerScript = path.join(API_DOCS_ROOT, 'getswagger.sh');
+    if (fs.existsSync(getswaggerScript)) {
+      execCommand(
+        `cd ${API_DOCS_ROOT} && ./getswagger.sh ${productKey} -B`,
+        `Fetching OpenAPI spec for ${productKey}`
+      );
+    } else {
+      console.log(`⚠️  getswagger.sh not found, skipping fetch step`);
+    }
+    // Step 2: Ensure static directory exists
+    if (!fs.existsSync(staticPath)) {
+      fs.mkdirSync(staticPath, { recursive: true });
+    }
+    // Step 3: Copy the generated OpenAPI spec to static folder (YAML)
+    if (fs.existsSync(config.specFile)) {
+      fs.copyFileSync(config.specFile, staticSpecPath);
+      console.log(`✓ Copied spec to ${staticSpecPath}`);
+      // Step 4: Generate JSON version of the spec
+      try {
+        const yaml = require('js-yaml');
+        const specContent = fs.readFileSync(config.specFile, 'utf8');
+        const specObject = yaml.load(specContent);
+        fs.writeFileSync(
+          staticJsonSpecPath,
+          JSON.stringify(specObject, null, 2)
+        );
+        console.log(`✓ Generated JSON spec at ${staticJsonSpecPath}`);
+      } catch (jsonError) {
+        console.warn(`⚠️  Could not generate JSON spec: ${jsonError}`);
+      }
+    }
+    // Step 5: Generate Hugo data from OpenAPI spec
+    if (config.useTagBasedGeneration) {
+      // Tag-based generation: group operations by OpenAPI tag
+      const staticTagsPath = path.join(staticPath, `${staticDirName}/tags`);
+      console.log(`\n📋 Using tag-based generation for ${productKey}...`);
+      openapiPathsToHugo.generateHugoDataByTag({
+        specFile: config.specFile,
+        dataOutPath: staticTagsPath,
+        articleOutPath: articlesPath,
+        includePaths: true, // Also generate path-based files for backwards compatibility
+      });
+      // Step 6: Generate Hugo content pages from tag-based article data
+      generateTagPagesFromArticleData({
+        articlesPath,
+        contentPath: config.pagesDir,
+        menuKey: config.menuKey,
+        menuParent: 'InfluxDB HTTP API',
+        skipParentMenu: config.skipParentMenu,
+      });
+    } else {
+      // Path-based generation: group paths by URL prefix (legacy)
+      generateDataFromOpenAPI(config.specFile, staticPathsPath, articlesPath);
+      // Step 6: Generate Hugo content pages from path-based article data
+      generatePagesFromArticleData({
+        articlesPath,
+        contentPath: config.pagesDir,
+        menuKey: config.menuKey,
+        menuParent: 'InfluxDB HTTP API',
+        skipParentMenu: config.skipParentMenu,
+      });
+    }
+    console.log(
+      `\n✅ Successfully processed ${config.description || productKey}\n`
+    );
+  } catch (error) {
+    console.error(`\n❌ Error processing ${productKey}:`, error);
+    process.exit(1);
+  }
+}
+/**
+ * Main execution function
+ */
+function main() {
+  const args = process.argv.slice(2);
+  // Determine which products to process
+  let productsToProcess;
+  if (args.length === 0) {
+    // No arguments: process all products
+    productsToProcess = Object.keys(productConfigs);
+    console.log('\n📋 Processing all products...\n');
+  } else {
+    // Arguments provided: process only specified products
+    productsToProcess = args;
+    console.log(
+      `\n📋 Processing specified products: ${productsToProcess.join(', ')}\n`
+    );
+  }
+  // Validate product keys
+  const invalidProducts = productsToProcess.filter(
+    (key) => !productConfigs[key]
+  );
+  if (invalidProducts.length > 0) {
+    console.error(
+      `\n❌ Invalid product identifier(s): ${invalidProducts.join(', ')}`
+    );
+    console.error('\nValid products:');
+    Object.keys(productConfigs).forEach((key) => {
+      console.error(`  - ${key}: ${productConfigs[key].description}`);
+    });
+    process.exit(1);
+  }
+  // Process each product
+  productsToProcess.forEach((productKey) => {
+    const config = productConfigs[productKey];
+    processProduct(productKey, config);
+  });
+  console.log('\n' + '='.repeat(80));
+  console.log('✅ All products processed successfully!');
+  console.log('='.repeat(80) + '\n');
+}
+// Execute if run directly
+if (require.main === module) {
+  main();
+}
+//# sourceMappingURL=generate-openapi-articles.js.map
diff --git a/api-docs/scripts/dist/openapi-paths-to-hugo-data/index.js b/api-docs/scripts/dist/openapi-paths-to-hugo-data/index.js
new file mode 100644
index 0000000000..09e66f4f87
--- /dev/null
+++ b/api-docs/scripts/dist/openapi-paths-to-hugo-data/index.js
@@ -0,0 +1,777 @@
+'use strict';
+/**
+ * OpenAPI to Hugo Data Converter
+ *
+ * Converts OpenAPI v3 specifications into Hugo-compatible data files.
+ * Generates both YAML and JSON versions of spec fragments grouped by path.
+ *
+ * @module openapi-paths-to-hugo-data
+ */
+var __createBinding =
+  (this && this.__createBinding) ||
+  (Object.create
+    ? function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        var desc = Object.getOwnPropertyDescriptor(m, k);
+        if (
+          !desc ||
+          ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)
+        ) {
+          desc = {
+            enumerable: true,
+            get: function () {
+              return m[k];
+            },
+          };
+        }
+        Object.defineProperty(o, k2, desc);
+      }
+    : function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        o[k2] = m[k];
+      });
+var __setModuleDefault =
+  (this && this.__setModuleDefault) ||
+  (Object.create
+    ? function (o, v) {
+        Object.defineProperty(o, 'default', { enumerable: true, value: v });
+      }
+    : function (o, v) {
+        o['default'] = v;
+      });
+var __importStar =
+  (this && this.__importStar) ||
+  (function () {
+    var ownKeys = function (o) {
+      ownKeys =
+        Object.getOwnPropertyNames ||
+        function (o) {
+          var ar = [];
+          for (var k in o)
+            if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+          return ar;
+        };
+      return ownKeys(o);
+    };
+    return function (mod) {
+      if (mod && mod.__esModule) return mod;
+      var result = {};
+      if (mod != null)
+        for (var k = ownKeys(mod), i = 0; i < k.length; i++)
+          if (k[i] !== 'default') __createBinding(result, mod, k[i]);
+      __setModuleDefault(result, mod);
+      return result;
+    };
+  })();
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.generateHugoDataByTag = generateHugoDataByTag;
+exports.generateHugoData = generateHugoData;
+const yaml = __importStar(require('js-yaml'));
+const fs = __importStar(require('fs'));
+const path = __importStar(require('path'));
+/**
+ * Read a YAML file and parse it
+ *
+ * @param filepath - Path to the YAML file
+ * @param encoding - File encoding (default: 'utf8')
+ * @returns Parsed YAML content
+ */
+function readFile(filepath, encoding = 'utf8') {
+  const content = fs.readFileSync(filepath, encoding);
+  return yaml.load(content);
+}
+/**
+ * Write data to a YAML file
+ *
+ * @param data - Data to write
+ * @param outputTo - Output file path
+ */
+function writeDataFile(data, outputTo) {
+  fs.writeFileSync(outputTo, yaml.dump(data));
+}
+/**
+ * Write data to a JSON file
+ *
+ * @param data - Data to write
+ * @param outputTo - Output file path
+ */
+function writeJsonFile(data, outputTo) {
+  fs.writeFileSync(outputTo, JSON.stringify(data, null, 2));
+}
+/**
+ * OpenAPI utility functions
+ */
+const openapiUtils = {
+  /**
+   * Check if a path fragment is a placeholder (e.g., {id})
+   *
+   * @param str - Path fragment to check
+   * @returns True if the fragment is a placeholder
+   */
+  isPlaceholderFragment(str) {
+    const placeholderRegex = /^\{.*\}$/;
+    return placeholderRegex.test(str);
+  },
+};
+/**
+ * Convert tag name to URL-friendly slug
+ *
+ * @param tagName - Tag name (e.g., "Write data", "Processing engine")
+ * @returns URL-friendly slug (e.g., "write-data", "processing-engine")
+ */
+function slugifyTag(tagName) {
+  return tagName
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-|-$/g, '');
+}
+/**
+ * Menu group mappings for tag-based navigation
+ * Maps OpenAPI tags to sidebar groups
+ */
+const TAG_MENU_GROUPS = {
+  // Concepts group
+  'Quick start': 'Concepts',
+  Authentication: 'Concepts',
+  'Headers and parameters': 'Concepts',
+  'Response codes': 'Concepts',
+  // Data Operations group
+  'Write data': 'Data Operations',
+  'Query data': 'Data Operations',
+  'Cache data': 'Data Operations',
+  // Administration group
+  Database: 'Administration',
+  Table: 'Administration',
+  Token: 'Administration',
+  // Processing Engine group
+  'Processing engine': 'Processing Engine',
+  // Server group
+  'Server information': 'Server',
+  // Compatibility group
+  'Compatibility endpoints': 'Compatibility',
+};
+/**
+ * Get menu group for a tag
+ *
+ * @param tagName - Tag name
+ * @returns Menu group name or 'Other' if not mapped
+ */
+function getMenuGroupForTag(tagName) {
+  return TAG_MENU_GROUPS[tagName] || 'Other';
+}
+/**
+ * HTTP methods to check for operations
+ */
+const HTTP_METHODS = [
+  'get',
+  'post',
+  'put',
+  'patch',
+  'delete',
+  'options',
+  'head',
+  'trace',
+];
+/**
+ * Extract all operations from an OpenAPI document grouped by tag
+ *
+ * @param openapi - OpenAPI document
+ * @returns Map of tag name to operations with that tag
+ */
+function extractOperationsByTag(openapi) {
+  const tagOperations = new Map();
+  Object.entries(openapi.paths).forEach(([pathKey, pathItem]) => {
+    HTTP_METHODS.forEach((method) => {
+      const operation = pathItem[method];
+      if (operation) {
+        const opMeta = {
+          operationId: operation.operationId || `${method}-${pathKey}`,
+          method: method.toUpperCase(),
+          path: pathKey,
+          summary: operation.summary || '',
+          tags: operation.tags || [],
+        };
+        // Extract compatibility version if present
+        if (operation['x-compatibility-version']) {
+          opMeta.compatVersion = operation['x-compatibility-version'];
+        }
+        // Extract externalDocs if present
+        if (operation.externalDocs) {
+          opMeta.externalDocs = {
+            description: operation.externalDocs.description || '',
+            url: operation.externalDocs.url,
+          };
+        }
+        // Add operation to each of its tags
+        (operation.tags || []).forEach((tag) => {
+          if (!tagOperations.has(tag)) {
+            tagOperations.set(tag, []);
+          }
+          tagOperations.get(tag).push(opMeta);
+        });
+      }
+    });
+  });
+  return tagOperations;
+}
+/**
+ * Write OpenAPI specs grouped by tag to separate files
+ * Generates both YAML and JSON versions per tag
+ *
+ * @param openapi - OpenAPI document
+ * @param prefix - Filename prefix for output files
+ * @param outPath - Output directory path
+ */
+function writeTagOpenapis(openapi, prefix, outPath) {
+  const tagOperations = extractOperationsByTag(openapi);
+  // Process each tag
+  tagOperations.forEach((operations, tagName) => {
+    // Deep copy openapi
+    const doc = JSON.parse(JSON.stringify(openapi));
+    // Filter paths to only include those with operations for this tag
+    const filteredPaths = {};
+    Object.entries(openapi.paths).forEach(([pathKey, pathItem]) => {
+      const filteredPathItem = {};
+      let hasOperations = false;
+      HTTP_METHODS.forEach((method) => {
+        const operation = pathItem[method];
+        if (operation?.tags?.includes(tagName)) {
+          // Clone the operation and restrict tags to only this tag
+          // This prevents RapiDoc from rendering the operation multiple times
+          // (once per tag) when an operation belongs to multiple tags
+          const filteredOperation = { ...operation, tags: [tagName] };
+          filteredPathItem[method] = filteredOperation;
+          hasOperations = true;
+        }
+      });
+      // Include path-level parameters if we have operations
+      if (hasOperations) {
+        if (pathItem.parameters) {
+          filteredPathItem.parameters = pathItem.parameters;
+        }
+        filteredPaths[pathKey] = filteredPathItem;
+      }
+    });
+    doc.paths = filteredPaths;
+    // Filter tags to only include this tag (and trait tags for context)
+    if (doc.tags) {
+      doc.tags = doc.tags.filter(
+        (tag) => tag.name === tagName || tag['x-traitTag']
+      );
+    }
+    // Update info
+    const tagSlug = slugifyTag(tagName);
+    doc.info.title = tagName;
+    doc.info.description = `API reference for ${tagName}`;
+    doc['x-tagGroup'] = tagName;
+    try {
+      if (!fs.existsSync(outPath)) {
+        fs.mkdirSync(outPath, { recursive: true });
+      }
+      const baseFilename = `${prefix}${tagSlug}`;
+      const yamlPath = path.resolve(outPath, `${baseFilename}.yaml`);
+      const jsonPath = path.resolve(outPath, `${baseFilename}.json`);
+      writeDataFile(doc, yamlPath);
+      writeJsonFile(doc, jsonPath);
+      console.log(
+        `Generated tag spec: ${baseFilename}.yaml (${Object.keys(filteredPaths).length} paths, ${operations.length} operations)`
+      );
+    } catch (err) {
+      console.error(`Error writing tag group ${tagName}:`, err);
+    }
+  });
+  // Also create specs for conceptual tags (x-traitTag) without operations
+  (openapi.tags || []).forEach((tag) => {
+    if (tag['x-traitTag'] && !tagOperations.has(tag.name)) {
+      const doc = JSON.parse(JSON.stringify(openapi));
+      doc.paths = {};
+      doc.tags = [tag];
+      doc.info.title = tag.name;
+      doc.info.description = tag.description || `API reference for ${tag.name}`;
+      doc['x-tagGroup'] = tag.name;
+      const tagSlug = slugifyTag(tag.name);
+      try {
+        const baseFilename = `${prefix}${tagSlug}`;
+        const yamlPath = path.resolve(outPath, `${baseFilename}.yaml`);
+        const jsonPath = path.resolve(outPath, `${baseFilename}.json`);
+        writeDataFile(doc, yamlPath);
+        writeJsonFile(doc, jsonPath);
+        console.log(`Generated conceptual tag spec: ${baseFilename}.yaml`);
+      } catch (err) {
+        console.error(`Error writing conceptual tag ${tag.name}:`, err);
+      }
+    }
+  });
+}
+/**
+ * Write OpenAPI specs grouped by path to separate files
+ * Generates both YAML and JSON versions
+ *
+ * @param openapi - OpenAPI document
+ * @param prefix - Filename prefix for output files
+ * @param outPath - Output directory path
+ */
+function writePathOpenapis(openapi, prefix, outPath) {
+  const pathGroups = {};
+  // Group paths by their base path (first 3-4 segments, excluding placeholders)
+  Object.keys(openapi.paths)
+    .sort()
+    .forEach((p) => {
+      const delimiter = '/';
+      let key = p.split(delimiter);
+      // Check if this is an item path (ends with a placeholder)
+      let isItemPath = openapiUtils.isPlaceholderFragment(key[key.length - 1]);
+      if (isItemPath) {
+        key = key.slice(0, -1);
+      }
+      // Take first 4 segments
+      key = key.slice(0, 4);
+      // Check if the last segment is still a placeholder
+      isItemPath = openapiUtils.isPlaceholderFragment(key[key.length - 1]);
+      if (isItemPath) {
+        key = key.slice(0, -1);
+      }
+      const groupKey = key.join('/');
+      pathGroups[groupKey] = pathGroups[groupKey] || {};
+      pathGroups[groupKey][p] = openapi.paths[p];
+    });
+  // Write each path group to separate YAML and JSON files
+  Object.keys(pathGroups).forEach((pg) => {
+    // Deep copy openapi
+    const doc = JSON.parse(JSON.stringify(openapi));
+    doc.paths = pathGroups[pg];
+    // Collect tags used by operations in this path group
+    const usedTags = new Set();
+    Object.values(doc.paths).forEach((pathItem) => {
+      const httpMethods = [
+        'get',
+        'post',
+        'put',
+        'patch',
+        'delete',
+        'options',
+        'head',
+        'trace',
+      ];
+      httpMethods.forEach((method) => {
+        const operation = pathItem[method];
+        if (operation?.tags) {
+          operation.tags.forEach((tag) => usedTags.add(tag));
+        }
+      });
+    });
+    // Filter tags to only include those used by operations in this path group
+    // Exclude x-traitTag tags (supplementary documentation tags)
+    if (doc.tags) {
+      doc.tags = doc.tags.filter(
+        (tag) => usedTags.has(tag.name) && !tag['x-traitTag']
+      );
+    }
+    // Simplify info for path-specific docs
+    doc.info.title = pg;
+    doc.info.description = `API reference for ${pg}`;
+    doc['x-pathGroup'] = pg;
+    try {
+      if (!fs.existsSync(outPath)) {
+        fs.mkdirSync(outPath, { recursive: true });
+      }
+      const baseFilename = `${prefix}${pg.replaceAll('/', '-').replace(/^-/, '')}`;
+      const yamlPath = path.resolve(outPath, `${baseFilename}.yaml`);
+      const jsonPath = path.resolve(outPath, `${baseFilename}.json`);
+      // Write both YAML and JSON versions
+      writeDataFile(doc, yamlPath);
+      writeJsonFile(doc, jsonPath);
+      console.log(`Generated: ${baseFilename}.yaml and ${baseFilename}.json`);
+    } catch (err) {
+      console.error(`Error writing path group ${pg}:`, err);
+    }
+  });
+}
+/**
+ * Create article metadata for a path group
+ *
+ * @param openapi - OpenAPI document with x-pathGroup
+ * @returns Article metadata object
+ */
+function createArticleDataForPathGroup(openapi) {
+  const article = {
+    path: '',
+    fields: {
+      name: openapi['x-pathGroup'] || '',
+      describes: Object.keys(openapi.paths),
+    },
+  };
+  /**
+   * Convert OpenAPI path to Hugo-friendly article path
+   * Legacy endpoints (without /api/ prefix) go under api/ directly
+   * Versioned endpoints (with /api/vN/) keep their structure
+   *
+   * @param p - Path to convert (e.g., '/health', '/api/v3/query_sql')
+   * @returns Path suitable for Hugo content directory (e.g., 'api/health', 'api/v3/query_sql')
+   */
+  const toHugoPath = (p) => {
+    if (!p) {
+      return '';
+    }
+    // If path doesn't start with /api/, it's a legacy endpoint
+    // Place it directly under api/ to avoid collision with /api/v1/* paths
+    if (!p.startsWith('/api/')) {
+      // /health -> api/health
+      // /write -> api/write
+      return `api${p}`;
+    }
+    // /api/v1/health -> api/v1/health
+    // /api/v2/write -> api/v2/write
+    // /api/v3/query_sql -> api/v3/query_sql
+    return p.replace(/^\//, '');
+  };
+  /**
+   * Convert path to tag-friendly format (dashes instead of slashes)
+   *
+   * @param p - Path to convert
+   * @returns Tag-friendly path
+   */
+  const toTagPath = (p) => {
+    if (!p) {
+      return '';
+    }
+    return p.replace(/^\//, '').replaceAll('/', '-');
+  };
+  const pathGroup = openapi['x-pathGroup'] || '';
+  article.path = toHugoPath(pathGroup);
+  // Store original path for menu display (shows actual endpoint path)
+  article.fields.menuName = pathGroup;
+  article.fields.title = openapi.info?.title;
+  article.fields.description = openapi.description;
+  const pathGroupFrags = path.parse(openapi['x-pathGroup'] || '');
+  article.fields.tags = [pathGroupFrags?.dir, pathGroupFrags?.name]
+    .filter(Boolean)
+    .map((t) => toTagPath(t));
+  // Extract x-relatedLinks and OpenAPI tags from path items or operations
+  const relatedLinks = [];
+  const apiTags = [];
+  const httpMethods = [
+    'get',
+    'post',
+    'put',
+    'patch',
+    'delete',
+    'options',
+    'head',
+    'trace',
+  ];
+  Object.values(openapi.paths).forEach((pathItem) => {
+    // Check path-level x-relatedLinks
+    if (
+      pathItem['x-relatedLinks'] &&
+      Array.isArray(pathItem['x-relatedLinks'])
+    ) {
+      relatedLinks.push(
+        ...pathItem['x-relatedLinks'].filter(
+          (link) => !relatedLinks.includes(link)
+        )
+      );
+    }
+    // Check operation-level x-relatedLinks and tags
+    httpMethods.forEach((method) => {
+      const operation = pathItem[method];
+      if (operation) {
+        // Extract x-relatedLinks
+        if (
+          operation['x-relatedLinks'] &&
+          Array.isArray(operation['x-relatedLinks'])
+        ) {
+          relatedLinks.push(
+            ...operation['x-relatedLinks'].filter(
+              (link) => !relatedLinks.includes(link)
+            )
+          );
+        }
+        // Extract OpenAPI tags from operation
+        if (operation.tags && Array.isArray(operation.tags)) {
+          operation.tags.forEach((tag) => {
+            if (!apiTags.includes(tag)) {
+              apiTags.push(tag);
+            }
+          });
+        }
+      }
+    });
+  });
+  // Only add related if there are links
+  if (relatedLinks.length > 0) {
+    article.fields.related = relatedLinks;
+  }
+  // Add OpenAPI tags from operations (for Hugo frontmatter)
+  if (apiTags.length > 0) {
+    article.fields.apiTags = apiTags;
+  }
+  return article;
+}
+/**
+ * Write OpenAPI article metadata to Hugo data files
+ * Generates articles.yml and articles.json
+ *
+ * @param sourcePath - Path to directory containing OpenAPI fragment files
+ * @param targetPath - Output path for article data
+ * @param opts - Options including file pattern filter
+ */
+function writeOpenapiArticleData(sourcePath, targetPath, opts) {
+  /**
+   * Check if path is a file
+   */
+  const isFile = (filePath) => {
+    return fs.lstatSync(filePath).isFile();
+  };
+  /**
+   * Check if filename matches pattern
+   */
+  const matchesPattern = (filePath) => {
+    return opts.filePattern
+      ? path.parse(filePath).name.startsWith(opts.filePattern)
+      : true;
+  };
+  try {
+    const articles = fs
+      .readdirSync(sourcePath)
+      .map((fileName) => path.join(sourcePath, fileName))
+      .filter(matchesPattern)
+      .filter(isFile)
+      .filter(
+        (filePath) => filePath.endsWith('.yaml') || filePath.endsWith('.yml')
+      ) // Only process YAML files
+      .map((filePath) => {
+        const openapi = readFile(filePath);
+        const article = createArticleDataForPathGroup(openapi);
+        article.fields.source = filePath;
+        // Hugo omits "/static" from the URI when serving files stored in "./static"
+        article.fields.staticFilePath = filePath.replace(/^static\//, '/');
+        return article;
+      });
+    if (!fs.existsSync(targetPath)) {
+      fs.mkdirSync(targetPath, { recursive: true });
+    }
+    const articleCollection = { articles };
+    // Write both YAML and JSON versions
+    const yamlPath = path.resolve(targetPath, 'articles.yml');
+    const jsonPath = path.resolve(targetPath, 'articles.json');
+    writeDataFile(articleCollection, yamlPath);
+    writeJsonFile(articleCollection, jsonPath);
+    console.log(`Generated ${articles.length} articles in ${targetPath}`);
+  } catch (e) {
+    console.error('Error writing article data:', e);
+  }
+}
+/**
+ * Create article data for a tag-based grouping
+ *
+ * @param openapi - OpenAPI document with x-tagGroup
+ * @param operations - Operations for this tag
+ * @param tagMeta - Tag metadata from OpenAPI spec
+ * @returns Article metadata object
+ */
+function createArticleDataForTag(openapi, operations, tagMeta) {
+  const tagName = openapi['x-tagGroup'] || '';
+  const tagSlug = slugifyTag(tagName);
+  const isConceptual = tagMeta?.['x-traitTag'] === true;
+  const article = {
+    path: `api/${tagSlug}`,
+    fields: {
+      name: tagName,
+      describes: Object.keys(openapi.paths),
+      title: tagName,
+      description:
+        tagMeta?.description ||
+        openapi.info?.description ||
+        `API reference for ${tagName}`,
+      tag: tagName,
+      isConceptual,
+      menuGroup: getMenuGroupForTag(tagName),
+      operations: operations.map((op) => ({
+        operationId: op.operationId,
+        method: op.method,
+        path: op.path,
+        summary: op.summary,
+        tags: op.tags,
+        ...(op.compatVersion && { compatVersion: op.compatVersion }),
+        ...(op.externalDocs && { externalDocs: op.externalDocs }),
+      })),
+    },
+  };
+  // Add tag description for conceptual pages
+  if (tagMeta?.description) {
+    article.fields.tagDescription = tagMeta.description;
+  }
+  // Aggregate unique externalDocs URLs from operations into article-level related
+  // This populates Hugo frontmatter `related` field for "Related content" links
+  const relatedUrls = new Set();
+  // First check tag-level externalDocs
+  if (tagMeta?.externalDocs?.url) {
+    relatedUrls.add(tagMeta.externalDocs.url);
+  }
+  // Then aggregate from operations
+  operations.forEach((op) => {
+    if (op.externalDocs?.url) {
+      relatedUrls.add(op.externalDocs.url);
+    }
+  });
+  if (relatedUrls.size > 0) {
+    article.fields.related = Array.from(relatedUrls);
+  }
+  return article;
+}
+/**
+ * Write tag-based OpenAPI article metadata to Hugo data files
+ * Generates articles.yml and articles.json
+ *
+ * @param sourcePath - Path to directory containing tag-based OpenAPI fragment files
+ * @param targetPath - Output path for article data
+ * @param openapi - Original OpenAPI document (for tag metadata)
+ * @param opts - Options including file pattern filter
+ */
+function writeOpenapiTagArticleData(sourcePath, targetPath, openapi, opts) {
+  const isFile = (filePath) => {
+    return fs.lstatSync(filePath).isFile();
+  };
+  const matchesPattern = (filePath) => {
+    return opts.filePattern
+      ? path.parse(filePath).name.startsWith(opts.filePattern)
+      : true;
+  };
+  // Create tag metadata lookup
+  const tagMetaMap = new Map();
+  (openapi.tags || []).forEach((tag) => {
+    tagMetaMap.set(tag.name, tag);
+  });
+  try {
+    const articles = fs
+      .readdirSync(sourcePath)
+      .map((fileName) => path.join(sourcePath, fileName))
+      .filter(matchesPattern)
+      .filter(isFile)
+      .filter(
+        (filePath) => filePath.endsWith('.yaml') || filePath.endsWith('.yml')
+      )
+      .map((filePath) => {
+        const tagOpenapi = readFile(filePath);
+        const tagName =
+          tagOpenapi['x-tagGroup'] || tagOpenapi.info?.title || '';
+        const tagMeta = tagMetaMap.get(tagName);
+        // Extract operations from the tag-filtered spec
+        const operations = [];
+        Object.entries(tagOpenapi.paths).forEach(([pathKey, pathItem]) => {
+          HTTP_METHODS.forEach((method) => {
+            const operation = pathItem[method];
+            if (operation) {
+              const opMeta = {
+                operationId: operation.operationId || `${method}-${pathKey}`,
+                method: method.toUpperCase(),
+                path: pathKey,
+                summary: operation.summary || '',
+                tags: operation.tags || [],
+              };
+              // Extract compatibility version if present
+              if (operation['x-compatibility-version']) {
+                opMeta.compatVersion = operation['x-compatibility-version'];
+              }
+              // Extract externalDocs if present
+              if (operation.externalDocs) {
+                opMeta.externalDocs = {
+                  description: operation.externalDocs.description || '',
+                  url: operation.externalDocs.url,
+                };
+              }
+              operations.push(opMeta);
+            }
+          });
+        });
+        const article = createArticleDataForTag(
+          tagOpenapi,
+          operations,
+          tagMeta
+        );
+        article.fields.source = filePath;
+        article.fields.staticFilePath = filePath.replace(/^static\//, '/');
+        return article;
+      });
+    if (!fs.existsSync(targetPath)) {
+      fs.mkdirSync(targetPath, { recursive: true });
+    }
+    const articleCollection = { articles };
+    // Write both YAML and JSON versions
+    const yamlPath = path.resolve(targetPath, 'articles.yml');
+    const jsonPath = path.resolve(targetPath, 'articles.json');
+    writeDataFile(articleCollection, yamlPath);
+    writeJsonFile(articleCollection, jsonPath);
+    console.log(
+      `Generated ${articles.length} tag-based articles in ${targetPath}`
+    );
+  } catch (e) {
+    console.error('Error writing tag article data:', e);
+  }
+}
+/**
+ * Generate Hugo data files from an OpenAPI specification grouped by tag
+ *
+ * This function:
+ * 1. Reads the OpenAPI spec file
+ * 2. Groups operations by their OpenAPI tags
+ * 3. Writes each tag group to separate YAML and JSON files
+ * 4. Generates tag-based article metadata for Hugo
+ *
+ * @param options - Generation options
+ */
+function generateHugoDataByTag(options) {
+  const filenamePrefix = `${path.parse(options.specFile).name}-`;
+  const sourceFile = readFile(options.specFile, 'utf8');
+  // Optionally generate path-based files for backwards compatibility
+  if (options.includePaths) {
+    console.log(
+      `\nGenerating OpenAPI path files in ${options.dataOutPath}....`
+    );
+    writePathOpenapis(sourceFile, filenamePrefix, options.dataOutPath);
+  }
+  // Generate tag-based files
+  const tagOutPath = options.includePaths
+    ? path.join(options.dataOutPath, 'tags')
+    : options.dataOutPath;
+  console.log(`\nGenerating OpenAPI tag files in ${tagOutPath}....`);
+  writeTagOpenapis(sourceFile, filenamePrefix, tagOutPath);
+  console.log(
+    `\nGenerating OpenAPI tag article data in ${options.articleOutPath}...`
+  );
+  writeOpenapiTagArticleData(tagOutPath, options.articleOutPath, sourceFile, {
+    filePattern: filenamePrefix,
+  });
+  console.log('\nTag-based generation complete!\n');
+}
+/**
+ * Generate Hugo data files from an OpenAPI specification
+ *
+ * This function:
+ * 1. Reads the OpenAPI spec file
+ * 2. Groups paths by their base path
+ * 3. Writes each group to separate YAML and JSON files
+ * 4. Generates article metadata for Hugo
+ *
+ * @param options - Generation options
+ */
+function generateHugoData(options) {
+  const filenamePrefix = `${path.parse(options.specFile).name}-`;
+  const sourceFile = readFile(options.specFile, 'utf8');
+  console.log(`\nGenerating OpenAPI path files in ${options.dataOutPath}....`);
+  writePathOpenapis(sourceFile, filenamePrefix, options.dataOutPath);
+  console.log(
+    `\nGenerating OpenAPI article data in ${options.articleOutPath}...`
+  );
+  writeOpenapiArticleData(options.dataOutPath, options.articleOutPath, {
+    filePattern: filenamePrefix,
+  });
+  console.log('\nGeneration complete!\n');
+}
+// CommonJS export for backward compatibility
+module.exports = {
+  generateHugoData,
+  generateHugoDataByTag,
+};
+//# sourceMappingURL=index.js.map
diff --git a/api-docs/scripts/generate-openapi-articles.ts b/api-docs/scripts/generate-openapi-articles.ts
new file mode 100644
index 0000000000..12db38fea0
--- /dev/null
+++ b/api-docs/scripts/generate-openapi-articles.ts
@@ -0,0 +1,863 @@
+#!/usr/bin/env node
+/**
+ * Generate OpenAPI Articles Script
+ *
+ * Generates Hugo data files and content pages from OpenAPI specifications
+ * for all InfluxDB products.
+ *
+ * This script:
+ * 1. Runs getswagger.sh to fetch/bundle OpenAPI specs
+ * 2. Copies specs to static directory for download
+ * 3. Generates path group fragments (YAML and JSON)
+ * 4. Creates article metadata (YAML and JSON)
+ * 5. Generates Hugo content pages from article data
+ *
+ * Usage:
+ *   node generate-openapi-articles.js                    # Generate all products
+ *   node generate-openapi-articles.js cloud-v2           # Generate single product
+ *   node generate-openapi-articles.js cloud-v2 oss-v2    # Generate multiple products
+ *
+ * @module generate-openapi-articles
+ */
+
+import { execSync } from 'child_process';
+import * as path from 'path';
+import * as fs from 'fs';
+
+// Import the OpenAPI to Hugo converter
+const openapiPathsToHugo = require('./openapi-paths-to-hugo-data/index.js');
+
+/**
+ * Operation metadata structure from tag-based articles
+ */
+interface OperationMeta {
+  operationId: string;
+  method: string;
+  path: string;
+  summary: string;
+  tags: string[];
+  /** Compatibility version (v1 or v2) for migration context */
+  compatVersion?: string;
+  /** External documentation link */
+  externalDocs?: {
+    description: string;
+    url: string;
+  };
+}
+
+/**
+ * Product configuration for API generation
+ */
+interface ProductConfig {
+  /** Path to the OpenAPI spec file */
+  specFile: string;
+  /** Path to the Hugo content directory for generated pages */
+  pagesDir: string;
+  /** Optional description of the product */
+  description?: string;
+  /** Hugo menu identifier for this product (e.g., 'influxdb3_core') */
+  menuKey?: string;
+  /** Skip adding menu entry to generated parent page (use when existing reference page has menu entry) */
+  skipParentMenu?: boolean;
+  /** Use tag-based generation instead of path-based (default: false) */
+  useTagBasedGeneration?: boolean;
+}
+
+/**
+ * Map of product identifiers to their configuration
+ */
+type ProductConfigMap = Record<string, ProductConfig>;
+
+// Calculate the relative paths
+const DOCS_ROOT = '.';
+const API_DOCS_ROOT = 'api-docs';
+
+/**
+ * Execute a shell command and handle errors
+ *
+ * @param command - Command to execute
+ * @param description - Human-readable description of the command
+ * @throws Exits process with code 1 on error
+ */
+function execCommand(command: string, description?: string): void {
+  try {
+    if (description) {
+      console.log(`\n${description}...`);
+    }
+    console.log(`Executing: ${command}\n`);
+    execSync(command, { stdio: 'inherit' });
+  } catch (error) {
+    console.error(`\n❌ Error executing command: ${command}`);
+    if (error instanceof Error) {
+      console.error(error.message);
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * Generate a clean static directory name from a product key.
+ * Handles the influxdb3_* products to avoid redundant 'influxdb-influxdb3' prefixes.
+ *
+ * @param productKey - Product identifier (e.g., 'cloud-v2', 'influxdb3_core')
+ * @returns Clean directory name (e.g., 'influxdb-cloud-v2', 'influxdb3-core')
+ */
+function getStaticDirName(productKey: string): string {
+  // For influxdb3_* products, convert underscore to hyphen and don't add prefix
+  if (productKey.startsWith('influxdb3_')) {
+    return productKey.replace('_', '-');
+  }
+  // For other products, add 'influxdb-' prefix
+  return `influxdb-${productKey}`;
+}
+
+/**
+ * Generate Hugo data files from OpenAPI specification
+ *
+ * @param specFile - Path to the OpenAPI spec file
+ * @param dataOutPath - Output path for OpenAPI path fragments
+ * @param articleOutPath - Output path for article metadata
+ */
+function generateDataFromOpenAPI(
+  specFile: string,
+  dataOutPath: string,
+  articleOutPath: string
+): void {
+  if (!fs.existsSync(dataOutPath)) {
+    fs.mkdirSync(dataOutPath, { recursive: true });
+  }
+
+  openapiPathsToHugo.generateHugoData({
+    dataOutPath,
+    articleOutPath,
+    specFile,
+  });
+}
+
+/**
+ * Options for generating pages from article data
+ */
+interface GeneratePagesOptions {
+  /** Path to the articles data directory */
+  articlesPath: string;
+  /** Output path for generated content pages */
+  contentPath: string;
+  /** Hugo menu identifier for navigation (e.g., 'influxdb3_core') */
+  menuKey?: string;
+  /** Parent menu item name (e.g., 'InfluxDB HTTP API') */
+  menuParent?: string;
+  /** Product description for the parent page */
+  productDescription?: string;
+  /** Skip adding menu entry to generated parent page */
+  skipParentMenu?: boolean;
+}
+
+/**
+ * Generate Hugo content pages from article data
+ *
+ * Creates markdown files with frontmatter from article metadata.
+ * Each article becomes a page with type: api that renders via Scalar.
+ *
+ * @param options - Generation options
+ */
+function generatePagesFromArticleData(options: GeneratePagesOptions): void {
+  const {
+    articlesPath,
+    contentPath,
+    menuKey,
+    menuParent,
+    productDescription,
+    skipParentMenu,
+  } = options;
+  const yaml = require('js-yaml');
+  const articlesFile = path.join(articlesPath, 'articles.yml');
+
+  if (!fs.existsSync(articlesFile)) {
+    console.warn(`⚠️  Articles file not found: ${articlesFile}`);
+    return;
+  }
+
+  // Read articles data
+  const articlesContent = fs.readFileSync(articlesFile, 'utf8');
+  const data = yaml.load(articlesContent) as {
+    articles: Array<{
+      path: string;
+      fields: Record<string, unknown>;
+    }>;
+  };
+
+  if (!data.articles || !Array.isArray(data.articles)) {
+    console.warn(`⚠️  No articles found in ${articlesFile}`);
+    return;
+  }
+
+  // Ensure content directory exists
+  if (!fs.existsSync(contentPath)) {
+    fs.mkdirSync(contentPath, { recursive: true });
+  }
+
+  // Determine the API parent directory from the first article's path
+  // e.g., if article path is "api/v1/health", the API root is "api"
+  const firstArticlePath = data.articles[0]?.path || '';
+  const apiRootDir = firstArticlePath.split('/')[0];
+
+  // Generate parent _index.md for the API section
+  if (apiRootDir) {
+    const apiParentDir = path.join(contentPath, apiRootDir);
+    const parentIndexFile = path.join(apiParentDir, '_index.md');
+
+    if (!fs.existsSync(apiParentDir)) {
+      fs.mkdirSync(apiParentDir, { recursive: true });
+    }
+
+    if (!fs.existsSync(parentIndexFile)) {
+      const parentFrontmatter: Record<string, unknown> = {
+        title: menuParent || 'HTTP API',
+        description:
+          productDescription ||
+          'API reference documentation for all available endpoints.',
+        weight: 104,
+      };
+
+      // Add menu entry for parent page (unless skipParentMenu is true)
+      if (menuKey && !skipParentMenu) {
+        parentFrontmatter.menu = {
+          [menuKey]: {
+            name: menuParent || 'HTTP API',
+          },
+        };
+      }
+
+      const parentContent = `---
+${yaml.dump(parentFrontmatter)}---
+`;
+
+      fs.writeFileSync(parentIndexFile, parentContent);
+      console.log(`✓ Generated parent index at ${parentIndexFile}`);
+    }
+  }
+
+  // Generate a page for each article
+  for (const article of data.articles) {
+    const pagePath = path.join(contentPath, article.path);
+    const pageFile = path.join(pagePath, '_index.md');
+
+    // Create directory if needed
+    if (!fs.existsSync(pagePath)) {
+      fs.mkdirSync(pagePath, { recursive: true });
+    }
+
+    // Build frontmatter object
+    // Use menuName for display (actual endpoint path like /health)
+    // Fall back to name or path if menuName is not set
+    const displayName =
+      article.fields.menuName || article.fields.name || article.path;
+    const frontmatter: Record<string, unknown> = {
+      title: displayName,
+      description: `API reference for ${displayName}`,
+      type: 'api',
+      // Use explicit layout to override Hugo's default section template lookup
+      // (Hugo's section lookup ignores `type`, so we need `layout` for the 3-column API layout)
+      layout: 'list',
+      staticFilePath: article.fields.staticFilePath,
+      weight: 100,
+    };
+
+    // Add menu entry if menuKey is provided
+    // Use menuName for menu display (shows actual endpoint path like /health)
+    if (menuKey) {
+      frontmatter.menu = {
+        [menuKey]: {
+          name: displayName,
+          ...(menuParent && { parent: menuParent }),
+        },
+      };
+    }
+
+    // Add related links if present in article fields
+    if (
+      article.fields.related &&
+      Array.isArray(article.fields.related) &&
+      article.fields.related.length > 0
+    ) {
+      frontmatter.related = article.fields.related;
+    }
+
+    // Add OpenAPI tags if present in article fields (for frontmatter metadata)
+    if (
+      article.fields.apiTags &&
+      Array.isArray(article.fields.apiTags) &&
+      article.fields.apiTags.length > 0
+    ) {
+      frontmatter.api_tags = article.fields.apiTags;
+    }
+
+    const pageContent = `---
+${yaml.dump(frontmatter)}---
+`;
+
+    fs.writeFileSync(pageFile, pageContent);
+  }
+
+  console.log(
+    `✓ Generated ${data.articles.length} content pages in ${contentPath}`
+  );
+}
+
+/**
+ * Options for generating tag-based pages from article data
+ */
+interface GenerateTagPagesOptions {
+  /** Path to the articles data directory */
+  articlesPath: string;
+  /** Output path for generated content pages */
+  contentPath: string;
+  /** Hugo menu identifier for navigation (e.g., 'influxdb3_core') */
+  menuKey?: string;
+  /** Parent menu item name (e.g., 'InfluxDB HTTP API') */
+  menuParent?: string;
+  /** Product description for the parent page */
+  productDescription?: string;
+  /** Skip adding menu entry to generated parent page */
+  skipParentMenu?: boolean;
+}
+
+/**
+ * Generate Hugo content pages from tag-based article data
+ *
+ * Creates markdown files with frontmatter from article metadata.
+ * Each article becomes a page with type: api that renders via RapiDoc.
+ * Includes operation metadata for TOC generation.
+ *
+ * @param options - Generation options
+ */
+function generateTagPagesFromArticleData(
+  options: GenerateTagPagesOptions
+): void {
+  const {
+    articlesPath,
+    contentPath,
+    menuKey,
+    menuParent,
+    productDescription,
+    skipParentMenu,
+  } = options;
+  const yaml = require('js-yaml');
+  const articlesFile = path.join(articlesPath, 'articles.yml');
+
+  if (!fs.existsSync(articlesFile)) {
+    console.warn(`⚠️  Articles file not found: ${articlesFile}`);
+    return;
+  }
+
+  // Read articles data
+  const articlesContent = fs.readFileSync(articlesFile, 'utf8');
+  const data = yaml.load(articlesContent) as {
+    articles: Array<{
+      path: string;
+      fields: {
+        name?: string;
+        title?: string;
+        description?: string;
+        tag?: string;
+        isConceptual?: boolean;
+        tagDescription?: string;
+        menuGroup?: string;
+        staticFilePath?: string;
+        operations?: OperationMeta[];
+        related?: string[];
+      };
+    }>;
+  };
+
+  if (!data.articles || !Array.isArray(data.articles)) {
+    console.warn(`⚠️  No articles found in ${articlesFile}`);
+    return;
+  }
+
+  // Ensure content directory exists
+  if (!fs.existsSync(contentPath)) {
+    fs.mkdirSync(contentPath, { recursive: true });
+  }
+
+  // Generate parent _index.md for the API section
+  const apiParentDir = path.join(contentPath, 'api');
+  const parentIndexFile = path.join(apiParentDir, '_index.md');
+
+  if (!fs.existsSync(apiParentDir)) {
+    fs.mkdirSync(apiParentDir, { recursive: true });
+  }
+
+  if (!fs.existsSync(parentIndexFile)) {
+    const parentFrontmatter: Record<string, unknown> = {
+      title: menuParent || 'HTTP API',
+      description:
+        productDescription ||
+        'API reference documentation for all available endpoints.',
+      weight: 104,
+    };
+
+    // Add menu entry for parent page (unless skipParentMenu is true)
+    if (menuKey && !skipParentMenu) {
+      parentFrontmatter.menu = {
+        [menuKey]: {
+          name: menuParent || 'HTTP API',
+        },
+      };
+    }
+
+    const parentContent = `---
+${yaml.dump(parentFrontmatter)}---
+`;
+
+    fs.writeFileSync(parentIndexFile, parentContent);
+    console.log(`✓ Generated parent index at ${parentIndexFile}`);
+  }
+
+  // Generate a page for each article (tag)
+  for (const article of data.articles) {
+    const pagePath = path.join(contentPath, article.path);
+    const pageFile = path.join(pagePath, '_index.md');
+
+    // Create directory if needed
+    if (!fs.existsSync(pagePath)) {
+      fs.mkdirSync(pagePath, { recursive: true });
+    }
+
+    // Build frontmatter object
+    const title = article.fields.title || article.fields.name || article.path;
+    const isConceptual = article.fields.isConceptual === true;
+
+    const frontmatter: Record<string, unknown> = {
+      title,
+      description: article.fields.description || `API reference for ${title}`,
+      type: 'api',
+      layout: isConceptual ? 'single' : 'list',
+      staticFilePath: article.fields.staticFilePath,
+      weight: 100,
+      // Tag-based fields
+      tag: article.fields.tag,
+      isConceptual,
+      menuGroup: article.fields.menuGroup,
+    };
+
+    // Add operations for TOC generation (only for non-conceptual pages)
+    if (
+      !isConceptual &&
+      article.fields.operations &&
+      article.fields.operations.length > 0
+    ) {
+      frontmatter.operations = article.fields.operations;
+    }
+
+    // Add tag description for conceptual pages
+    if (isConceptual && article.fields.tagDescription) {
+      frontmatter.tagDescription = article.fields.tagDescription;
+    }
+
+    // Note: We deliberately don't add menu entries for tag-based API pages.
+    // The API sidebar navigation (api/sidebar-nav.html) handles navigation
+    // for API reference pages, avoiding conflicts with existing menu items
+    // like "Query data" and "Write data" that exist in the main sidebar.
+
+    // Add related links if present in article fields
+    if (
+      article.fields.related &&
+      Array.isArray(article.fields.related) &&
+      article.fields.related.length > 0
+    ) {
+      frontmatter.related = article.fields.related;
+    }
+
+    const pageContent = `---
+${yaml.dump(frontmatter)}---
+`;
+
+    fs.writeFileSync(pageFile, pageContent);
+  }
+
+  console.log(
+    `✓ Generated ${data.articles.length} tag-based content pages in ${contentPath}`
+  );
+
+  // Generate individual operation pages for standalone URLs
+  generateOperationPages({
+    articlesPath,
+    contentPath,
+  });
+}
+
+/**
+ * Options for generating operation pages
+ */
+interface GenerateOperationPagesOptions {
+  /** Path to the articles data directory */
+  articlesPath: string;
+  /** Output path for generated content pages */
+  contentPath: string;
+}
+
+/**
+ * Convert API path to URL-safe slug
+ *
+ * Transforms an API path like "/api/v3/write_lp" to a URL-friendly format.
+ * Removes leading slash and uses the path as-is (underscores are URL-safe).
+ *
+ * @param apiPath - The API path (e.g., "/write", "/api/v3/write_lp")
+ * @returns URL-safe path slug (e.g., "write", "api/v3/write_lp")
+ */
+function apiPathToSlug(apiPath: string): string {
+  // Remove leading slash, keep underscores (they're URL-safe)
+  return apiPath.replace(/^\//, '');
+}
+
+/**
+ * Generate standalone Hugo content pages for each API operation
+ *
+ * Creates individual pages at path-based URLs like /api/write/post/
+ * for each operation, using RapiDoc Mini with tag-level specs.
+ *
+ * @param options - Generation options
+ */
+function generateOperationPages(options: GenerateOperationPagesOptions): void {
+  const { articlesPath, contentPath } = options;
+  const yaml = require('js-yaml');
+  const articlesFile = path.join(articlesPath, 'articles.yml');
+
+  if (!fs.existsSync(articlesFile)) {
+    console.warn(`⚠️  Articles file not found: ${articlesFile}`);
+    return;
+  }
+
+  // Read articles data
+  const articlesContent = fs.readFileSync(articlesFile, 'utf8');
+  const data = yaml.load(articlesContent) as {
+    articles: Array<{
+      path: string;
+      fields: {
+        name?: string;
+        title?: string;
+        tag?: string;
+        isConceptual?: boolean;
+        staticFilePath?: string;
+        operations?: OperationMeta[];
+        related?: string[];
+      };
+    }>;
+  };
+
+  if (!data.articles || !Array.isArray(data.articles)) {
+    console.warn(`⚠️  No articles found in ${articlesFile}`);
+    return;
+  }
+
+  let operationCount = 0;
+
+  // Process each article (tag) and generate pages for its operations
+  for (const article of data.articles) {
+    // Skip conceptual articles (they don't have operations)
+    if (article.fields.isConceptual) {
+      continue;
+    }
+
+    const operations = article.fields.operations || [];
+    const tagSpecFile = article.fields.staticFilePath;
+    const tagName = article.fields.tag || article.fields.name || '';
+
+    for (const op of operations) {
+      // Build operation page path: api/{path}/{method}/
+      // e.g., /write -> api/write/post/
+      // e.g., /api/v3/write_lp -> api/api/v3/write_lp/post/
+      const pathSlug = apiPathToSlug(op.path);
+      const method = op.method.toLowerCase();
+      const operationDir = path.join(contentPath, 'api', pathSlug, method);
+      const operationFile = path.join(operationDir, '_index.md');
+
+      // Create directory if needed
+      if (!fs.existsSync(operationDir)) {
+        fs.mkdirSync(operationDir, { recursive: true });
+      }
+
+      // Build frontmatter
+      const title = op.summary || `${op.method} ${op.path}`;
+      const frontmatter: Record<string, unknown> = {
+        title,
+        description: `API reference for ${op.method} ${op.path}`,
+        type: 'api-operation',
+        layout: 'operation',
+        // RapiDoc Mini configuration
+        specFile: tagSpecFile,
+        // RapiDoc match-paths format: "method /path" (e.g., "post /write")
+        matchPaths: `${method} ${op.path}`,
+        // Operation metadata
+        operationId: op.operationId,
+        method: op.method,
+        apiPath: op.path,
+        tag: tagName,
+      };
+
+      // Add compatibility version if present
+      if (op.compatVersion) {
+        frontmatter.compatVersion = op.compatVersion;
+      }
+
+      // Add related links from operation's externalDocs
+      if (op.externalDocs?.url) {
+        frontmatter.related = [op.externalDocs.url];
+      }
+
+      const pageContent = `---
+${yaml.dump(frontmatter)}---
+`;
+
+      fs.writeFileSync(operationFile, pageContent);
+      operationCount++;
+    }
+  }
+
+  console.log(
+    `✓ Generated ${operationCount} operation pages in ${contentPath}/api/`
+  );
+}
+
+/**
+ * Product configurations for all InfluxDB editions
+ *
+ * Maps product identifiers to their OpenAPI specs and content directories
+ */
+const productConfigs: ProductConfigMap = {
+  // TODO: v2 products (cloud-v2, oss-v2) are disabled for now because they
+  // have existing Redoc-based API reference at /reference/api/
+  // Uncomment when ready to migrate v2 products to Scalar
+  // 'cloud-v2': {
+  //   specFile: path.join(API_DOCS_ROOT, 'influxdb/cloud/v2/ref.yml'),
+  //   pagesDir: path.join(DOCS_ROOT, 'content/influxdb/cloud/api'),
+  //   description: 'InfluxDB Cloud (v2 API)',
+  //   menuKey: 'influxdb_cloud',
+  // },
+  // 'oss-v2': {
+  //   specFile: path.join(API_DOCS_ROOT, 'influxdb/v2/v2/ref.yml'),
+  //   pagesDir: path.join(DOCS_ROOT, 'content/influxdb/v2/api'),
+  //   description: 'InfluxDB OSS v2',
+  //   menuKey: 'influxdb_v2',
+  // },
+  // InfluxDB 3 products use tag-based generation for better UX
+  // Keys use underscores to match Hugo data directory structure
+  influxdb3_core: {
+    specFile: path.join(API_DOCS_ROOT, 'influxdb3/core/v3/ref.yml'),
+    pagesDir: path.join(DOCS_ROOT, 'content/influxdb3/core'),
+    description: 'InfluxDB 3 Core',
+    menuKey: 'influxdb3_core',
+    useTagBasedGeneration: true,
+  },
+  influxdb3_enterprise: {
+    specFile: path.join(API_DOCS_ROOT, 'influxdb3/enterprise/v3/ref.yml'),
+    pagesDir: path.join(DOCS_ROOT, 'content/influxdb3/enterprise'),
+    description: 'InfluxDB 3 Enterprise',
+    menuKey: 'influxdb3_enterprise',
+    useTagBasedGeneration: true,
+  },
+  // Note: Cloud Dedicated, Serverless, and Clustered use management APIs
+  // with paths like /accounts/{accountId}/... so we put them under /api/
+  // These products have existing /reference/api/ pages with menu entries,
+  // so we skip adding menu entries to the generated parent pages.
+  'cloud-dedicated': {
+    specFile: path.join(
+      API_DOCS_ROOT,
+      'influxdb3/cloud-dedicated/management/openapi.yml'
+    ),
+    pagesDir: path.join(DOCS_ROOT, 'content/influxdb3/cloud-dedicated/api'),
+    description: 'InfluxDB Cloud Dedicated',
+    menuKey: 'influxdb3_cloud_dedicated',
+    skipParentMenu: true,
+  },
+  'cloud-serverless': {
+    specFile: path.join(
+      API_DOCS_ROOT,
+      'influxdb3/cloud-serverless/management/openapi.yml'
+    ),
+    pagesDir: path.join(DOCS_ROOT, 'content/influxdb3/cloud-serverless/api'),
+    description: 'InfluxDB Cloud Serverless',
+    menuKey: 'influxdb3_cloud_serverless',
+    skipParentMenu: true,
+  },
+  clustered: {
+    specFile: path.join(
+      API_DOCS_ROOT,
+      'influxdb3/clustered/management/openapi.yml'
+    ),
+    pagesDir: path.join(DOCS_ROOT, 'content/influxdb3/clustered/api'),
+    description: 'InfluxDB Clustered',
+    menuKey: 'influxdb3_clustered',
+    skipParentMenu: true,
+  },
+};
+
+/**
+ * Process a single product: fetch spec, generate data, and create pages
+ *
+ * @param productKey - Product identifier (e.g., 'cloud-v2')
+ * @param config - Product configuration
+ */
+function processProduct(productKey: string, config: ProductConfig): void {
+  console.log('\n' + '='.repeat(80));
+  console.log(`Processing ${config.description || productKey}`);
+  console.log('='.repeat(80));
+
+  const staticPath = path.join(DOCS_ROOT, 'static/openapi');
+  const staticDirName = getStaticDirName(productKey);
+  const staticSpecPath = path.join(staticPath, `${staticDirName}.yml`);
+  const staticJsonSpecPath = path.join(staticPath, `${staticDirName}.json`);
+  const staticPathsPath = path.join(staticPath, `${staticDirName}/paths`);
+  const articlesPath = path.join(
+    DOCS_ROOT,
+    `data/article_data/influxdb/${productKey}`
+  );
+
+  // Check if spec file exists
+  if (!fs.existsSync(config.specFile)) {
+    console.warn(`⚠️  Spec file not found: ${config.specFile}`);
+    console.log('Skipping this product. Run getswagger.sh first if needed.\n');
+    return;
+  }
+
+  try {
+    // Step 1: Execute the getswagger.sh script to fetch/bundle the spec
+    // Note: getswagger.sh must run from api-docs/ because it uses relative paths
+    const getswaggerScript = path.join(API_DOCS_ROOT, 'getswagger.sh');
+    if (fs.existsSync(getswaggerScript)) {
+      execCommand(
+        `cd ${API_DOCS_ROOT} && ./getswagger.sh ${productKey} -B`,
+        `Fetching OpenAPI spec for ${productKey}`
+      );
+    } else {
+      console.log(`⚠️  getswagger.sh not found, skipping fetch step`);
+    }
+
+    // Step 2: Ensure static directory exists
+    if (!fs.existsSync(staticPath)) {
+      fs.mkdirSync(staticPath, { recursive: true });
+    }
+
+    // Step 3: Copy the generated OpenAPI spec to static folder (YAML)
+    if (fs.existsSync(config.specFile)) {
+      fs.copyFileSync(config.specFile, staticSpecPath);
+      console.log(`✓ Copied spec to ${staticSpecPath}`);
+
+      // Step 4: Generate JSON version of the spec
+      try {
+        const yaml = require('js-yaml');
+        const specContent = fs.readFileSync(config.specFile, 'utf8');
+        const specObject = yaml.load(specContent);
+        fs.writeFileSync(
+          staticJsonSpecPath,
+          JSON.stringify(specObject, null, 2)
+        );
+        console.log(`✓ Generated JSON spec at ${staticJsonSpecPath}`);
+      } catch (jsonError) {
+        console.warn(`⚠️  Could not generate JSON spec: ${jsonError}`);
+      }
+    }
+
+    // Step 5: Generate Hugo data from OpenAPI spec
+    if (config.useTagBasedGeneration) {
+      // Tag-based generation: group operations by OpenAPI tag
+      const staticTagsPath = path.join(staticPath, `${staticDirName}/tags`);
+      console.log(`\n📋 Using tag-based generation for ${productKey}...`);
+      openapiPathsToHugo.generateHugoDataByTag({
+        specFile: config.specFile,
+        dataOutPath: staticTagsPath,
+        articleOutPath: articlesPath,
+        includePaths: true, // Also generate path-based files for backwards compatibility
+      });
+
+      // Step 6: Generate Hugo content pages from tag-based article data
+      generateTagPagesFromArticleData({
+        articlesPath,
+        contentPath: config.pagesDir,
+        menuKey: config.menuKey,
+        menuParent: 'InfluxDB HTTP API',
+        skipParentMenu: config.skipParentMenu,
+      });
+    } else {
+      // Path-based generation: group paths by URL prefix (legacy)
+      generateDataFromOpenAPI(config.specFile, staticPathsPath, articlesPath);
+
+      // Step 6: Generate Hugo content pages from path-based article data
+      generatePagesFromArticleData({
+        articlesPath,
+        contentPath: config.pagesDir,
+        menuKey: config.menuKey,
+        menuParent: 'InfluxDB HTTP API',
+        skipParentMenu: config.skipParentMenu,
+      });
+    }
+
+    console.log(
+      `\n✅ Successfully processed ${config.description || productKey}\n`
+    );
+  } catch (error) {
+    console.error(`\n❌ Error processing ${productKey}:`, error);
+    process.exit(1);
+  }
+}
+
+/**
+ * Main execution function
+ */
+function main(): void {
+  const args = process.argv.slice(2);
+
+  // Determine which products to process
+  let productsToProcess: string[];
+
+  if (args.length === 0) {
+    // No arguments: process all products
+    productsToProcess = Object.keys(productConfigs);
+    console.log('\n📋 Processing all products...\n');
+  } else {
+    // Arguments provided: process only specified products
+    productsToProcess = args;
+    console.log(
+      `\n📋 Processing specified products: ${productsToProcess.join(', ')}\n`
+    );
+  }
+
+  // Validate product keys
+  const invalidProducts = productsToProcess.filter(
+    (key) => !productConfigs[key]
+  );
+  if (invalidProducts.length > 0) {
+    console.error(
+      `\n❌ Invalid product identifier(s): ${invalidProducts.join(', ')}`
+    );
+    console.error('\nValid products:');
+    Object.keys(productConfigs).forEach((key) => {
+      console.error(`  - ${key}: ${productConfigs[key].description}`);
+    });
+    process.exit(1);
+  }
+
+  // Process each product
+  productsToProcess.forEach((productKey) => {
+    const config = productConfigs[productKey];
+    processProduct(productKey, config);
+  });
+
+  console.log('\n' + '='.repeat(80));
+  console.log('✅ All products processed successfully!');
+  console.log('='.repeat(80) + '\n');
+}
+
+// Execute if run directly
+if (require.main === module) {
+  main();
+}
+
+// Export for use as a module
+export {
+  productConfigs,
+  processProduct,
+  generateDataFromOpenAPI,
+  generatePagesFromArticleData,
+};
diff --git a/api-docs/scripts/openapi-paths-to-hugo-data/index.ts b/api-docs/scripts/openapi-paths-to-hugo-data/index.ts
new file mode 100644
index 0000000000..8492230b62
--- /dev/null
+++ b/api-docs/scripts/openapi-paths-to-hugo-data/index.ts
@@ -0,0 +1,1145 @@
+/**
+ * OpenAPI to Hugo Data Converter
+ *
+ * Converts OpenAPI v3 specifications into Hugo-compatible data files.
+ * Generates both YAML and JSON versions of spec fragments grouped by path.
+ *
+ * @module openapi-paths-to-hugo-data
+ */
+
+import * as yaml from 'js-yaml';
+import * as fs from 'fs';
+import * as path from 'path';
+
+/**
+ * OpenAPI path item object
+ */
+interface PathItem {
+  get?: Operation;
+  post?: Operation;
+  put?: Operation;
+  patch?: Operation;
+  delete?: Operation;
+  options?: Operation;
+  head?: Operation;
+  trace?: Operation;
+  parameters?: Parameter[];
+  [key: string]: unknown;
+}
+
+/**
+ * OpenAPI operation object
+ */
+interface Operation {
+  operationId?: string;
+  summary?: string;
+  description?: string;
+  tags?: string[];
+  parameters?: Parameter[];
+  requestBody?: RequestBody;
+  responses?: Record<string, Response>;
+  externalDocs?: ExternalDocs;
+  /** Compatibility version for migration context (v1 or v2) */
+  'x-compatibility-version'?: string;
+  [key: string]: unknown;
+}
+
+/**
+ * OpenAPI parameter object
+ */
+interface Parameter {
+  name: string;
+  in: 'query' | 'header' | 'path' | 'cookie';
+  description?: string;
+  required?: boolean;
+  schema?: Schema;
+  [key: string]: unknown;
+}
+
+/**
+ * OpenAPI request body object
+ */
+interface RequestBody {
+  description?: string;
+  content?: Record<string, MediaType>;
+  required?: boolean;
+  [key: string]: unknown;
+}
+
+/**
+ * OpenAPI response object
+ */
+interface Response {
+  description: string;
+  content?: Record<string, MediaType>;
+  headers?: Record<string, Header>;
+  [key: string]: unknown;
+}
+
+/**
+ * OpenAPI media type object
+ */
+interface MediaType {
+  schema?: Schema;
+  example?: unknown;
+  examples?: Record<string, Example>;
+  [key: string]: unknown;
+}
+
+/**
+ * OpenAPI schema object
+ */
+interface Schema {
+  type?: string;
+  format?: string;
+  description?: string;
+  properties?: Record<string, Schema>;
+  items?: Schema;
+  required?: string[];
+  [key: string]: unknown;
+}
+
+/**
+ * OpenAPI header object
+ */
+interface Header {
+  description?: string;
+  schema?: Schema;
+  [key: string]: unknown;
+}
+
+/**
+ * OpenAPI example object
+ */
+interface Example {
+  summary?: string;
+  description?: string;
+  value?: unknown;
+  [key: string]: unknown;
+}
+
+/**
+ * OpenAPI document structure
+ */
+interface OpenAPIDocument {
+  openapi: string;
+  info: Info;
+  paths: Record<string, PathItem>;
+  components?: Components;
+  servers?: Server[];
+  tags?: Tag[];
+  description?: string;
+  'x-pathGroup'?: string;
+  [key: string]: unknown;
+}
+
+/**
+ * OpenAPI info object
+ */
+interface Info {
+  title: string;
+  version: string;
+  description?: string;
+  termsOfService?: string;
+  contact?: Contact;
+  license?: License;
+  [key: string]: unknown;
+}
+
+/**
+ * OpenAPI contact object
+ */
+interface Contact {
+  name?: string;
+  url?: string;
+  email?: string;
+  [key: string]: unknown;
+}
+
+/**
+ * OpenAPI license object
+ */
+interface License {
+  name: string;
+  url?: string;
+  [key: string]: unknown;
+}
+
+/**
+ * OpenAPI components object
+ */
+interface Components {
+  schemas?: Record<string, Schema>;
+  responses?: Record<string, Response>;
+  parameters?: Record<string, Parameter>;
+  requestBodies?: Record<string, RequestBody>;
+  headers?: Record<string, Header>;
+  securitySchemes?: Record<string, SecurityScheme>;
+  [key: string]: unknown;
+}
+
+/**
+ * OpenAPI security scheme object
+ */
+interface SecurityScheme {
+  type: string;
+  description?: string;
+  [key: string]: unknown;
+}
+
+/**
+ * OpenAPI server object
+ */
+interface Server {
+  url: string;
+  description?: string;
+  variables?: Record<string, ServerVariable>;
+  [key: string]: unknown;
+}
+
+/**
+ * OpenAPI server variable object
+ */
+interface ServerVariable {
+  default: string;
+  enum?: string[];
+  description?: string;
+  [key: string]: unknown;
+}
+
+/**
+ * OpenAPI tag object
+ */
+interface Tag {
+  name: string;
+  description?: string;
+  externalDocs?: ExternalDocs;
+  /** Indicates this is a conceptual/supplementary tag (no operations) */
+  'x-traitTag'?: boolean;
+  [key: string]: unknown;
+}
+
+/**
+ * Operation metadata for TOC generation
+ */
+interface OperationMeta {
+  operationId: string;
+  method: string;
+  path: string;
+  summary: string;
+  tags: string[];
+  /** Compatibility version (v1 or v2) for migration context */
+  compatVersion?: string;
+  /** External documentation link */
+  externalDocs?: {
+    description: string;
+    url: string;
+  };
+}
+
+/**
+ * OpenAPI external docs object
+ */
+interface ExternalDocs {
+  url: string;
+  description?: string;
+  [key: string]: unknown;
+}
+
+/**
+ * Article metadata for Hugo
+ */
+interface Article {
+  path: string;
+  fields: {
+    name: string;
+    describes: string[];
+    title?: string;
+    description?: string;
+    tags?: string[];
+    source?: string;
+    staticFilePath?: string;
+    /** Related documentation links extracted from x-relatedLinks */
+    related?: string[];
+    /** OpenAPI tags from operations (for Hugo frontmatter) */
+    apiTags?: string[];
+    /** Menu display name (actual endpoint path, different from Hugo path) */
+    menuName?: string;
+    /** OpenAPI tag name (for tag-based articles) */
+    tag?: string;
+    /** Whether this is a conceptual tag (x-traitTag) */
+    isConceptual?: boolean;
+    /** Tag description from OpenAPI spec */
+    tagDescription?: string;
+    /** Sidebar navigation group */
+    menuGroup?: string;
+    /** Operations metadata for TOC generation */
+    operations?: OperationMeta[];
+  };
+}
+
+/**
+ * Article collection for Hugo data files
+ */
+interface ArticleCollection {
+  articles: Article[];
+}
+
+/**
+ * Options for generating Hugo data
+ */
+export interface GenerateHugoDataOptions {
+  /** Path to the OpenAPI spec file */
+  specFile: string;
+  /** Output path for generated OpenAPI path fragments */
+  dataOutPath: string;
+  /** Output path for article metadata */
+  articleOutPath: string;
+}
+
+/**
+ * Options for writing OpenAPI article data
+ */
+interface WriteOpenapiArticleDataOptions {
+  /** File pattern to match when filtering files */
+  filePattern?: string;
+}
+
+/**
+ * Read a YAML file and parse it
+ *
+ * @param filepath - Path to the YAML file
+ * @param encoding - File encoding (default: 'utf8')
+ * @returns Parsed YAML content
+ */
+function readFile(
+  filepath: string,
+  encoding: BufferEncoding = 'utf8'
+): OpenAPIDocument {
+  const content = fs.readFileSync(filepath, encoding);
+  return yaml.load(content) as OpenAPIDocument;
+}
+
+/**
+ * Write data to a YAML file
+ *
+ * @param data - Data to write
+ * @param outputTo - Output file path
+ */
+function writeDataFile(data: unknown, outputTo: string): void {
+  fs.writeFileSync(outputTo, yaml.dump(data));
+}
+
+/**
+ * Write data to a JSON file
+ *
+ * @param data - Data to write
+ * @param outputTo - Output file path
+ */
+function writeJsonFile(data: unknown, outputTo: string): void {
+  fs.writeFileSync(outputTo, JSON.stringify(data, null, 2));
+}
+
+/**
+ * OpenAPI utility functions
+ */
+const openapiUtils = {
+  /**
+   * Check if a path fragment is a placeholder (e.g., {id})
+   *
+   * @param str - Path fragment to check
+   * @returns True if the fragment is a placeholder
+   */
+  isPlaceholderFragment(str: string): boolean {
+    const placeholderRegex = /^\{.*\}$/;
+    return placeholderRegex.test(str);
+  },
+};
+
+/**
+ * Convert tag name to URL-friendly slug
+ *
+ * @param tagName - Tag name (e.g., "Write data", "Processing engine")
+ * @returns URL-friendly slug (e.g., "write-data", "processing-engine")
+ */
+function slugifyTag(tagName: string): string {
+  return tagName
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-|-$/g, '');
+}
+
+/**
+ * Menu group mappings for tag-based navigation
+ * Maps OpenAPI tags to sidebar groups
+ */
+const TAG_MENU_GROUPS: Record<string, string> = {
+  // Concepts group
+  'Quick start': 'Concepts',
+  Authentication: 'Concepts',
+  'Headers and parameters': 'Concepts',
+  'Response codes': 'Concepts',
+  // Data Operations group
+  'Write data': 'Data Operations',
+  'Query data': 'Data Operations',
+  'Cache data': 'Data Operations',
+  // Administration group
+  Database: 'Administration',
+  Table: 'Administration',
+  Token: 'Administration',
+  // Processing Engine group
+  'Processing engine': 'Processing Engine',
+  // Server group
+  'Server information': 'Server',
+  // Compatibility group
+  'Compatibility endpoints': 'Compatibility',
+};
+
+/**
+ * Get menu group for a tag
+ *
+ * @param tagName - Tag name
+ * @returns Menu group name or 'Other' if not mapped
+ */
+function getMenuGroupForTag(tagName: string): string {
+  return TAG_MENU_GROUPS[tagName] || 'Other';
+}
+
+/**
+ * HTTP methods to check for operations
+ */
+const HTTP_METHODS = [
+  'get',
+  'post',
+  'put',
+  'patch',
+  'delete',
+  'options',
+  'head',
+  'trace',
+] as const;
+
+/**
+ * Extract all operations from an OpenAPI document grouped by tag
+ *
+ * @param openapi - OpenAPI document
+ * @returns Map of tag name to operations with that tag
+ */
+function extractOperationsByTag(
+  openapi: OpenAPIDocument
+): Map<string, OperationMeta[]> {
+  const tagOperations = new Map<string, OperationMeta[]>();
+
+  Object.entries(openapi.paths).forEach(([pathKey, pathItem]) => {
+    HTTP_METHODS.forEach((method) => {
+      const operation = pathItem[method] as Operation | undefined;
+      if (operation) {
+        const opMeta: OperationMeta = {
+          operationId: operation.operationId || `${method}-${pathKey}`,
+          method: method.toUpperCase(),
+          path: pathKey,
+          summary: operation.summary || '',
+          tags: operation.tags || [],
+        };
+
+        // Extract compatibility version if present
+        if (operation['x-compatibility-version']) {
+          opMeta.compatVersion = operation['x-compatibility-version'];
+        }
+
+        // Extract externalDocs if present
+        if (operation.externalDocs) {
+          opMeta.externalDocs = {
+            description: operation.externalDocs.description || '',
+            url: operation.externalDocs.url,
+          };
+        }
+
+        // Add operation to each of its tags
+        (operation.tags || []).forEach((tag) => {
+          if (!tagOperations.has(tag)) {
+            tagOperations.set(tag, []);
+          }
+          tagOperations.get(tag)!.push(opMeta);
+        });
+      }
+    });
+  });
+
+  return tagOperations;
+}
+
+/**
+ * Write OpenAPI specs grouped by tag to separate files
+ * Generates both YAML and JSON versions per tag
+ *
+ * @param openapi - OpenAPI document
+ * @param prefix - Filename prefix for output files
+ * @param outPath - Output directory path
+ */
+function writeTagOpenapis(
+  openapi: OpenAPIDocument,
+  prefix: string,
+  outPath: string
+): void {
+  const tagOperations = extractOperationsByTag(openapi);
+
+  // Process each tag
+  tagOperations.forEach((operations, tagName) => {
+    // Deep copy openapi
+    const doc: OpenAPIDocument = JSON.parse(JSON.stringify(openapi));
+
+    // Filter paths to only include those with operations for this tag
+    const filteredPaths: Record<string, PathItem> = {};
+    Object.entries(openapi.paths).forEach(([pathKey, pathItem]) => {
+      const filteredPathItem: PathItem = {};
+      let hasOperations = false;
+
+      HTTP_METHODS.forEach((method) => {
+        const operation = pathItem[method] as Operation | undefined;
+        if (operation?.tags?.includes(tagName)) {
+          // Clone the operation and restrict tags to only this tag
+          // This prevents RapiDoc from rendering the operation multiple times
+          // (once per tag) when an operation belongs to multiple tags
+          const filteredOperation = { ...operation, tags: [tagName] };
+          filteredPathItem[method] = filteredOperation;
+          hasOperations = true;
+        }
+      });
+
+      // Include path-level parameters if we have operations
+      if (hasOperations) {
+        if (pathItem.parameters) {
+          filteredPathItem.parameters = pathItem.parameters;
+        }
+        filteredPaths[pathKey] = filteredPathItem;
+      }
+    });
+
+    doc.paths = filteredPaths;
+
+    // Filter tags to only include this tag (and trait tags for context)
+    if (doc.tags) {
+      doc.tags = doc.tags.filter(
+        (tag) => tag.name === tagName || tag['x-traitTag']
+      );
+    }
+
+    // Update info
+    const tagSlug = slugifyTag(tagName);
+    doc.info.title = tagName;
+    doc.info.description = `API reference for ${tagName}`;
+    doc['x-tagGroup'] = tagName;
+
+    try {
+      if (!fs.existsSync(outPath)) {
+        fs.mkdirSync(outPath, { recursive: true });
+      }
+
+      const baseFilename = `${prefix}${tagSlug}`;
+      const yamlPath = path.resolve(outPath, `${baseFilename}.yaml`);
+      const jsonPath = path.resolve(outPath, `${baseFilename}.json`);
+
+      writeDataFile(doc, yamlPath);
+      writeJsonFile(doc, jsonPath);
+
+      console.log(
+        `Generated tag spec: ${baseFilename}.yaml (${Object.keys(filteredPaths).length} paths, ${operations.length} operations)`
+      );
+    } catch (err) {
+      console.error(`Error writing tag group ${tagName}:`, err);
+    }
+  });
+
+  // Also create specs for conceptual tags (x-traitTag) without operations
+  (openapi.tags || []).forEach((tag) => {
+    if (tag['x-traitTag'] && !tagOperations.has(tag.name)) {
+      const doc: OpenAPIDocument = JSON.parse(JSON.stringify(openapi));
+      doc.paths = {};
+      doc.tags = [tag];
+      doc.info.title = tag.name;
+      doc.info.description = tag.description || `API reference for ${tag.name}`;
+      doc['x-tagGroup'] = tag.name;
+
+      const tagSlug = slugifyTag(tag.name);
+
+      try {
+        const baseFilename = `${prefix}${tagSlug}`;
+        const yamlPath = path.resolve(outPath, `${baseFilename}.yaml`);
+        const jsonPath = path.resolve(outPath, `${baseFilename}.json`);
+
+        writeDataFile(doc, yamlPath);
+        writeJsonFile(doc, jsonPath);
+
+        console.log(`Generated conceptual tag spec: ${baseFilename}.yaml`);
+      } catch (err) {
+        console.error(`Error writing conceptual tag ${tag.name}:`, err);
+      }
+    }
+  });
+}
+
+/**
+ * Write OpenAPI specs grouped by path to separate files
+ * Generates both YAML and JSON versions
+ *
+ * @param openapi - OpenAPI document
+ * @param prefix - Filename prefix for output files
+ * @param outPath - Output directory path
+ */
+function writePathOpenapis(
+  openapi: OpenAPIDocument,
+  prefix: string,
+  outPath: string
+): void {
+  const pathGroups: Record<string, Record<string, PathItem>> = {};
+
+  // Group paths by their base path (first 3-4 segments, excluding placeholders)
+  Object.keys(openapi.paths)
+    .sort()
+    .forEach((p) => {
+      const delimiter = '/';
+      let key = p.split(delimiter);
+
+      // Check if this is an item path (ends with a placeholder)
+      let isItemPath = openapiUtils.isPlaceholderFragment(key[key.length - 1]);
+      if (isItemPath) {
+        key = key.slice(0, -1);
+      }
+
+      // Take first 4 segments
+      key = key.slice(0, 4);
+
+      // Check if the last segment is still a placeholder
+      isItemPath = openapiUtils.isPlaceholderFragment(key[key.length - 1]);
+      if (isItemPath) {
+        key = key.slice(0, -1);
+      }
+
+      const groupKey = key.join('/');
+      pathGroups[groupKey] = pathGroups[groupKey] || {};
+      pathGroups[groupKey][p] = openapi.paths[p];
+    });
+
+  // Write each path group to separate YAML and JSON files
+  Object.keys(pathGroups).forEach((pg) => {
+    // Deep copy openapi
+    const doc: OpenAPIDocument = JSON.parse(JSON.stringify(openapi));
+    doc.paths = pathGroups[pg];
+
+    // Collect tags used by operations in this path group
+    const usedTags = new Set<string>();
+    Object.values(doc.paths).forEach((pathItem: PathItem) => {
+      const httpMethods = [
+        'get',
+        'post',
+        'put',
+        'patch',
+        'delete',
+        'options',
+        'head',
+        'trace',
+      ];
+      httpMethods.forEach((method) => {
+        const operation = pathItem[method] as Operation | undefined;
+        if (operation?.tags) {
+          operation.tags.forEach((tag) => usedTags.add(tag));
+        }
+      });
+    });
+
+    // Filter tags to only include those used by operations in this path group
+    // Exclude x-traitTag tags (supplementary documentation tags)
+    if (doc.tags) {
+      doc.tags = doc.tags.filter(
+        (tag) => usedTags.has(tag.name) && !tag['x-traitTag']
+      );
+    }
+
+    // Simplify info for path-specific docs
+    doc.info.title = pg;
+    doc.info.description = `API reference for ${pg}`;
+    doc['x-pathGroup'] = pg;
+
+    try {
+      if (!fs.existsSync(outPath)) {
+        fs.mkdirSync(outPath, { recursive: true });
+      }
+
+      const baseFilename = `${prefix}${pg.replaceAll('/', '-').replace(/^-/, '')}`;
+      const yamlPath = path.resolve(outPath, `${baseFilename}.yaml`);
+      const jsonPath = path.resolve(outPath, `${baseFilename}.json`);
+
+      // Write both YAML and JSON versions
+      writeDataFile(doc, yamlPath);
+      writeJsonFile(doc, jsonPath);
+
+      console.log(`Generated: ${baseFilename}.yaml and ${baseFilename}.json`);
+    } catch (err) {
+      console.error(`Error writing path group ${pg}:`, err);
+    }
+  });
+}
+
+/**
+ * Create article metadata for a path group
+ *
+ * @param openapi - OpenAPI document with x-pathGroup
+ * @returns Article metadata object
+ */
+function createArticleDataForPathGroup(openapi: OpenAPIDocument): Article {
+  const article: Article = {
+    path: '',
+    fields: {
+      name: openapi['x-pathGroup'] || '',
+      describes: Object.keys(openapi.paths),
+    },
+  };
+
+  /**
+   * Convert OpenAPI path to Hugo-friendly article path
+   * Legacy endpoints (without /api/ prefix) go under api/ directly
+   * Versioned endpoints (with /api/vN/) keep their structure
+   *
+   * @param p - Path to convert (e.g., '/health', '/api/v3/query_sql')
+   * @returns Path suitable for Hugo content directory (e.g., 'api/health', 'api/v3/query_sql')
+   */
+  const toHugoPath = (p: string): string => {
+    if (!p) {
+      return '';
+    }
+    // If path doesn't start with /api/, it's a legacy endpoint
+    // Place it directly under api/ to avoid collision with /api/v1/* paths
+    if (!p.startsWith('/api/')) {
+      // /health -> api/health
+      // /write -> api/write
+      return `api${p}`;
+    }
+    // /api/v1/health -> api/v1/health
+    // /api/v2/write -> api/v2/write
+    // /api/v3/query_sql -> api/v3/query_sql
+    return p.replace(/^\//, '');
+  };
+
+  /**
+   * Convert path to tag-friendly format (dashes instead of slashes)
+   *
+   * @param p - Path to convert
+   * @returns Tag-friendly path
+   */
+  const toTagPath = (p: string): string => {
+    if (!p) {
+      return '';
+    }
+    return p.replace(/^\//, '').replaceAll('/', '-');
+  };
+
+  const pathGroup = openapi['x-pathGroup'] || '';
+  article.path = toHugoPath(pathGroup);
+  // Store original path for menu display (shows actual endpoint path)
+  article.fields.menuName = pathGroup;
+  article.fields.title = openapi.info?.title;
+  article.fields.description = openapi.description;
+
+  const pathGroupFrags = path.parse(openapi['x-pathGroup'] || '');
+  article.fields.tags = [pathGroupFrags?.dir, pathGroupFrags?.name]
+    .filter(Boolean)
+    .map((t) => toTagPath(t));
+
+  // Extract x-relatedLinks and OpenAPI tags from path items or operations
+  const relatedLinks: string[] = [];
+  const apiTags: string[] = [];
+  const httpMethods = [
+    'get',
+    'post',
+    'put',
+    'patch',
+    'delete',
+    'options',
+    'head',
+    'trace',
+  ];
+
+  Object.values(openapi.paths).forEach((pathItem: PathItem) => {
+    // Check path-level x-relatedLinks
+    if (
+      pathItem['x-relatedLinks'] &&
+      Array.isArray(pathItem['x-relatedLinks'])
+    ) {
+      relatedLinks.push(
+        ...(pathItem['x-relatedLinks'] as string[]).filter(
+          (link) => !relatedLinks.includes(link)
+        )
+      );
+    }
+
+    // Check operation-level x-relatedLinks and tags
+    httpMethods.forEach((method) => {
+      const operation = pathItem[method] as Operation | undefined;
+      if (operation) {
+        // Extract x-relatedLinks
+        if (
+          operation['x-relatedLinks'] &&
+          Array.isArray(operation['x-relatedLinks'])
+        ) {
+          relatedLinks.push(
+            ...(operation['x-relatedLinks'] as string[]).filter(
+              (link) => !relatedLinks.includes(link)
+            )
+          );
+        }
+        // Extract OpenAPI tags from operation
+        if (operation.tags && Array.isArray(operation.tags)) {
+          operation.tags.forEach((tag) => {
+            if (!apiTags.includes(tag)) {
+              apiTags.push(tag);
+            }
+          });
+        }
+      }
+    });
+  });
+
+  // Only add related if there are links
+  if (relatedLinks.length > 0) {
+    article.fields.related = relatedLinks;
+  }
+
+  // Add OpenAPI tags from operations (for Hugo frontmatter)
+  if (apiTags.length > 0) {
+    article.fields.apiTags = apiTags;
+  }
+
+  return article;
+}
+
+/**
+ * Write OpenAPI article metadata to Hugo data files
+ * Generates articles.yml and articles.json
+ *
+ * @param sourcePath - Path to directory containing OpenAPI fragment files
+ * @param targetPath - Output path for article data
+ * @param opts - Options including file pattern filter
+ */
+function writeOpenapiArticleData(
+  sourcePath: string,
+  targetPath: string,
+  opts: WriteOpenapiArticleDataOptions
+): void {
+  /**
+   * Check if path is a file
+   */
+  const isFile = (filePath: string): boolean => {
+    return fs.lstatSync(filePath).isFile();
+  };
+
+  /**
+   * Check if filename matches pattern
+   */
+  const matchesPattern = (filePath: string): boolean => {
+    return opts.filePattern
+      ? path.parse(filePath).name.startsWith(opts.filePattern)
+      : true;
+  };
+
+  try {
+    const articles = fs
+      .readdirSync(sourcePath)
+      .map((fileName) => path.join(sourcePath, fileName))
+      .filter(matchesPattern)
+      .filter(isFile)
+      .filter(
+        (filePath) => filePath.endsWith('.yaml') || filePath.endsWith('.yml')
+      ) // Only process YAML files
+      .map((filePath) => {
+        const openapi = readFile(filePath);
+        const article = createArticleDataForPathGroup(openapi);
+        article.fields.source = filePath;
+        // Hugo omits "/static" from the URI when serving files stored in "./static"
+        article.fields.staticFilePath = filePath.replace(/^static\//, '/');
+        return article;
+      });
+
+    if (!fs.existsSync(targetPath)) {
+      fs.mkdirSync(targetPath, { recursive: true });
+    }
+
+    const articleCollection: ArticleCollection = { articles };
+
+    // Write both YAML and JSON versions
+    const yamlPath = path.resolve(targetPath, 'articles.yml');
+    const jsonPath = path.resolve(targetPath, 'articles.json');
+
+    writeDataFile(articleCollection, yamlPath);
+    writeJsonFile(articleCollection, jsonPath);
+
+    console.log(`Generated ${articles.length} articles in ${targetPath}`);
+  } catch (e) {
+    console.error('Error writing article data:', e);
+  }
+}
+
+/**
+ * Create article data for a tag-based grouping
+ *
+ * @param openapi - OpenAPI document with x-tagGroup
+ * @param operations - Operations for this tag
+ * @param tagMeta - Tag metadata from OpenAPI spec
+ * @returns Article metadata object
+ */
+function createArticleDataForTag(
+  openapi: OpenAPIDocument,
+  operations: OperationMeta[],
+  tagMeta?: Tag
+): Article {
+  const tagName = (openapi['x-tagGroup'] as string) || '';
+  const tagSlug = slugifyTag(tagName);
+  const isConceptual = tagMeta?.['x-traitTag'] === true;
+
+  const article: Article = {
+    path: `api/${tagSlug}`,
+    fields: {
+      name: tagName,
+      describes: Object.keys(openapi.paths),
+      title: tagName,
+      description:
+        tagMeta?.description ||
+        openapi.info?.description ||
+        `API reference for ${tagName}`,
+      tag: tagName,
+      isConceptual,
+      menuGroup: getMenuGroupForTag(tagName),
+      operations: operations.map((op) => ({
+        operationId: op.operationId,
+        method: op.method,
+        path: op.path,
+        summary: op.summary,
+        tags: op.tags,
+        ...(op.compatVersion && { compatVersion: op.compatVersion }),
+        ...(op.externalDocs && { externalDocs: op.externalDocs }),
+      })),
+    },
+  };
+
+  // Add tag description for conceptual pages
+  if (tagMeta?.description) {
+    article.fields.tagDescription = tagMeta.description;
+  }
+
+  // Aggregate unique externalDocs URLs from operations into article-level related
+  // This populates Hugo frontmatter `related` field for "Related content" links
+  const relatedUrls = new Set<string>();
+
+  // First check tag-level externalDocs
+  if (tagMeta?.externalDocs?.url) {
+    relatedUrls.add(tagMeta.externalDocs.url);
+  }
+
+  // Then aggregate from operations
+  operations.forEach((op) => {
+    if (op.externalDocs?.url) {
+      relatedUrls.add(op.externalDocs.url);
+    }
+  });
+
+  if (relatedUrls.size > 0) {
+    article.fields.related = Array.from(relatedUrls);
+  }
+
+  return article;
+}
+
+/**
+ * Write tag-based OpenAPI article metadata to Hugo data files
+ * Generates articles.yml and articles.json
+ *
+ * @param sourcePath - Path to directory containing tag-based OpenAPI fragment files
+ * @param targetPath - Output path for article data
+ * @param openapi - Original OpenAPI document (for tag metadata)
+ * @param opts - Options including file pattern filter
+ */
+function writeOpenapiTagArticleData(
+  sourcePath: string,
+  targetPath: string,
+  openapi: OpenAPIDocument,
+  opts: WriteOpenapiArticleDataOptions
+): void {
+  const isFile = (filePath: string): boolean => {
+    return fs.lstatSync(filePath).isFile();
+  };
+
+  const matchesPattern = (filePath: string): boolean => {
+    return opts.filePattern
+      ? path.parse(filePath).name.startsWith(opts.filePattern)
+      : true;
+  };
+
+  // Create tag metadata lookup
+  const tagMetaMap = new Map<string, Tag>();
+  (openapi.tags || []).forEach((tag) => {
+    tagMetaMap.set(tag.name, tag);
+  });
+
+  try {
+    const articles = fs
+      .readdirSync(sourcePath)
+      .map((fileName) => path.join(sourcePath, fileName))
+      .filter(matchesPattern)
+      .filter(isFile)
+      .filter(
+        (filePath) => filePath.endsWith('.yaml') || filePath.endsWith('.yml')
+      )
+      .map((filePath) => {
+        const tagOpenapi = readFile(filePath);
+        const tagName =
+          (tagOpenapi['x-tagGroup'] as string) || tagOpenapi.info?.title || '';
+        const tagMeta = tagMetaMap.get(tagName);
+
+        // Extract operations from the tag-filtered spec
+        const operations: OperationMeta[] = [];
+        Object.entries(tagOpenapi.paths).forEach(([pathKey, pathItem]) => {
+          HTTP_METHODS.forEach((method) => {
+            const operation = pathItem[method] as Operation | undefined;
+            if (operation) {
+              const opMeta: OperationMeta = {
+                operationId: operation.operationId || `${method}-${pathKey}`,
+                method: method.toUpperCase(),
+                path: pathKey,
+                summary: operation.summary || '',
+                tags: operation.tags || [],
+              };
+
+              // Extract compatibility version if present
+              if (operation['x-compatibility-version']) {
+                opMeta.compatVersion = operation['x-compatibility-version'];
+              }
+
+              // Extract externalDocs if present
+              if (operation.externalDocs) {
+                opMeta.externalDocs = {
+                  description: operation.externalDocs.description || '',
+                  url: operation.externalDocs.url,
+                };
+              }
+
+              operations.push(opMeta);
+            }
+          });
+        });
+
+        const article = createArticleDataForTag(
+          tagOpenapi,
+          operations,
+          tagMeta
+        );
+        article.fields.source = filePath;
+        article.fields.staticFilePath = filePath.replace(/^static\//, '/');
+        return article;
+      });
+
+    if (!fs.existsSync(targetPath)) {
+      fs.mkdirSync(targetPath, { recursive: true });
+    }
+
+    const articleCollection: ArticleCollection = { articles };
+
+    // Write both YAML and JSON versions
+    const yamlPath = path.resolve(targetPath, 'articles.yml');
+    const jsonPath = path.resolve(targetPath, 'articles.json');
+
+    writeDataFile(articleCollection, yamlPath);
+    writeJsonFile(articleCollection, jsonPath);
+
+    console.log(
+      `Generated ${articles.length} tag-based articles in ${targetPath}`
+    );
+  } catch (e) {
+    console.error('Error writing tag article data:', e);
+  }
+}
+
+/**
+ * Options for generating Hugo data by tag
+ */
+export interface GenerateHugoDataByTagOptions extends GenerateHugoDataOptions {
+  /** Whether to also generate path-based files (for backwards compatibility) */
+  includePaths?: boolean;
+}
+
+/**
+ * Generate Hugo data files from an OpenAPI specification grouped by tag
+ *
+ * This function:
+ * 1. Reads the OpenAPI spec file
+ * 2. Groups operations by their OpenAPI tags
+ * 3. Writes each tag group to separate YAML and JSON files
+ * 4. Generates tag-based article metadata for Hugo
+ *
+ * @param options - Generation options
+ */
+export function generateHugoDataByTag(
+  options: GenerateHugoDataByTagOptions
+): void {
+  const filenamePrefix = `${path.parse(options.specFile).name}-`;
+  const sourceFile = readFile(options.specFile, 'utf8');
+
+  // Optionally generate path-based files for backwards compatibility
+  if (options.includePaths) {
+    console.log(
+      `\nGenerating OpenAPI path files in ${options.dataOutPath}....`
+    );
+    writePathOpenapis(sourceFile, filenamePrefix, options.dataOutPath);
+  }
+
+  // Generate tag-based files
+  const tagOutPath = options.includePaths
+    ? path.join(options.dataOutPath, 'tags')
+    : options.dataOutPath;
+
+  console.log(`\nGenerating OpenAPI tag files in ${tagOutPath}....`);
+  writeTagOpenapis(sourceFile, filenamePrefix, tagOutPath);
+
+  console.log(
+    `\nGenerating OpenAPI tag article data in ${options.articleOutPath}...`
+  );
+  writeOpenapiTagArticleData(tagOutPath, options.articleOutPath, sourceFile, {
+    filePattern: filenamePrefix,
+  });
+
+  console.log('\nTag-based generation complete!\n');
+}
+
+/**
+ * Generate Hugo data files from an OpenAPI specification
+ *
+ * This function:
+ * 1. Reads the OpenAPI spec file
+ * 2. Groups paths by their base path
+ * 3. Writes each group to separate YAML and JSON files
+ * 4. Generates article metadata for Hugo
+ *
+ * @param options - Generation options
+ */
+export function generateHugoData(options: GenerateHugoDataOptions): void {
+  const filenamePrefix = `${path.parse(options.specFile).name}-`;
+
+  const sourceFile = readFile(options.specFile, 'utf8');
+
+  console.log(`\nGenerating OpenAPI path files in ${options.dataOutPath}....`);
+  writePathOpenapis(sourceFile, filenamePrefix, options.dataOutPath);
+
+  console.log(
+    `\nGenerating OpenAPI article data in ${options.articleOutPath}...`
+  );
+  writeOpenapiArticleData(options.dataOutPath, options.articleOutPath, {
+    filePattern: filenamePrefix,
+  });
+
+  console.log('\nGeneration complete!\n');
+}
+
+// CommonJS export for backward compatibility
+module.exports = {
+  generateHugoData,
+  generateHugoDataByTag,
+};
diff --git a/api-docs/scripts/openapi-paths-to-hugo-data/package.json b/api-docs/scripts/openapi-paths-to-hugo-data/package.json
new file mode 100644
index 0000000000..78bd5bc114
--- /dev/null
+++ b/api-docs/scripts/openapi-paths-to-hugo-data/package.json
@@ -0,0 +1,14 @@
+{
+  "name": "openapi-paths-to-hugo-data",
+  "version": "1.0.0",
+  "description": "Convert OpenAPI specifications to Hugo data files for API documentation",
+  "main": "index.js",
+  "type": "commonjs",
+  "dependencies": {
+    "js-yaml": "^4.1.1"
+  },
+  "devDependencies": {},
+  "scripts": {},
+  "author": "InfluxData",
+  "license": "MIT"
+}
diff --git a/api-docs/scripts/openapi-paths-to-hugo-data/yarn.lock b/api-docs/scripts/openapi-paths-to-hugo-data/yarn.lock
new file mode 100644
index 0000000000..96bb86828b
--- /dev/null
+++ b/api-docs/scripts/openapi-paths-to-hugo-data/yarn.lock
@@ -0,0 +1,32 @@
+# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+# yarn lockfile v1
+
+
+"@types/js-yaml@^4.0.9":
+  version "4.0.9"
+  resolved "https://registry.yarnpkg.com/@types/js-yaml/-/js-yaml-4.0.9.tgz#cd82382c4f902fed9691a2ed79ec68c5898af4c2"
+  integrity sha512-k4MGaQl5TGo/iipqb2UDG2UwjXziSWkh0uysQelTlJpX1qGlpUZYm8PnO4DxG1qBomtJUdYJ6qR6xdIah10JLg==
+
+"@types/node@^24.10.1":
+  version "24.10.1"
+  resolved "https://registry.yarnpkg.com/@types/node/-/node-24.10.1.tgz#91e92182c93db8bd6224fca031e2370cef9a8f01"
+  integrity sha512-GNWcUTRBgIRJD5zj+Tq0fKOJ5XZajIiBroOF0yvj2bSU1WvNdYS/dn9UxwsujGW4JX06dnHyjV2y9rRaybH0iQ==
+  dependencies:
+    undici-types "~7.16.0"
+
+argparse@^2.0.1:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/argparse/-/argparse-2.0.1.tgz#246f50f3ca78a3240f6c997e8a9bd1eac49e4b38"
+  integrity sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==
+
+js-yaml@^4.1.0:
+  version "4.1.1"
+  resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-4.1.1.tgz#854c292467705b699476e1a2decc0c8a3458806b"
+  integrity sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==
+  dependencies:
+    argparse "^2.0.1"
+
+undici-types@~7.16.0:
+  version "7.16.0"
+  resolved "https://registry.yarnpkg.com/undici-types/-/undici-types-7.16.0.tgz#ffccdff36aea4884cbfce9a750a0580224f58a46"
+  integrity sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw==
diff --git a/api-docs/scripts/tsconfig.json b/api-docs/scripts/tsconfig.json
new file mode 100644
index 0000000000..e36776534b
--- /dev/null
+++ b/api-docs/scripts/tsconfig.json
@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "ES2021",
+    "lib": ["ES2021"],
+    "module": "CommonJS",
+    "moduleResolution": "node",
+    "outDir": "./dist",
+    "rootDir": ".",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "sourceMap": true,
+    "types": ["node"]
+  },
+  "include": [
+    "**/*.ts"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}
diff --git a/assets/js/components/api-rapidoc.ts b/assets/js/components/api-rapidoc.ts
new file mode 100644
index 0000000000..8807c46c42
--- /dev/null
+++ b/assets/js/components/api-rapidoc.ts
@@ -0,0 +1,259 @@
+/**
+ * RapiDoc API Documentation Component
+ *
+ * Initializes the full RapiDoc renderer with theme synchronization.
+ * This is the component version of the inline JavaScript from rapidoc.html.
+ *
+ * Features:
+ * - Theme detection from Hugo's stylesheet toggle system
+ * - Automatic theme synchronization when user toggles dark/light mode
+ * - Shadow DOM manipulation to hide unwanted UI elements
+ * - CSS custom property injection for styling
+ *
+ * Usage:
+ * <div data-component="api-rapidoc" data-spec-url="/path/to/spec.yml"></div>
+ *
+ * The component expects a <rapi-doc> element to already exist in the container
+ * (created by Hugo template) or will wait for it to be added.
+ */
+
+import { getPreference } from '../services/local-storage.js';
+
+interface ComponentOptions {
+  component: HTMLElement;
+}
+
+interface ThemeColors {
+  theme: 'light' | 'dark';
+  bgColor: string;
+  textColor: string;
+  headerColor: string;
+  primaryColor: string;
+  navBgColor: string;
+  navTextColor: string;
+  navHoverBgColor: string;
+  navHoverTextColor: string;
+  navAccentColor: string;
+  codeTheme: string;
+}
+
+type CleanupFn = () => void;
+
+/**
+ * Get current theme from localStorage (source of truth for Hugo theme system)
+ */
+function getTheme(): 'dark' | 'light' {
+  const theme = getPreference('theme');
+  return theme === 'dark' ? 'dark' : 'light';
+}
+
+/**
+ * Get theme colors matching Hugo SCSS variables
+ */
+function getThemeColors(isDark: boolean): ThemeColors {
+  if (isDark) {
+    return {
+      theme: 'dark',
+      bgColor: '#14141F', // $grey10 ($article-bg in dark theme)
+      textColor: '#D4D7DD', // $g15-platinum
+      headerColor: '#D4D7DD',
+      primaryColor: '#a0a0ff',
+      navBgColor: '#1a1a2a',
+      navTextColor: '#D4D7DD',
+      navHoverBgColor: '#252535',
+      navHoverTextColor: '#ffffff',
+      navAccentColor: '#a0a0ff',
+      codeTheme: 'monokai',
+    };
+  }
+
+  return {
+    theme: 'light',
+    bgColor: '#ffffff', // $g20-white
+    textColor: '#2b2b2b',
+    headerColor: '#020a47', // $br-dark-blue
+    primaryColor: '#020a47',
+    navBgColor: '#f7f8fa',
+    navTextColor: '#2b2b2b',
+    navHoverBgColor: '#e8e8f0',
+    navHoverTextColor: '#020a47',
+    navAccentColor: '#020a47',
+    codeTheme: 'prism',
+  };
+}
+
+/**
+ * Apply theme to RapiDoc element
+ */
+function applyTheme(rapiDoc: HTMLElement): void {
+  const isDark = getTheme() === 'dark';
+  const colors = getThemeColors(isDark);
+
+  rapiDoc.setAttribute('theme', colors.theme);
+  rapiDoc.setAttribute('bg-color', colors.bgColor);
+  rapiDoc.setAttribute('text-color', colors.textColor);
+  rapiDoc.setAttribute('header-color', colors.headerColor);
+  rapiDoc.setAttribute('primary-color', colors.primaryColor);
+  rapiDoc.setAttribute('nav-bg-color', colors.navBgColor);
+  rapiDoc.setAttribute('nav-text-color', colors.navTextColor);
+  rapiDoc.setAttribute('nav-hover-bg-color', colors.navHoverBgColor);
+  rapiDoc.setAttribute('nav-hover-text-color', colors.navHoverTextColor);
+  rapiDoc.setAttribute('nav-accent-color', colors.navAccentColor);
+  rapiDoc.setAttribute('code-theme', colors.codeTheme);
+}
+
+/**
+ * Set custom CSS properties on RapiDoc element
+ */
+function setInputBorderStyles(rapiDoc: HTMLElement): void {
+  rapiDoc.style.setProperty('--border-color', '#00A3FF');
+}
+
+/**
+ * Hide unwanted elements in RapiDoc shadow DOM
+ */
+function hideExpandCollapseControls(rapiDoc: HTMLElement): void {
+  const maxAttempts = 10;
+  let attempts = 0;
+
+  const tryHide = (): void => {
+    attempts++;
+
+    try {
+      const shadowRoot = rapiDoc.shadowRoot;
+      if (!shadowRoot) {
+        if (attempts < maxAttempts) {
+          setTimeout(tryHide, 500);
+        }
+        return;
+      }
+
+      // Find elements containing "Expand all" / "Collapse all" and hide them
+      const allElements = shadowRoot.querySelectorAll('*');
+      let hiddenCount = 0;
+
+      allElements.forEach((element) => {
+        const text = element.textContent || '';
+
+        if (text.includes('Expand all') || text.includes('Collapse all')) {
+          (element as HTMLElement).style.display = 'none';
+          if (element.parentElement) {
+            element.parentElement.style.display = 'none';
+          }
+          hiddenCount++;
+        }
+      });
+
+      // Hide "Overview" headings
+      const headings = shadowRoot.querySelectorAll('h1, h2, h3, h4');
+      headings.forEach((heading) => {
+        const text = (heading.textContent || '').trim();
+        if (text.includes('Overview')) {
+          (heading as HTMLElement).style.display = 'none';
+          hiddenCount++;
+        }
+      });
+
+      // Inject CSS as backup
+      const style = document.createElement('style');
+      style.textContent = `
+        .section-gap.section-tag,
+        [id*="overview"],
+        .regular-font.section-gap:empty,
+        h1:empty, h2:empty, h3:empty {
+          display: none !important;
+        }
+      `;
+      shadowRoot.appendChild(style);
+
+      if (hiddenCount === 0 && attempts < maxAttempts) {
+        setTimeout(tryHide, 500);
+      }
+    } catch {
+      if (attempts < maxAttempts) {
+        setTimeout(tryHide, 500);
+      }
+    }
+  };
+
+  setTimeout(tryHide, 500);
+}
+
+/**
+ * Watch for theme changes via stylesheet toggle
+ */
+function watchThemeChanges(rapiDoc: HTMLElement): CleanupFn {
+  const handleThemeChange = (): void => {
+    applyTheme(rapiDoc);
+  };
+
+  // Watch stylesheet disabled attribute changes (Hugo theme.js toggles this)
+  const observer = new MutationObserver((mutations) => {
+    for (const mutation of mutations) {
+      if (
+        mutation.type === 'attributes' &&
+        mutation.target instanceof HTMLLinkElement &&
+        mutation.target.title?.includes('theme')
+      ) {
+        handleThemeChange();
+        break;
+      }
+      // Also watch data-theme changes as fallback
+      if (mutation.attributeName === 'data-theme') {
+        handleThemeChange();
+      }
+    }
+  });
+
+  // Observe head for stylesheet changes
+  observer.observe(document.head, {
+    attributes: true,
+    attributeFilter: ['disabled'],
+    subtree: true,
+  });
+
+  // Observe documentElement for data-theme changes
+  observer.observe(document.documentElement, {
+    attributes: true,
+    attributeFilter: ['data-theme'],
+  });
+
+  return (): void => {
+    observer.disconnect();
+  };
+}
+
+/**
+ * Initialize RapiDoc component
+ */
+export default function ApiRapiDoc({
+  component,
+}: ComponentOptions): CleanupFn | void {
+  // Find the rapi-doc element inside the container
+  const rapiDoc = component.querySelector('rapi-doc') as HTMLElement | null;
+
+  if (!rapiDoc) {
+    console.warn('[API RapiDoc] No rapi-doc element found in container');
+    return;
+  }
+
+  // Apply initial theme
+  applyTheme(rapiDoc);
+
+  // Set custom CSS properties
+  if (customElements && customElements.whenDefined) {
+    customElements.whenDefined('rapi-doc').then(() => {
+      setInputBorderStyles(rapiDoc);
+      setTimeout(() => setInputBorderStyles(rapiDoc), 500);
+    });
+  } else {
+    setInputBorderStyles(rapiDoc);
+    setTimeout(() => setInputBorderStyles(rapiDoc), 500);
+  }
+
+  // Hide unwanted UI elements
+  hideExpandCollapseControls(rapiDoc);
+
+  // Watch for theme changes
+  return watchThemeChanges(rapiDoc);
+}
diff --git a/assets/js/components/api-toc.ts b/assets/js/components/api-toc.ts
new file mode 100644
index 0000000000..06b0d2f589
--- /dev/null
+++ b/assets/js/components/api-toc.ts
@@ -0,0 +1,434 @@
+/**
+ * API Table of Contents Component
+ *
+ * Generates "ON THIS PAGE" navigation from content headings or operations data.
+ * Features:
+ * - Builds TOC from h2/h3 headings in the active tab panel (legacy)
+ * - Builds TOC from operations data passed via data-operations attribute (tag-based)
+ * - Highlights current section on scroll (intersection observer)
+ * - Smooth scroll to anchors
+ * - Updates when tab changes
+ *
+ * Usage:
+ * <aside class="api-toc" data-component="api-toc" data-operations='[...]'>
+ *   <h4 class="api-toc-header">ON THIS PAGE</h4>
+ *   <nav class="api-toc-nav"></nav>
+ * </aside>
+ */
+
+interface ComponentOptions {
+  component: HTMLElement;
+}
+
+interface TocEntry {
+  id: string;
+  text: string;
+  level: number;
+}
+
+/**
+ * Operation metadata from frontmatter (for tag-based pages)
+ */
+interface OperationMeta {
+  operationId: string;
+  method: string;
+  path: string;
+  summary: string;
+  tags: string[];
+}
+
+/**
+ * Check if the active panel contains a RapiDoc component
+ */
+function isRapiDocActive(): boolean {
+  const activePanel = document.querySelector(
+    '.tab-content:not([style*="display: none"]), [data-tab-panel]:not([style*="display: none"])'
+  );
+  return activePanel?.querySelector('rapi-doc') !== null;
+}
+
+/**
+ * Get headings from the currently visible content
+ */
+function getVisibleHeadings(): TocEntry[] {
+  // Find the active tab panel or main content area
+  const activePanel = document.querySelector(
+    '.tab-content:not([style*="display: none"]), [data-tab-panel]:not([style*="display: none"]), .article--content'
+  );
+
+  if (!activePanel) {
+    return [];
+  }
+
+  const headings = activePanel.querySelectorAll('h2, h3');
+  const entries: TocEntry[] = [];
+
+  headings.forEach((heading) => {
+    // Skip headings without IDs
+    if (!heading.id) {
+      return;
+    }
+
+    // Skip hidden headings
+    const rect = heading.getBoundingClientRect();
+    if (rect.width === 0 && rect.height === 0) {
+      return;
+    }
+
+    entries.push({
+      id: heading.id,
+      text: heading.textContent?.trim() || '',
+      level: heading.tagName === 'H2' ? 2 : 3,
+    });
+  });
+
+  return entries;
+}
+
+/**
+ * Build TOC HTML from entries
+ */
+function buildTocHtml(entries: TocEntry[]): string {
+  if (entries.length === 0) {
+    // Check if RapiDoc is active - show helpful message
+    if (isRapiDocActive()) {
+      return '<p class="api-toc-empty">Use RapiDoc\'s navigation below to explore this endpoint.</p>';
+    }
+    return '<p class="api-toc-empty">No sections on this page.</p>';
+  }
+
+  let html = '<ul class="api-toc-list">';
+
+  entries.forEach((entry) => {
+    const indent = entry.level === 3 ? ' api-toc-item--nested' : '';
+    html += `
+      <li class="api-toc-item${indent}">
+        <a href="#${entry.id}" class="api-toc-link">${entry.text}</a>
+      </li>
+    `;
+  });
+
+  html += '</ul>';
+  return html;
+}
+
+/**
+ * Get method badge class for HTTP method
+ */
+function getMethodClass(method: string): string {
+  const m = method.toLowerCase();
+  switch (m) {
+    case 'get':
+      return 'api-method--get';
+    case 'post':
+      return 'api-method--post';
+    case 'put':
+      return 'api-method--put';
+    case 'patch':
+      return 'api-method--patch';
+    case 'delete':
+      return 'api-method--delete';
+    default:
+      return '';
+  }
+}
+
+/**
+ * Build TOC HTML from operations data (for tag-based pages)
+ */
+function buildOperationsTocHtml(operations: OperationMeta[]): string {
+  if (operations.length === 0) {
+    return '<p class="api-toc-empty">No operations on this page.</p>';
+  }
+
+  let html = '<ul class="api-toc-list api-toc-list--operations">';
+
+  operations.forEach((op) => {
+    // Generate anchor ID from operationId (Scalar uses operationId for anchors)
+    const anchorId = op.operationId;
+    const methodClass = getMethodClass(op.method);
+
+    html += `
+      <li class="api-toc-item api-toc-item--operation">
+        <a href="#${anchorId}" class="api-toc-link api-toc-link--operation">
+          <span class="api-method ${methodClass}">${op.method.toUpperCase()}</span>
+          <span class="api-path">${op.path}</span>
+        </a>
+      </li>
+    `;
+  });
+
+  html += '</ul>';
+  return html;
+}
+
+/**
+ * Parse operations from data attribute
+ */
+function parseOperationsData(component: HTMLElement): OperationMeta[] | null {
+  const dataAttr = component.getAttribute('data-operations');
+  if (!dataAttr) {
+    return null;
+  }
+
+  try {
+    const operations = JSON.parse(dataAttr) as OperationMeta[];
+    return Array.isArray(operations) ? operations : null;
+  } catch (e) {
+    console.warn('[API TOC] Failed to parse operations data:', e);
+    return null;
+  }
+}
+
+/**
+ * Set up intersection observer for scroll highlighting
+ */
+function setupScrollHighlighting(
+  container: HTMLElement,
+  entries: TocEntry[]
+): IntersectionObserver | null {
+  if (entries.length === 0) {
+    return null;
+  }
+
+  const headingIds = entries.map((e) => e.id);
+  const links = container.querySelectorAll<HTMLAnchorElement>('.api-toc-link');
+
+  // Create a map of heading ID to link element
+  const linkMap = new Map<string, HTMLAnchorElement>();
+  links.forEach((link) => {
+    const href = link.getAttribute('href');
+    if (href?.startsWith('#')) {
+      linkMap.set(href.slice(1), link);
+    }
+  });
+
+  // Track which headings are visible
+  const visibleHeadings = new Set<string>();
+
+  const observer = new IntersectionObserver(
+    (observerEntries) => {
+      observerEntries.forEach((entry) => {
+        const id = entry.target.id;
+
+        if (entry.isIntersecting) {
+          visibleHeadings.add(id);
+        } else {
+          visibleHeadings.delete(id);
+        }
+      });
+
+      // Find the first visible heading (in document order)
+      let activeId: string | null = null;
+      for (const id of headingIds) {
+        if (visibleHeadings.has(id)) {
+          activeId = id;
+          break;
+        }
+      }
+
+      // If no heading is visible, use the last one that was scrolled past
+      if (!activeId && visibleHeadings.size === 0) {
+        const scrollY = window.scrollY;
+        for (let i = headingIds.length - 1; i >= 0; i--) {
+          const heading = document.getElementById(headingIds[i]);
+          if (heading && heading.offsetTop < scrollY + 100) {
+            activeId = headingIds[i];
+            break;
+          }
+        }
+      }
+
+      // Update active state on links
+      links.forEach((link) => {
+        link.classList.remove('is-active');
+      });
+
+      if (activeId) {
+        const activeLink = linkMap.get(activeId);
+        activeLink?.classList.add('is-active');
+      }
+    },
+    {
+      rootMargin: '-80px 0px -70% 0px',
+      threshold: 0,
+    }
+  );
+
+  // Observe all headings
+  headingIds.forEach((id) => {
+    const heading = document.getElementById(id);
+    if (heading) {
+      observer.observe(heading);
+    }
+  });
+
+  return observer;
+}
+
+/**
+ * Set up smooth scroll for TOC links
+ */
+function setupSmoothScroll(container: HTMLElement): void {
+  container.addEventListener('click', (event) => {
+    const target = event.target as HTMLElement;
+    const link = target.closest<HTMLAnchorElement>('.api-toc-link');
+
+    if (!link) {
+      return;
+    }
+
+    const href = link.getAttribute('href');
+    if (!href?.startsWith('#')) {
+      return;
+    }
+
+    const targetElement = document.getElementById(href.slice(1));
+    if (!targetElement) {
+      return;
+    }
+
+    event.preventDefault();
+
+    // Scroll with offset for fixed header
+    const headerOffset = 80;
+    const elementPosition = targetElement.getBoundingClientRect().top;
+    const offsetPosition = elementPosition + window.scrollY - headerOffset;
+
+    window.scrollTo({
+      top: offsetPosition,
+      behavior: 'smooth',
+    });
+
+    // Update URL hash without jumping
+    history.pushState(null, '', href);
+  });
+}
+
+/**
+ * Update TOC visibility based on active tab
+ * Hide TOC for Operations tab (RapiDoc has built-in navigation)
+ */
+function updateTocVisibility(container: HTMLElement): void {
+  const operationsPanel = document.querySelector(
+    '[data-tab-panel="operations"]'
+  );
+  const isOperationsVisible =
+    operationsPanel &&
+    !operationsPanel.getAttribute('style')?.includes('display: none');
+
+  if (isOperationsVisible) {
+    container.classList.add('is-hidden');
+  } else {
+    container.classList.remove('is-hidden');
+  }
+}
+
+/**
+ * Watch for tab changes to rebuild TOC
+ */
+function watchTabChanges(
+  container: HTMLElement,
+  rebuild: () => void
+): MutationObserver {
+  const tabPanels = document.querySelector('.api-tab-panels');
+
+  if (!tabPanels) {
+    return new MutationObserver(() => {});
+  }
+
+  const observer = new MutationObserver((mutations) => {
+    // Check if any tab panel visibility changed
+    const hasVisibilityChange = mutations.some((mutation) => {
+      return (
+        mutation.type === 'attributes' &&
+        (mutation.attributeName === 'style' ||
+          mutation.attributeName === 'class')
+      );
+    });
+
+    if (hasVisibilityChange) {
+      // Update visibility based on active tab
+      updateTocVisibility(container);
+      // Debounce rebuild
+      setTimeout(rebuild, 100);
+    }
+  });
+
+  observer.observe(tabPanels, {
+    attributes: true,
+    subtree: true,
+    attributeFilter: ['style', 'class'],
+  });
+
+  return observer;
+}
+
+/**
+ * Initialize API TOC component
+ */
+export default function ApiToc({ component }: ComponentOptions): void {
+  const nav = component.querySelector<HTMLElement>('.api-toc-nav');
+
+  if (!nav) {
+    console.warn('[API TOC] No .api-toc-nav element found');
+    return;
+  }
+
+  // Check for operations data (tag-based pages)
+  const operations = parseOperationsData(component);
+  let observer: IntersectionObserver | null = null;
+
+  /**
+   * Rebuild the TOC
+   */
+  function rebuild(): void {
+    // Clean up previous observer
+    if (observer) {
+      observer.disconnect();
+      observer = null;
+    }
+
+    // If operations data is present, build operations-based TOC
+    if (operations && operations.length > 0) {
+      if (nav) {
+        nav.innerHTML = buildOperationsTocHtml(operations);
+      }
+      // Don't hide TOC for tag-based pages - always show operations
+      component.classList.remove('is-hidden');
+      return;
+    }
+
+    // Otherwise, fall back to heading-based TOC
+    const entries = getVisibleHeadings();
+    if (nav) {
+      nav.innerHTML = buildTocHtml(entries);
+    }
+
+    // Set up scroll highlighting
+    observer = setupScrollHighlighting(component, entries);
+  }
+
+  // Check initial visibility (hide for Operations tab, only for non-operations pages)
+  if (!operations || operations.length === 0) {
+    updateTocVisibility(component);
+  }
+
+  // Initial build
+  rebuild();
+
+  // Set up smooth scroll
+  setupSmoothScroll(component);
+
+  // Watch for tab changes (only for non-operations pages)
+  if (!operations || operations.length === 0) {
+    watchTabChanges(component, rebuild);
+  }
+
+  // Also rebuild on window resize (headings may change visibility)
+  let resizeTimeout: number;
+  window.addEventListener('resize', () => {
+    clearTimeout(resizeTimeout);
+    resizeTimeout = window.setTimeout(rebuild, 250);
+  });
+}
diff --git a/assets/js/components/rapidoc-mini.ts b/assets/js/components/rapidoc-mini.ts
new file mode 100644
index 0000000000..4a49eea9f3
--- /dev/null
+++ b/assets/js/components/rapidoc-mini.ts
@@ -0,0 +1,335 @@
+/**
+ * RapiDoc Mini Component
+ *
+ * Initializes RapiDoc Mini web component for single API operation rendering.
+ * Features:
+ * - Dynamic CDN loading (memoized across instances)
+ * - Theme synchronization with Hugo theme system
+ * - Multiple instance support (no hardcoded IDs)
+ * - Cleanup function for proper teardown
+ *
+ * Usage:
+ * <div data-component="rapidoc-mini"
+ *      data-spec-url="/path/to/spec.yml"
+ *      data-match-paths="post /write">
+ * </div>
+ */
+
+import { getPreference } from '../services/local-storage.js';
+
+interface ComponentOptions {
+  component: HTMLElement;
+}
+
+interface ThemeConfig {
+  theme: 'light' | 'dark';
+  bgColor: string;
+  textColor: string;
+  primaryColor: string;
+  navBgColor: string;
+  navTextColor: string;
+  navHoverBgColor: string;
+  navHoverTextColor: string;
+}
+
+type CleanupFn = () => void;
+
+// Use full RapiDoc for proper auth tooltip behavior (mini version has limited features)
+const RAPIDOC_CDN = 'https://unpkg.com/rapidoc/dist/rapidoc-min.js';
+const RAPIDOC_ELEMENT = 'rapi-doc';
+
+// Memoization: track script loading state
+let scriptLoadPromise: Promise<void> | null = null;
+
+/**
+ * Load RapiDoc Mini script from CDN (memoized)
+ */
+function loadRapiDocScript(timeout = 10000): Promise<void> {
+  // Return existing promise if already loading
+  if (scriptLoadPromise) {
+    return scriptLoadPromise;
+  }
+
+  // Check if custom element already registered
+  if (customElements.get(RAPIDOC_ELEMENT)) {
+    return Promise.resolve();
+  }
+
+  scriptLoadPromise = new Promise((resolve, reject) => {
+    // Check if script tag already exists
+    const existing = Array.from(document.scripts).find(
+      (s) => s.src && s.src.includes('rapidoc')
+    );
+
+    if (existing && customElements.get(RAPIDOC_ELEMENT)) {
+      return resolve();
+    }
+
+    const script = document.createElement('script');
+    script.type = 'module';
+    script.src = RAPIDOC_CDN;
+
+    script.onload = () => {
+      // Poll for custom element registration
+      const startTime = Date.now();
+      const pollInterval = setInterval(() => {
+        if (customElements.get(RAPIDOC_ELEMENT)) {
+          clearInterval(pollInterval);
+          resolve();
+        } else if (Date.now() - startTime > timeout) {
+          clearInterval(pollInterval);
+          reject(new Error('RapiDoc Mini custom element not registered'));
+        }
+      }, 50);
+    };
+
+    script.onerror = () => {
+      scriptLoadPromise = null; // Reset on error for retry
+      reject(new Error(`Failed to load RapiDoc Mini from ${RAPIDOC_CDN}`));
+    };
+
+    document.head.appendChild(script);
+  });
+
+  return scriptLoadPromise;
+}
+
+/**
+ * Get current theme from localStorage
+ */
+function getTheme(): 'dark' | 'light' {
+  const theme = getPreference('theme');
+  return theme === 'dark' ? 'dark' : 'light';
+}
+
+/**
+ * Get theme configuration for RapiDoc Mini
+ * Colors matched to Hugo theme SCSS variables:
+ * - Dark: _theme-dark.scss
+ * - Light: _theme-light.scss
+ */
+function getThemeConfig(isDark: boolean): ThemeConfig {
+  return isDark
+    ? {
+        theme: 'dark',
+        bgColor: '#14141F', // $grey10 ($article-bg in dark theme)
+        textColor: '#D4D7DD', // $g15-platinum ($article-text in dark theme)
+        primaryColor: '#00A3FF', // $b-pool ($article-link)
+        navBgColor: '#07070E', // $grey5 ($body-bg in dark theme)
+        navTextColor: '#D4D7DD', // $g15-platinum ($nav-item)
+        navHoverBgColor: '#00A3FF', // $b-pool
+        navHoverTextColor: '#FFFFFF', // $g20-white
+      }
+    : {
+        theme: 'light',
+        bgColor: '#FFFFFF', // $g20-white ($article-bg in light theme)
+        textColor: '#020a47', // $br-dark-blue ($article-text in light theme)
+        primaryColor: '#00A3FF', // $b-pool ($article-link)
+        navBgColor: '#f3f4fb', // $body-bg in light theme
+        navTextColor: '#757888', // $g9-mountain ($nav-item)
+        navHoverBgColor: '#BF2FE5', // $br-magenta ($nav-item-hover)
+        navHoverTextColor: '#FFFFFF', // $g20-white
+      };
+}
+
+/**
+ * Apply theme attributes to RapiDoc Mini element
+ */
+function applyTheme(element: HTMLElement): void {
+  const isDark = getTheme() === 'dark';
+  const config = getThemeConfig(isDark);
+
+  // Core theme colors
+  element.setAttribute('theme', config.theme);
+  element.setAttribute('bg-color', config.bgColor);
+  element.setAttribute('text-color', config.textColor);
+  element.setAttribute('primary-color', config.primaryColor);
+
+  // Navigation colors (for any internal nav elements)
+  element.setAttribute('nav-bg-color', config.navBgColor);
+  element.setAttribute('nav-text-color', config.navTextColor);
+  element.setAttribute('nav-hover-bg-color', config.navHoverBgColor);
+  element.setAttribute('nav-hover-text-color', config.navHoverTextColor);
+
+  // Accent color - prevent green defaults
+  element.setAttribute('nav-accent-color', config.primaryColor);
+}
+
+/**
+ * Create RapiDoc Mini element with configuration
+ */
+function createRapiDocElement(
+  specUrl: string,
+  matchPaths?: string
+): HTMLElement {
+  const element = document.createElement(RAPIDOC_ELEMENT);
+
+  // Core attributes
+  element.setAttribute('spec-url', specUrl);
+  // matchPaths format: "method /path" (e.g., "post /write")
+  if (matchPaths) {
+    element.setAttribute('match-paths', matchPaths);
+  }
+
+  // Typography - match docs theme fonts
+  element.setAttribute(
+    'regular-font',
+    'Proxima Nova, -apple-system, BlinkMacSystemFont, sans-serif'
+  );
+  element.setAttribute(
+    'mono-font',
+    'IBM Plex Mono, Monaco, Consolas, monospace'
+  );
+  element.setAttribute('font-size', 'default'); // Match surrounding content size
+
+  // Layout - use 'read' style for proper auth element layout
+  element.setAttribute('layout', 'column');
+  element.setAttribute('render-style', 'read');
+  element.setAttribute('show-header', 'false');
+  element.setAttribute('allow-server-selection', 'false');
+
+  // Schema display - use 'table' style to reduce parameter indentation
+  element.setAttribute('schema-style', 'table');
+  element.setAttribute('default-schema-tab', 'schema');
+  element.setAttribute('paths-expanded', 'true');
+  element.setAttribute('schema-expand-level', '1');
+
+  // Interactivity
+  element.setAttribute('allow-try', 'true');
+  element.setAttribute('fill-request-fields-with-example', 'true');
+
+  // Reduce excessive spacing
+  element.setAttribute('use-path-in-nav-bar', 'false');
+  element.setAttribute('show-info', 'false');
+
+  // Authentication display - allow-authentication enables proper layout
+  element.setAttribute('allow-authentication', 'true');
+  element.setAttribute('show-components', 'false');
+
+  // Custom CSS for internal style overrides (table layout, etc.)
+  element.setAttribute('css-file', '/css/rapidoc-custom.css');
+
+  // Override method colors to use theme primary color instead of green
+  element.setAttribute('post-color', '#00A3FF'); // $b-pool instead of green
+  element.setAttribute('get-color', '#00A3FF');
+  element.setAttribute('put-color', '#9394FF'); // $br-galaxy
+  element.setAttribute('delete-color', '#BF3D5E'); // $r-ruby
+  element.setAttribute('patch-color', '#9394FF');
+
+  // Apply initial theme
+  applyTheme(element);
+
+  return element;
+}
+
+/**
+ * Watch for theme changes and update RapiDoc element
+ */
+function watchThemeChanges(container: HTMLElement): CleanupFn {
+  let currentElement: HTMLElement | null =
+    container.querySelector(RAPIDOC_ELEMENT);
+
+  const handleThemeChange = (): void => {
+    if (currentElement) {
+      applyTheme(currentElement);
+    }
+  };
+
+  // Watch stylesheet changes (Hugo theme.js enables/disables stylesheets)
+  const styleObserver = new MutationObserver((mutations) => {
+    for (const mutation of mutations) {
+      if (
+        mutation.type === 'attributes' &&
+        mutation.target instanceof HTMLLinkElement &&
+        mutation.target.title?.includes('theme')
+      ) {
+        handleThemeChange();
+        break;
+      }
+    }
+  });
+
+  const head = document.querySelector('head');
+  if (head) {
+    styleObserver.observe(head, {
+      attributes: true,
+      attributeFilter: ['disabled'],
+      subtree: true,
+    });
+  }
+
+  // Watch localStorage changes from other tabs
+  const storageHandler = (event: StorageEvent): void => {
+    if (event.key === 'influxdata_docs_preferences' && event.newValue) {
+      try {
+        const prefs = JSON.parse(event.newValue);
+        if (prefs.theme) {
+          handleThemeChange();
+        }
+      } catch (error) {
+        console.error('[RapiDoc Mini] Failed to parse preferences:', error);
+      }
+    }
+  };
+
+  window.addEventListener('storage', storageHandler);
+
+  // Return cleanup function
+  return (): void => {
+    styleObserver.disconnect();
+    window.removeEventListener('storage', storageHandler);
+  };
+}
+
+/**
+ * Show error message in container
+ */
+function showError(container: HTMLElement, message: string): void {
+  container.innerHTML = `
+    <div class="api-operation-error">
+      <p><strong>Error loading API documentation</strong></p>
+      <p>${message}</p>
+    </div>
+  `;
+}
+
+/**
+ * Initialize RapiDoc Mini component
+ */
+export default async function RapiDocMini({
+  component,
+}: ComponentOptions): Promise<CleanupFn | void> {
+  try {
+    // Get configuration from data attributes
+    const specUrl = component.dataset.specUrl;
+    const matchPaths = component.dataset.matchPaths;
+
+    if (!specUrl) {
+      console.error('[RapiDoc Mini] No data-spec-url attribute provided');
+      showError(component, 'No API specification configured.');
+      return;
+    }
+
+    // Load RapiDoc Mini from CDN (memoized)
+    try {
+      await loadRapiDocScript();
+    } catch (error) {
+      console.error('[RapiDoc Mini] Failed to load from CDN:', error);
+      showError(
+        component,
+        'Failed to load API viewer. Please refresh the page.'
+      );
+      return;
+    }
+
+    // Create and append RapiDoc Mini element
+    const rapiDocElement = createRapiDocElement(specUrl, matchPaths);
+    component.appendChild(rapiDocElement);
+
+    // Watch for theme changes and return cleanup function
+    return watchThemeChanges(component);
+  } catch (error) {
+    console.error('[RapiDoc Mini] Component initialization error:', error);
+    showError(component, 'API viewer failed to initialize.');
+  }
+}
diff --git a/assets/js/content-interactions.js b/assets/js/content-interactions.js
index eb9b4e1bc0..4c2a374c0a 100644
--- a/assets/js/content-interactions.js
+++ b/assets/js/content-interactions.js
@@ -122,21 +122,29 @@ function expandAccordions() {
 
   // Expand accordions on load based on URL anchor
   function openAccordionByHash() {
-    var anchor = window.location.hash;
+    var hash = window.location.hash;
+    if (!hash || hash.length <= 1) return;
+
+    // Use native DOM method to handle special characters in IDs (like /)
+    var id = hash.substring(1); // Remove leading #
+    var anchorElement = document.getElementById(id);
+    if (!anchorElement) return;
+
+    var $anchor = $(anchorElement);
 
     function expandElement() {
-      if ($(anchor).parents('.expand').length > 0) {
-        return $(anchor).closest('.expand').children('.expand-label');
-      } else if ($(anchor).hasClass('expand')) {
-        return $(anchor).children('.expand-label');
+      if ($anchor.parents('.expand').length > 0) {
+        return $anchor.closest('.expand').children('.expand-label');
+      } else if ($anchor.hasClass('expand')) {
+        return $anchor.children('.expand-label');
       }
+      return null;
     }
 
-    if (expandElement() != null) {
-      if (expandElement().children('.expand-toggle').hasClass('open')) {
-        // Do nothing?
-      } else {
-        expandElement().children('.expand-toggle').trigger('click');
+    var $expandLabel = expandElement();
+    if ($expandLabel != null) {
+      if (!$expandLabel.children('.expand-toggle').hasClass('open')) {
+        $expandLabel.children('.expand-toggle').trigger('click');
       }
     }
   }
diff --git a/assets/js/main.js b/assets/js/main.js
index 826ad9a116..77fda067a5 100644
--- a/assets/js/main.js
+++ b/assets/js/main.js
@@ -46,6 +46,9 @@ import SidebarSearch from './components/sidebar-search.js';
 import { SidebarToggle } from './sidebar-toggle.js';
 import Theme from './theme.js';
 import ThemeSwitch from './theme-switch.js';
+import ApiRapiDoc from './components/api-rapidoc.ts';
+import ApiToc from './components/api-toc.ts';
+import RapiDocMini from './components/rapidoc-mini.ts';
 
 /**
  * Component Registry
@@ -77,6 +80,9 @@ const componentRegistry = {
   'sidebar-toggle': SidebarToggle,
   theme: Theme,
   'theme-switch': ThemeSwitch,
+  'api-rapidoc': ApiRapiDoc,
+  'api-toc': ApiToc,
+  'rapidoc-mini': RapiDocMini,
 };
 
 /**
diff --git a/assets/styles/layouts/_api-layout.scss b/assets/styles/layouts/_api-layout.scss
new file mode 100644
index 0000000000..c3c6012c5a
--- /dev/null
+++ b/assets/styles/layouts/_api-layout.scss
@@ -0,0 +1,786 @@
+/////////////////////////////// API Reference Layout ///////////////////////////////
+//
+// 3-column layout for API reference documentation:
+// - Left: Existing Hugo sidebar + API navigation section
+// - Center: Content with page-level tabs (Operations | Server | Auth | Compatibility)
+// - Right: "ON THIS PAGE" table of contents
+//
+////////////////////////////////////////////////////////////////////////////////
+
+// Content wrapper becomes flex container when used with API content
+// Override overflow:hidden from _content-wrapper.scss to enable sticky positioning
+.content-wrapper.api-content {
+  display: flex;
+  flex-direction: row;
+  align-items: flex-start;
+  overflow: visible; // Required for sticky TOC to work
+}
+
+// Main API content area (center column)
+.api-main {
+  flex: 1;
+  min-width: 0; // Prevent flex item from overflowing
+  padding-right: 1rem;
+}
+
+// Right-side TOC (third column)
+.api-toc {
+  width: 200px;
+  flex-shrink: 0;
+  position: sticky;
+  top: 80px; // Account for fixed header height
+  align-self: flex-start; // Critical for sticky to work in flexbox
+  max-height: calc(100vh - 100px);
+  overflow-y: auto;
+  padding: 1rem;
+  border-left: 1px solid $nav-border;
+
+  // Hidden state (used when Operations/RapiDoc tab is active)
+  &.is-hidden {
+    display: none;
+  }
+
+  &-header {
+    font-size: 0.75rem;
+    font-weight: $bold;
+    text-transform: uppercase;
+    letter-spacing: 0.08rem;
+    color: rgba($article-heading, 0.5);
+    margin: 0 0 1rem;
+  }
+
+  &-nav {
+    // TOC list styles
+    .api-toc-list {
+      list-style: none;
+      margin: 0;
+      padding: 0;
+    }
+
+    .api-toc-item {
+      margin: 0;
+
+      &--nested {
+        padding-left: 0.75rem;
+      }
+    }
+
+    .api-toc-link {
+      display: block;
+      padding: 0.35rem 0;
+      font-size: 0.85rem;
+      color: $nav-item;
+      text-decoration: none;
+      transition: color 0.2s;
+      line-height: 1.4;
+
+      &:hover {
+        color: $nav-item-hover;
+      }
+
+      &.is-active {
+        color: $nav-active;
+        font-weight: $medium;
+      }
+    }
+  }
+
+  &-empty {
+    font-size: 0.85rem;
+    color: rgba($article-text, 0.5);
+    font-style: italic;
+  }
+
+  // Operations-based TOC (for tag-based pages)
+  &-nav .api-toc-list--operations {
+    .api-toc-item--operation {
+      margin: 0.35rem 0;
+    }
+
+    .api-toc-link--operation {
+      display: flex;
+      align-items: center;
+      gap: 0.5rem;
+      font-size: 0.8rem;
+      padding: 0.3rem 0;
+    }
+
+    // HTTP method badges in TOC
+    .api-method {
+      display: inline-block;
+      font-size: 0.6rem;
+      font-weight: $bold;
+      text-transform: uppercase;
+      padding: 0.15rem 0.3rem;
+      border-radius: 3px;
+      min-width: 2.2rem;
+      text-align: center;
+      flex-shrink: 0;
+
+      &--get { background-color: $b-pool; color: #fff; }           // #00A3FF - bright brand blue
+      &--post { background-color: $gr-rainforest; color: #fff; }   // #34BB55 - bright brand green
+      &--put { background-color: $y-pineapple; color: #fff; }      // #FFB94A - bright yellow (distinct from red)
+      &--patch { background-color: $br-new-purple; color: #fff; }  // #9b2aff - distinctive brand purple
+      &--delete { background-color: $r-curacao; color: #fff; }     // #F95F53 - bright brand red
+    }
+
+    .api-path {
+      font-family: $code;
+      font-size: 0.75rem;
+      word-break: break-all;
+      color: inherit;
+    }
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////// Operations List (Main Content) //////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+// Operations list section
+.api-operations-list {
+  margin: 2rem 0;
+
+  h2 {
+    margin-bottom: 1rem;
+  }
+}
+
+// Grid container for operation cards
+.api-operations-grid {
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+}
+
+// Individual operation card (clickable link)
+.api-operation-card {
+  display: flex;
+  align-items: flex-start;
+  gap: 0.75rem;
+  padding: 0.75rem 1rem;
+  background: rgba($article-bg, 0.5);
+  border: 1px solid $nav-border;
+  border-radius: $radius;
+  text-decoration: none;
+  color: $article-text;
+  transition: background-color 0.2s, border-color 0.2s;
+
+  &:hover {
+    background: rgba($article-bg, 0.8);
+    border-color: $nav-item-hover;
+  }
+
+  // HTTP method badge
+  .api-method {
+    display: inline-block;
+    font-size: 0.7rem;
+    font-weight: $bold;
+    text-transform: uppercase;
+    padding: 0.2rem 0.4rem;
+    border-radius: 3px;
+    min-width: 3.5rem;
+    text-align: center;
+    flex-shrink: 0;
+    margin-top: 0.15rem;
+    border: 2px solid;
+    background-color: transparent;
+
+    &--get { border-color: $b-pool; color: $b-pool; }                 // #00A3FF - bright brand blue
+    &--post { border-color: $gr-rainforest; color: $gr-rainforest; }  // #34BB55 - bright brand green
+    &--put { border-color: $y-pineapple; color: $y-pineapple; }       // #FFB94A - bright yellow (distinct from red)
+    &--patch { border-color: $br-new-purple; color: $br-new-purple; } // #9b2aff - distinctive brand purple
+    &--delete { border-color: $r-curacao; color: $r-curacao; }        // #F95F53 - bright brand red
+  }
+
+  // API path in monospace
+  .api-path {
+    font-family: $code;
+    font-size: 0.9rem;
+    color: $article-heading;
+    word-break: break-all;
+    flex-shrink: 0;
+  }
+
+  // Operation summary text
+  .api-operation-summary {
+    font-size: 0.875rem;
+    color: rgba($article-text, 0.8);
+    flex: 1;
+  }
+}
+
+// Overview/Description section
+.api-description {
+  margin: 2rem 0;
+  color: $article-text !important; // Override any inherited black color
+  
+  h2 {
+    margin-bottom: 1rem;
+  }
+  
+  // Ensure description text is visible and readable
+  p, ul, ol, pre, code {
+    color: $article-text !important;
+    opacity: 1;
+  }
+  
+  // Also ensure direct text nodes use correct color
+  & > * {
+    color: $article-text !important;
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////// API Navigation in Sidebar ///////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+// API navigation wrapper - controls visibility
+// Hidden by default, revealed via JS (localStorage) or on API pages
+.api-nav-wrapper {
+  display: none; // Hidden by default
+
+  &.is-revealed {
+    display: block; // Revealed via JS
+  }
+
+  // Always show on API pages (server-rendered with .api-reference class)
+  .api-reference & {
+    display: block;
+  }
+}
+
+// API navigation section added to the existing Hugo sidebar
+.api-nav {
+  margin-top: 2rem;
+  padding-top: 1rem;
+  border-top: 1px solid $nav-border;
+
+  &-header {
+    font-size: 0.85rem;
+    font-weight: $bold;
+    text-transform: uppercase;
+    letter-spacing: 0.06rem;
+    color: rgba($article-heading, 0.6);
+    margin: 0 0 1rem;
+    padding-left: 1.5rem;
+  }
+
+  // API nav groups (collapsible sections)
+  &-group {
+    margin-bottom: 0.5rem;
+
+    &-header {
+      display: flex;
+      align-items: center;
+      padding: 0.5rem 0 0.5rem 1.5rem;
+      font-weight: $medium;
+      color: $nav-category;
+      cursor: pointer;
+      transition: color 0.2s;
+      // Button reset for dark mode compatibility
+      background: none;
+      border: none;
+      width: 100%;
+      text-align: left;
+      font-size: 1.2rem; // Match sidebar .nav-category > a (19.2px)
+      font-family: inherit;
+      text-decoration: none; // For anchor version
+
+      &:hover {
+        color: $nav-category-hover;
+      }
+
+      &.is-active {
+        color: $nav-active;
+      }
+
+      // Collapse/expand indicator (for button headers)
+      &::before {
+        content: "";
+        display: inline-block;
+        width: 0;
+        height: 0;
+        margin-right: 0.5rem;
+        border-left: 5px solid $nav-border;
+        border-top: 4px solid transparent;
+        border-bottom: 4px solid transparent;
+        transition: transform 0.2s;
+        flex-shrink: 0;
+      }
+
+      &.is-open::before {
+        transform: rotate(90deg);
+      }
+    }
+
+    // For anchor headers, keep the ::before arrow (same as button)
+    // No special handling needed - anchor headers look the same as button headers
+    a#{&}-header {
+      // Same styling as button, arrow works via ::before
+    }
+
+    &-items {
+      list-style: none;
+      padding-left: 2.5rem;
+      margin: 0;
+      max-height: 0;
+      overflow: hidden;
+      transition: max-height 0.3s ease-out;
+      background: $body-bg; // Match sidebar background
+
+      &.is-open {
+        max-height: 2000px; // Large enough to show all operations
+      }
+    }
+  }
+
+  // Individual API nav items
+  &-item {
+    margin: 0.25rem 0;
+    position: relative;
+
+    a {
+      display: flex;
+      align-items: center;
+      padding: 0.35rem 0;
+      color: $nav-item;
+      text-decoration: none;
+      font-size: 0.95rem;
+      transition: color 0.2s;
+
+      &:hover {
+        color: $nav-item-hover;
+      }
+    }
+
+    &.is-active a {
+      color: $nav-active;
+      font-weight: $medium;
+    }
+
+    // HTTP method badge (legacy class)
+    .method-badge {
+      display: inline-block;
+      font-size: 0.65rem;
+      font-weight: $bold;
+      text-transform: uppercase;
+      padding: 0.15rem 0.35rem;
+      margin-right: 0.5rem;
+      border-radius: 3px;
+      min-width: 2.5rem;
+      text-align: center;
+
+      &.get { background-color: $gr-rainforest; color: #fff; }
+      &.post { background-color: $b-ocean; color: #fff; }
+      &.put { background-color: $br-galaxy; color: #fff; }
+      &.patch { background-color: $y-thunder; color: rgba($g5-pepper, 0.75); }
+      &.delete { background-color: $r-curacao; color: #fff; }
+    }
+
+    // Tag items that link to tag pages
+    &.api-nav-tag {
+      > a {
+        font-weight: $medium;
+      }
+
+      // Nested operations list under tag
+      .api-nav-operations {
+        list-style: none;
+        margin: 0.25rem 0 0.5rem;
+        padding-left: 0.75rem;
+
+        .api-nav-operation {
+          margin: 0.15rem 0;
+
+          a {
+            display: flex;
+            align-items: center;
+            gap: 0.4rem;
+            font-size: 0.85rem;
+            padding: 0.25rem 0;
+          }
+        }
+      }
+    }
+
+    // Operation items with method badges
+    &.api-nav-operation,
+    .api-nav-operation {
+      .api-method {
+        display: inline-block;
+        font-size: 0.55rem;
+        font-weight: $bold;
+        text-transform: uppercase;
+        padding: 0.1rem 0.25rem;
+        border-radius: 3px;
+        min-width: 2rem;
+        text-align: center;
+        flex-shrink: 0;
+
+        &--get { background-color: $b-pool; color: #fff; }           // #00A3FF - bright brand blue
+        &--post { background-color: $gr-rainforest; color: #fff; }   // #34BB55 - bright brand green
+        &--put { background-color: $y-pineapple; color: #fff; }      // #FFB94A - bright yellow (distinct from red)
+        &--patch { background-color: $br-new-purple; color: #fff; }  // #9b2aff - distinctive brand purple
+        &--delete { background-color: $r-curacao; color: #fff; }     // #F95F53 - bright brand red
+      }
+
+      .api-path {
+        font-family: $code;
+        font-size: 0.85rem;
+        word-break: break-all;
+        color: inherit;
+      }
+    }
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/////////////////////////// API Header with Actions ////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+// Header row with title and download button
+.article--header-row {
+  display: flex;
+  justify-content: space-between;
+  align-items: flex-start;
+  gap: 1rem;
+  flex-wrap: wrap;
+}
+
+.article--header-text {
+  flex: 1 1 100%; // Take full width, allowing download button to wrap
+  min-width: 0;
+}
+
+// Summary paragraph in header - ensure full width
+.article--summary {
+  max-width: none;
+  width: 100%;
+}
+
+// Download OpenAPI spec button
+.api-spec-actions {
+  flex-shrink: 0;
+}
+
+.api-spec-download {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.5rem;
+  padding: 0.5rem 1rem;
+  background-color: $g20-white;
+  color: $article-text;
+  text-decoration: none;
+  border-radius: $radius;
+  font-size: 0.875rem;
+  font-weight: $medium;
+  transition: background-color 0.2s, color 0.2s;
+  border: 1px solid $nav-border;
+  white-space: nowrap;
+
+  &:hover {
+    background-color: $r-curacao;
+    color: $g20-white;
+    border-color: $r-curacao;
+  }
+
+  svg {
+    flex-shrink: 0;
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////// API Tabs ////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+// API-specific tab wrapper (uses api-tabs-wrapper to avoid conflict with
+// tabbed-content.js which handles .tabs-wrapper elements)
+.api-tabs-wrapper {
+  margin: 1.5rem 0 1rem;
+}
+
+// API tab navigation bar
+.api-tabs-nav {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 2px;
+
+  a {
+    flex-grow: 1;
+    position: relative;
+    font-size: 1rem;
+    font-weight: $medium;
+    padding: 0.65rem 1.25rem;
+    display: inline-block;
+    white-space: nowrap;
+    text-align: center;
+    color: $article-tab-text !important;
+    border-radius: $radius;
+    background-color: $article-tab-bg;
+    text-decoration: none;
+    transition: background-color 0.2s, color 0.2s;
+    z-index: 1;
+
+    &::after {
+      content: '';
+      position: absolute;
+      display: block;
+      top: 0;
+      right: 0;
+      width: 100%;
+      height: 100%;
+      border-radius: $radius;
+      @include gradient($article-btn-gradient);
+      opacity: 0;
+      transition: opacity 0.2s;
+      z-index: -1;
+    }
+
+    &:hover {
+      color: $article-tab-active-text !important;
+      &::after {
+        opacity: 1;
+      }
+    }
+
+    &.is-active {
+      color: $article-tab-active-text !important;
+      &::after {
+        opacity: 1;
+        @include gradient($article-btn-gradient);
+      }
+    }
+  }
+}
+
+// Tab panels container
+.api-tab-panels {
+  // Tab content visibility (follows existing pattern)
+  .tab-content:not(:first-of-type) {
+    display: none;
+  }
+
+  // RapiDoc container styling
+  rapi-doc {
+    display: block;
+    width: 100%;
+    min-height: 400px;
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////// RapiDoc Overrides ///////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+// Hide RapiDoc's internal navigation (we provide our own)
+rapi-doc::part(section-navbar) {
+  display: none !important;
+}
+
+// Hide RapiDoc's internal tag headers/titles (we use custom tabs for navigation)
+// label-tag-title is the "PROCESSING ENGINE" header with auth badges shown in tag groups
+rapi-doc::part(label-tag-title) {
+  display: none !important;
+}
+
+// Hide RapiDoc's authentication section (we have separate Auth tab)
+rapi-doc::part(section-auth) {
+  display: none !important;
+}
+
+// Ensure RapiDoc content fills available space
+rapi-doc::part(section-main-content) {
+  padding: 0;
+}
+
+// Match RapiDoc's operation section styling to our theme
+rapi-doc::part(section-operations) {
+  padding: 0;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////// Authentication Tab Content //////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+.api-auth-content {
+  max-width: 800px;
+}
+
+.api-auth-card {
+  background: $article-bg;
+  border: 1px solid $nav-border;
+  border-radius: $radius;
+  padding: 1.5rem;
+  margin-bottom: 1.5rem;
+
+  h3 {
+    margin-top: 0;
+    margin-bottom: 0.5rem;
+  }
+
+  h4 {
+    margin-top: 1rem;
+    margin-bottom: 0.5rem;
+    font-size: 0.9rem;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    color: rgba($article-text, 0.6);
+  }
+
+  pre {
+    margin: 0.5rem 0;
+    padding: 1rem;
+    background: $article-code-bg;
+    border-radius: $radius;
+    overflow-x: auto;
+  }
+
+  code {
+    font-family: $code;
+    font-size: 0.875rem;
+  }
+}
+
+.api-auth-badge .badge {
+  display: inline-block;
+  padding: 0.25rem 0.5rem;
+  font-size: 0.75rem;
+  font-weight: $bold;
+  text-transform: uppercase;
+  border-radius: $radius;
+
+  &.recommended {
+    background: $gr-rainforest;
+    color: $g20-white;
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//////////////////////////// Server Tab Content ////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+.api-server-panel {
+  max-width: 600px;
+
+  h2 {
+    margin-top: 0;
+  }
+}
+
+.server-url-config {
+  display: flex;
+  gap: 0.5rem;
+  align-items: flex-end;
+  margin: 1rem 0;
+  flex-wrap: wrap;
+
+  label {
+    width: 100%;
+    font-weight: $medium;
+    margin-bottom: 0.25rem;
+  }
+
+  input {
+    flex: 1;
+    min-width: 200px;
+    padding: 0.5rem;
+    border: 1px solid $nav-border;
+    border-radius: $radius;
+    font-family: $code;
+    background: $article-bg;
+    color: $article-text;
+  }
+
+  button {
+    padding: 0.5rem 1rem;
+    background: $r-curacao;
+    color: $g20-white;
+    border: none;
+    border-radius: $radius;
+    cursor: pointer;
+    font-weight: $medium;
+
+    &:hover {
+      background: darken($r-curacao, 10%);
+    }
+  }
+}
+
+.server-info {
+  margin-top: 1.5rem;
+
+  ul {
+    list-style: disc;
+    padding-left: 1.5rem;
+  }
+
+  li {
+    margin: 0.5rem 0;
+  }
+
+  code {
+    background: $article-code-bg;
+    padding: 0.2rem 0.4rem;
+    border-radius: 3px;
+    font-family: $code;
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////// MEDIA QUERIES ////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+// Tablet: Hide TOC, keep sidebar
+@include media(large) {
+  .content-wrapper.api-content {
+    flex-direction: column;
+  }
+
+  .api-toc {
+    display: none;
+  }
+
+  .api-main {
+    padding-right: 0;
+  }
+}
+
+// Mobile: Standard Hugo sidebar behavior
+@include media(medium) {
+  .content-wrapper.api-content {
+    flex-direction: column;
+  }
+
+  .api-toc {
+    display: none;
+  }
+
+  .api-main {
+    padding-right: 0;
+  }
+
+  // Collapse API nav in mobile view
+  .api-nav {
+    margin-top: 1rem;
+    padding-top: 0.5rem;
+
+    &-group-items {
+      max-height: none; // Show all items by default in mobile
+    }
+  }
+}
+
+// Large screens: Wider TOC
+@include media(xlarge) {
+  .api-toc {
+    width: 240px;
+  }
+}
+
+// Match sidebar responsive widths
+@media (min-width: 801px) and (max-width: 1200px) {
+  .api-toc {
+    width: 180px;
+  }
+}
diff --git a/assets/styles/layouts/_api-overrides.scss b/assets/styles/layouts/_api-overrides.scss
index bc220588f8..f108911e24 100644
--- a/assets/styles/layouts/_api-overrides.scss
+++ b/assets/styles/layouts/_api-overrides.scss
@@ -1,9 +1,17 @@
+////////////////////////////////////////////////////////////////////////////////
+// API Documentation Style Overrides
+//
+// Provides loading spinner and reusable API-related styles.
+// Note: Legacy Redoc-specific overrides have been removed in favor of
+// Scalar/RapiDoc renderers which use CSS custom properties for theming.
+////////////////////////////////////////////////////////////////////////////////
+
 @import "tools/color-palette";
 @import "tools/fonts";
 
 // Fonts
 $proxima: 'Proxima Nova', sans-serif;
-$code: 'IBM Plex Mono', monospace;;
+$code: 'IBM Plex Mono', monospace;
 
 // Font weights
 $medium: 500;
@@ -22,7 +30,7 @@ $bold: 700;
 }
 
 @keyframes spinner {
-  to {transform: rotate(360deg);}
+  to { transform: rotate(360deg); }
 }
 
 .spinner:before {
@@ -41,256 +49,15 @@ $bold: 700;
   animation: spinner .6s linear infinite;
 }
 
-//////////////////////////////// InfluxDB Header ///////////////////////////////
-
-#influx-header {
-  font-family: $proxima;
-  padding: 10px ;
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  background-color: $g2-kevlar;
-  a {
-    text-decoration: none;
-    &.back {
-      color: $g20-white;
-      transition: color .2s;
-      &:hover {
-        color: $b-pool;
-      }
-      &:before {
-        content: "\e919";
-        font-family: 'icomoon-v2';
-        margin-right: .65rem;
-      }
-    }
-    &.btn {
-      padding: .5rem .75rem .5rem .65rem;
-      font-size: .85rem;
-      font-weight: 500;
-      color: $g15-platinum;
-      background: $g5-pepper;
-      border-radius: 4.5px;
-      transition: all .2s;
-      &:before {
-        content: "\e934";
-        display: inline-block;
-        font-size: .95rem;
-        margin-right: .5rem;
-        font-family: 'icomoon-v2';
-      }
-      &:hover {
-        color: $g20-white;
-        background: $b-pool;
-      }
-    }
-  }
-}
-
-// Header Media Queries
-
-@media (max-width: 600px) {
-  #influx-header span.version {display: none;}
-}
-
+////////////////////////////////////////////////////////////////////////////////
+/////////////////////////// HTTP Method Badge Colors ///////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
-.cjtbAK {
-  h1,h2,h3,h4,h5,h6,
-  p,li,th,td {
-    font-family: $proxima !important;
-  }
-}
-
-#redoc {
-  h1,h2,h3 {
-    font-weight: $medium !important;
-  }
-}
-
-// Section title padding
-.dluJDj {
-  padding: 20px 0;
-}
-
-// Page h1
-.dTJWQH {
-  color: $g7-graphite;
-  font-size: 2rem;
-}
-
-// Download button
-.jIdpVJ {
-  background: $b-dodger;
-  color: $g20-white;
-  border: none;
-  border-radius: 3px;
-  font-family: $proxima;
-  font-size: .85rem;
-  font-weight: $medium;
-  transition: background-color .2s;
-  &:hover {
-    background-color: $b-pool;
-  }
-}
-
-// Tag h1s
-.WxWXp {
-  color: $g7-graphite;
-  font-size: 1.75rem;
-}
-
-// Summaru h2s and table headers
-.ioYTqA, .bxcHYI, .hoUoen {
-  color: $g7-graphite;
-}
-
-// h3s
-.espozG {
-  color: $g8-storm;
-}
-
-// Links
-.bnFPhO a { color: $b-dodger;
-  &:visited {color: $b-dodger;}
-}
-
-.redoc-json {
-  font-family: $code !important;
-}
-
-// Inline Code
-.flfxUM code,
-.gDsWLk code,
-.kTVySD {
-  font-family: $code !important;
-  color: $cp-marguerite;
-  background: $cp-titan;
-  border-color: $cp-titan;
-}
-
-// Required tags
-.jsTAxL {
-  color: $r-curacao;
-}
-
-///////////////////////////// RESPONSE COLOR BLOCKS ////////////////////////////
-
-// Green
-.hLVzSF, .fDvFMp {
-  background-color: rgba($gr-honeydew, .2);
-  color: $gr-emerald;
-}
-
-// Red
-.byLrBg {
-  background-color: rgba($r-curacao, .1);
-  color: $r-curacao;
-}
-
-
-
-/////////////////////////////////// LEFT NAV ///////////////////////////////////
-
-// Left nav background
-.gZdDsM {
-  background-color: $g19-ghost;
-}
-
-.gpbcFk:hover, .sc-eTuwsz.active {
-  background-color: $g17-whisper;
-}
-
-// List item text
-.SmuWE, .gcUzvG, .bbViyS, .sc-hrWEMg label {
-  font-family: $proxima !important;
-}
-
-.fyUykq {
-  font-weight: $medium;
-}
-
-// Request method tags
-.cFwMcp {
-  &.post { background-color: $b-ocean; }
-  &.get { background-color: $gr-rainforest; }
-  &.put { background-color: $br-galaxy; }
-  &.patch { background-color: $y-thunder; color: rgba($g5-pepper, .75);}
-  &.delete { background-color: $r-curacao; }
-}
-
-// Active nav section
-.gcUzvG, .iNzLCk:hover {
-  color: $br-magenta;
-}
-
-/////////////////////////////// RIGHT CODE COLUMN //////////////////////////////
-
-// Right column backgrounds
-.dtUibw, .fLUKgj {
-  background-color: $g2-kevlar;
-  h3,h4,h5,h6 {
-    font-family: $proxima !important;
-    font-weight: $medium !important;
-  }
-}
-
-// Code backgrounds
-.irpqyy > .react-tabs__tab-panel {
-  background-color: $g0-obsidian;
-}
-.dHLKeu, .fVaxnA {
-  padding-left: 10px;
-  background-color: $g0-obsidian;
-}
-
-// Response code tabs
-.irpqyy > ul > li {
-  background-color: $g0-obsidian;
-  border-radius: 3px;
-  &.react-tabs__tab--selected{ color: $br-pulsar;}
-  &.tab-error { color: $r-fire; }
-  &.tab-success { color: $gr-viridian; }
-}
-
-// Request methods
-.bNYCAJ,
-.jBjYbV,
-.hOczRB,
-.fRsrDc,
-.hPskZd {
-  font-family: $proxima;
-  font-weight: $medium;
-  letter-spacing: .04em;
-  border-radius: 3px;
-}
-.bNYCAJ { background-color: $b-ocean; } /* Post */
-.jBjYbV { background-color: $gr-viridian; } /* Get */
-.hOczRB { background-color: $br-galaxy; } /* Put */
-.fRsrDc { background-color: $y-thunder; color: $g5-pepper; } /* Patch */
-.hPskZd { background-color: $r-curacao; } /* Delete */
-
-// Content type block
-.gzAoUb {
-  background-color: $g2-kevlar;
-  font-family: $proxima;
-}
-.iENVAs { font-family: $code; }
-.dpMbau { font-family: $proxima; }
-
-// Code controls
-.fCJmC {
-  font-family: $proxima;
-  span { border-radius: 3px; }
-}
-
-// Code blocks
-.kZHJcC { font-family: $code; }
-.jCgylq {
-  .token.string {
-    color: $gr-honeydew;
-    & + a { color: $b-pool; }
-  }
-  .token.boolean { color: #f955b0; }
-}
+// Reusable method badge colors (used by _api-layout.scss .method-badge)
+// These follow standard REST API color conventions
+$method-get: $gr-rainforest;
+$method-post: $b-ocean;
+$method-put: $br-galaxy;
+$method-patch: $y-thunder;
+$method-delete: $r-curacao;
 
diff --git a/assets/styles/layouts/_sidebar.scss b/assets/styles/layouts/_sidebar.scss
index 1c8df3c041..9add872854 100644
--- a/assets/styles/layouts/_sidebar.scss
+++ b/assets/styles/layouts/_sidebar.scss
@@ -255,6 +255,66 @@
         }
       }
     }
+
+    // API operation items within Hugo menu
+    .api-operation {
+      a {
+        display: flex;
+        align-items: center;
+        gap: 0.4rem;
+      }
+
+      // Path-based operation display (All endpoints list)
+      &--path .api-path {
+        font-family: $proxima;
+        font-size: 0.9rem;
+        color: inherit;
+        word-break: break-all;
+      }
+    }
+
+    .api-method {
+      font-size: 0.6rem;
+      font-weight: 700;
+      padding: 0.15rem 0.35rem;
+      border-radius: 3px;
+      text-transform: uppercase;
+      flex-shrink: 0;
+      line-height: 1;
+      border: 2px solid;
+      background-color: transparent;
+
+      // Using lighter InfluxData brand colors - bordered style for readability
+      &--get { border-color: $b-pool; color: $b-pool; }                 // #00A3FF - bright brand blue
+      &--post { border-color: $gr-rainforest; color: $gr-rainforest; }  // #34BB55 - bright brand green
+      &--put { border-color: $y-pineapple; color: $y-pineapple; }       // #FFB94A - bright yellow (distinct from red)
+      &--delete { border-color: $r-curacao; color: $r-curacao; }        // #F95F53 - bright brand red
+      &--patch { border-color: $br-new-purple; color: $br-new-purple; } // #9b2aff - distinctive brand purple
+    }
+
+    // Compatibility version badge (v1 or v2)
+    .api-compat-badge {
+      font-size: 0.55rem;
+      font-weight: 600;
+      padding: 0.1rem 0.3rem;
+      border-radius: 3px;
+      text-transform: uppercase;
+      flex-shrink: 0;
+      line-height: 1;
+      margin-left: auto;
+      opacity: 0.8;
+      cursor: help;
+
+      &--v1 { background: #8b5cf6; color: white; } // Purple for v1
+      &--v2 { background: #06b6d4; color: white; } // Cyan for v2
+    }
+
+    // Non-link group labels (for multi-tag groups)
+    .nav-group-label {
+      color: $nav-item;
+      font-weight: $medium;
+      display: inline-block;
+    }
   }
 }
 
diff --git a/assets/styles/styles-default.scss b/assets/styles/styles-default.scss
index 8852a240c3..94c897f291 100644
--- a/assets/styles/styles-default.scss
+++ b/assets/styles/styles-default.scss
@@ -32,7 +32,8 @@
         "layouts/v1-overrides",
         "layouts/notifications",
         "layouts/code-controls",
-        "layouts/v3-wayfinding";
+        "layouts/v3-wayfinding",
+        "layouts/api-layout";
 
 // Import Components
 @import "components/influxdb-version-detector",
diff --git a/content/influxdb3/core/reference/api/_index.md b/content/influxdb3/core/reference/api/_index.md
index 6a2200b1e5..13724ba97f 100644
--- a/content/influxdb3/core/reference/api/_index.md
+++ b/content/influxdb3/core/reference/api/_index.md
@@ -1,20 +1,12 @@
 ---
 title: InfluxDB HTTP API
 description: >
-  The InfluxDB HTTP API for {{% product-name %}} provides a programmatic interface
-  for interactions with InfluxDB,
-  including writing, querying, and processing data, and managing an InfluxDB 3
-  instance.
-menu:
-  influxdb3_core:
-    parent: Reference
-    name: InfluxDB HTTP API
-weight: 104
-influxdb3/core/tags: [api]
-source: /shared/influxdb3-api-reference/_index.md
+  The InfluxDB HTTP API for InfluxDB 3 Core provides a programmatic interface
+  for interactions with InfluxDB.
+# Redirect to the new location
+aliases:
+  - /influxdb3/core/reference/api/
+redirect: /influxdb3/core/api/
 ---
 
-<!--
-The content for this page is at
-// SOURCE /content/shared/influxdb3-api-reference/_index.md
-->
+This page has moved to [InfluxDB HTTP API](/influxdb3/core/api/).
diff --git a/content/influxdb3/enterprise/reference/api/_index.md b/content/influxdb3/enterprise/reference/api/_index.md
index ea78867f6d..a5a831de48 100644
--- a/content/influxdb3/enterprise/reference/api/_index.md
+++ b/content/influxdb3/enterprise/reference/api/_index.md
@@ -1,20 +1,10 @@
 ---
 title: InfluxDB HTTP API
 description: >
-  The InfluxDB HTTP API for {{% product-name %}} provides a programmatic interface
-  for interactions with InfluxDB,
-  including writing, querying, and processing data, and managing an InfluxDB 3
-  instance.
-menu:
-  influxdb3_enterprise:
-    parent: Reference
-    name: InfluxDB HTTP API
-weight: 104
-influxdb3/enterprise/tags: [api]
-source: /shared/influxdb3-api-reference/_index.md
+  The InfluxDB HTTP API for InfluxDB 3 Enterprise provides a programmatic interface
+  for interactions with InfluxDB.
+# Redirect to the new location
+redirect: /influxdb3/enterprise/api/
 ---
 
-<!--
-The content for this page is at
-// SOURCE /content/shared/influxdb3-api-reference/_index.md
-->
+This page has moved to [InfluxDB HTTP API](/influxdb3/enterprise/api/).
diff --git a/cypress/e2e/content/api-reference.cy.js b/cypress/e2e/content/api-reference.cy.js
index ceeaffeffc..ca9d4e47c5 100644
--- a/cypress/e2e/content/api-reference.cy.js
+++ b/cypress/e2e/content/api-reference.cy.js
@@ -1,8 +1,20 @@
 /// <reference types="cypress" />
+
+/**
+ * API Reference Documentation E2E Tests
+ *
+ * Tests both:
+ * 1. Legacy API reference pages (link validation, content structure)
+ * 2. New 3-column layout with tabs and TOC (for InfluxDB 3 Core/Enterprise)
+ *
+ * Run with:
+ * node cypress/support/run-e2e-specs.js --spec "cypress/e2e/content/api-reference.cy.js" content/influxdb3/core/reference/api/_index.md
+ */
+
 const fakeGoogleTagManager = {
   trackingOptIn: () => {},
-  trackingOptOut: () => {}
-}
+  trackingOptOut: () => {},
+};
 
 describe('API reference content', () => {
   const subjects = [
@@ -37,42 +49,47 @@ describe('API reference content', () => {
     '/influxdb3/enterprise/api/',
   ];
 
-
   subjects.forEach((subject) => {
     describe(subject, () => {
       beforeEach(() => {
-                // Intercept and modify the page HTML before it loads
-                cy.intercept('GET', '**', (req) => {
-                  req.continue((res) => {
-                    if (res.headers['content-type']?.includes('text/html')) {
-                      // Modify the Kapa widget script attributes
-                      // Avoid socket errors from fpjs in tests by disabling fingerprinting
-                      res.body = res.body.replace(
-                        /data-user-analytics-fingerprint-enabled="true"/,
-                        'data-user-analytics-fingerprint-enabled="false"'
-                      );
-                    }
-                  });
-                });
+        // Intercept and modify the page HTML before it loads
+        cy.intercept('GET', '**', (req) => {
+          req.continue((res) => {
+            if (res.headers['content-type']?.includes('text/html')) {
+              // Modify the Kapa widget script attributes
+              // Avoid socket errors from fpjs in tests by disabling fingerprinting
+              res.body = res.body.replace(
+                /data-user-analytics-fingerprint-enabled="true"/,
+                'data-user-analytics-fingerprint-enabled="false"'
+              );
+            }
+          });
+        });
         cy.visit(subject);
 
-
         window.fcdsc = fakeGoogleTagManager;
         cy.stub(window.fcdsc, 'trackingOptIn').as('trackingOptIn');
         cy.stub(window.fcdsc, 'trackingOptOut').as('trackingOptOut');
       });
       it(`has API info`, function () {
-        cy.get('script[data-user-analytics-fingerprint-enabled=false]').should('have.length', 1);
+        cy.get('script[data-user-analytics-fingerprint-enabled=false]').should(
+          'have.length',
+          1
+        );
         cy.get('h1').first().should('have.length', 1);
-        cy.get('[data-role$=description]').should('have.length', 1);
+        // Check for description element (either article--description class or data-role attribute)
+        cy.get('.article--description, [data-role$=description]').should(
+          'have.length.at.least',
+          1
+        );
       });
       it('links back to the version home page', function () {
-        cy.get('a.back').contains('Docs')
-          .should('have.length', 1)
-          .click();
+        cy.get('a.back').contains('Docs').should('have.length', 1).click();
         // Path should be the first two segments and trailing slash in $subject
-        cy.location('pathname')
-          .should('eq', subject.replace(/^(\/[^/]+\/[^/]+\/).*/, '$1'));
+        cy.location('pathname').should(
+          'eq',
+          subject.replace(/^(\/[^/]+\/[^/]+\/).*/, '$1')
+        );
         cy.get('h1').should('have.length', 1);
       });
       it('contains valid internal links', function () {
@@ -88,8 +105,7 @@ describe('API reference content', () => {
             // cy.request doesn't show in your browser's Developer Tools
             // because the request comes from Node, not from the browser.
             cy.request($a.attr('href')).its('status').should('eq', 200);
-        });
-
+          });
         });
       });
       it('contains valid external links', function () {
@@ -109,3 +125,209 @@ describe('API reference content', () => {
     });
   });
 });
+
+/**
+ * API Reference Layout Tests
+ * Tests layout and renderer for InfluxDB 3 Core/Enterprise API documentation
+ */
+describe('API reference layout', () => {
+  // API tag pages have RapiDoc renderer
+  const layoutSubjects = [
+    '/influxdb3/core/api/v3/engine/',
+    '/influxdb3/enterprise/api/v3/engine/',
+  ];
+
+  layoutSubjects.forEach((subject) => {
+    describe(`${subject} layout`, () => {
+      beforeEach(() => {
+        cy.intercept('GET', '**', (req) => {
+          req.continue((res) => {
+            if (res.headers['content-type']?.includes('text/html')) {
+              res.body = res.body.replace(
+                /data-user-analytics-fingerprint-enabled="true"/,
+                'data-user-analytics-fingerprint-enabled="false"'
+              );
+            }
+          });
+        });
+        cy.visit(subject);
+      });
+
+      describe('Layout Structure', () => {
+        it('displays sidebar', () => {
+          cy.get('.sidebar').should('be.visible');
+        });
+
+        it('displays API content area', () => {
+          cy.get('.api-content, .content-wrapper, .article--content').should(
+            'exist'
+          );
+        });
+      });
+
+      describe('API Renderer', () => {
+        it('loads API documentation renderer', () => {
+          cy.get(
+            '.api-reference-container, rapi-doc, .api-reference-wrapper'
+          ).should('exist');
+        });
+      });
+    });
+  });
+});
+
+/**
+ * RapiDoc Mini Component Tests
+ * Tests the api-operation shortcode and RapiDoc Mini component behavior
+ */
+describe('RapiDoc Mini component', () => {
+  // Operation pages use RapiDoc Mini for single operation rendering
+  const operationPages = [
+    '/influxdb3/core/api/write/post/',
+    '/influxdb3/core/api/api/v3/write_lp/post/',
+  ];
+
+  operationPages.forEach((page) => {
+    describe(`Operation page ${page}`, () => {
+      beforeEach(() => {
+        cy.intercept('GET', '**', (req) => {
+          req.continue((res) => {
+            if (res.headers['content-type']?.includes('text/html')) {
+              res.body = res.body.replace(
+                /data-user-analytics-fingerprint-enabled="true"/,
+                'data-user-analytics-fingerprint-enabled="false"'
+              );
+            }
+          });
+        });
+        cy.visit(page);
+      });
+
+      describe('Component initialization', () => {
+        it('renders rapidoc-mini component container', () => {
+          cy.get('[data-component="rapidoc-mini"]').should('exist');
+        });
+
+        it('has data-spec-url attribute', () => {
+          cy.get('[data-component="rapidoc-mini"]')
+            .should('have.attr', 'data-spec-url')
+            .and('match', /\.ya?ml$/);
+        });
+
+        it('has data-match-paths attribute', () => {
+          cy.get('[data-component="rapidoc-mini"]')
+            .should('have.attr', 'data-match-paths')
+            .and('match', /^(get|post|put|patch|delete)\s+\//i);
+        });
+
+        it('includes machine-readable spec links', () => {
+          cy.get('link[rel="alternate"][type="application/x-yaml"]').should(
+            'exist'
+          );
+          cy.get('link[rel="alternate"][type="application/json"]').should(
+            'exist'
+          );
+        });
+      });
+
+      describe('RapiDoc element creation', () => {
+        it('creates rapi-doc-mini custom element', () => {
+          // Wait for component to initialize and create the element
+          cy.get('rapi-doc-mini', { timeout: 10000 }).should('exist');
+        });
+
+        it('rapi-doc-mini has spec-url attribute', () => {
+          cy.get('rapi-doc-mini', { timeout: 10000 })
+            .should('have.attr', 'spec-url')
+            .and('match', /\.ya?ml$/);
+        });
+
+        it('rapi-doc-mini has theme attributes', () => {
+          cy.get('rapi-doc-mini', { timeout: 10000 }).should(
+            'have.attr',
+            'theme'
+          );
+        });
+      });
+    });
+  });
+
+  describe('api-operation shortcode on example page', () => {
+    beforeEach(() => {
+      cy.intercept('GET', '**', (req) => {
+        req.continue((res) => {
+          if (res.headers['content-type']?.includes('text/html')) {
+            res.body = res.body.replace(
+              /data-user-analytics-fingerprint-enabled="true"/,
+              'data-user-analytics-fingerprint-enabled="false"'
+            );
+          }
+        });
+      });
+      cy.visit('/example/');
+    });
+
+    describe('Multiple instances', () => {
+      it('renders multiple rapidoc-mini containers', () => {
+        cy.get('[data-component="rapidoc-mini"]').should(
+          'have.length.at.least',
+          2
+        );
+      });
+
+      it('each instance has unique match-paths', () => {
+        cy.get('[data-component="rapidoc-mini"]').then(($containers) => {
+          const matchPaths = [];
+          $containers.each((_, el) => {
+            const path = el.getAttribute('data-match-paths');
+            expect(matchPaths).to.not.include(path);
+            matchPaths.push(path);
+          });
+        });
+      });
+
+      it('each instance creates its own rapi-doc-mini element', () => {
+        cy.get('rapi-doc-mini', { timeout: 10000 }).should(
+          'have.length.at.least',
+          2
+        );
+      });
+    });
+  });
+
+  describe('Theme synchronization', () => {
+    beforeEach(() => {
+      cy.intercept('GET', '**', (req) => {
+        req.continue((res) => {
+          if (res.headers['content-type']?.includes('text/html')) {
+            res.body = res.body.replace(
+              /data-user-analytics-fingerprint-enabled="true"/,
+              'data-user-analytics-fingerprint-enabled="false"'
+            );
+          }
+        });
+      });
+      cy.visit('/influxdb3/core/api/write/post/');
+    });
+
+    it('applies light theme by default', () => {
+      cy.get('rapi-doc-mini', { timeout: 10000 })
+        .should('have.attr', 'theme')
+        .and('match', /light|dark/);
+    });
+
+    it('rapi-doc-mini has background color attribute', () => {
+      cy.get('rapi-doc-mini', { timeout: 10000 }).should(
+        'have.attr',
+        'bg-color'
+      );
+    });
+
+    it('rapi-doc-mini has text color attribute', () => {
+      cy.get('rapi-doc-mini', { timeout: 10000 }).should(
+        'have.attr',
+        'text-color'
+      );
+    });
+  });
+});
diff --git a/data/article_data/influxdb/cloud-dedicated/articles.json b/data/article_data/influxdb/cloud-dedicated/articles.json
new file mode 100644
index 0000000000..2ee689c17f
--- /dev/null
+++ b/data/article_data/influxdb/cloud-dedicated/articles.json
@@ -0,0 +1,30 @@
+{
+  "articles": [
+    {
+      "path": "api/accounts/{accountId}/clusters",
+      "fields": {
+        "name": "/accounts/{accountId}/clusters",
+        "describes": [
+          "/accounts/{accountId}/clusters/{clusterId}/databases",
+          "/accounts/{accountId}/clusters/{clusterId}/databases/{databaseName}",
+          "/accounts/{accountId}/clusters/{clusterId}/databases/{databaseName}/tables",
+          "/accounts/{accountId}/clusters/{clusterId}/tokens",
+          "/accounts/{accountId}/clusters/{clusterId}/tokens/{tokenId}"
+        ],
+        "menuName": "/accounts/{accountId}/clusters",
+        "title": "/accounts/{accountId}/clusters",
+        "tags": [
+          "accounts-{accountId}",
+          "clusters"
+        ],
+        "apiTags": [
+          "Databases",
+          "Tables",
+          "Database tokens"
+        ],
+        "source": "static/openapi/influxdb-cloud-dedicated/paths/openapi-accounts-{accountId}-clusters.yaml",
+        "staticFilePath": "/openapi/influxdb-cloud-dedicated/paths/openapi-accounts-{accountId}-clusters.yaml"
+      }
+    }
+  ]
+}
\ No newline at end of file
diff --git a/data/article_data/influxdb/cloud-dedicated/articles.yml b/data/article_data/influxdb/cloud-dedicated/articles.yml
new file mode 100644
index 0000000000..e655739bf6
--- /dev/null
+++ b/data/article_data/influxdb/cloud-dedicated/articles.yml
@@ -0,0 +1,24 @@
+articles:
+  - path: api/accounts/{accountId}/clusters
+    fields:
+      name: /accounts/{accountId}/clusters
+      describes:
+        - /accounts/{accountId}/clusters/{clusterId}/databases
+        - /accounts/{accountId}/clusters/{clusterId}/databases/{databaseName}
+        - >-
+          /accounts/{accountId}/clusters/{clusterId}/databases/{databaseName}/tables
+        - /accounts/{accountId}/clusters/{clusterId}/tokens
+        - /accounts/{accountId}/clusters/{clusterId}/tokens/{tokenId}
+      menuName: /accounts/{accountId}/clusters
+      title: /accounts/{accountId}/clusters
+      tags:
+        - accounts-{accountId}
+        - clusters
+      apiTags:
+        - Databases
+        - Tables
+        - Database tokens
+      source: >-
+        static/openapi/influxdb-cloud-dedicated/paths/openapi-accounts-{accountId}-clusters.yaml
+      staticFilePath: >-
+        /openapi/influxdb-cloud-dedicated/paths/openapi-accounts-{accountId}-clusters.yaml
diff --git a/data/article_data/influxdb/cloud-v2/articles.yml b/data/article_data/influxdb/cloud-v2/articles.yml
new file mode 100644
index 0000000000..0f188ea905
--- /dev/null
+++ b/data/article_data/influxdb/cloud-v2/articles.yml
@@ -0,0 +1,499 @@
+articles:
+  - path: api/v2/authorizations
+    fields:
+      name: /api/v2/authorizations
+      describes:
+        - /api/v2/authorizations
+        - /api/v2/authorizations/{authID}
+      title: |-
+        /api/v2/authorizations
+        InfluxDB Cloud API Service
+      tags:
+        - api-v2
+        - authorizations
+      source: static/openapi/influxdb-cloud-v2/paths/ref-api-v2-authorizations.yaml
+      staticFilePath: /openapi/influxdb-cloud-v2/paths/ref-api-v2-authorizations.yaml
+  - path: api/v2/buckets
+    fields:
+      name: /api/v2/buckets
+      describes:
+        - /api/v2/buckets
+        - /api/v2/buckets/{bucketID}
+        - /api/v2/buckets/{bucketID}/labels
+        - /api/v2/buckets/{bucketID}/labels/{labelID}
+        - /api/v2/buckets/{bucketID}/members
+        - /api/v2/buckets/{bucketID}/members/{userID}
+        - /api/v2/buckets/{bucketID}/owners
+        - /api/v2/buckets/{bucketID}/owners/{userID}
+        - /api/v2/buckets/{bucketID}/schema/measurements
+        - /api/v2/buckets/{bucketID}/schema/measurements/{measurementID}
+      title: |-
+        /api/v2/buckets
+        InfluxDB Cloud API Service
+      tags:
+        - api-v2
+        - buckets
+      source: static/openapi/influxdb-cloud-v2/paths/ref-api-v2-buckets.yaml
+      staticFilePath: /openapi/influxdb-cloud-v2/paths/ref-api-v2-buckets.yaml
+  - path: api/v2/checks
+    fields:
+      name: /api/v2/checks
+      describes:
+        - /api/v2/checks
+        - /api/v2/checks/{checkID}
+        - /api/v2/checks/{checkID}/labels
+        - /api/v2/checks/{checkID}/labels/{labelID}
+        - /api/v2/checks/{checkID}/query
+      title: |-
+        /api/v2/checks
+        InfluxDB Cloud API Service
+      tags:
+        - api-v2
+        - checks
+      source: static/openapi/influxdb-cloud-v2/paths/ref-api-v2-checks.yaml
+      staticFilePath: /openapi/influxdb-cloud-v2/paths/ref-api-v2-checks.yaml
+  - path: api/v2/dashboards
+    fields:
+      name: /api/v2/dashboards
+      describes:
+        - /api/v2/dashboards
+        - /api/v2/dashboards/{dashboardID}
+        - /api/v2/dashboards/{dashboardID}/cells
+        - /api/v2/dashboards/{dashboardID}/cells/{cellID}
+        - /api/v2/dashboards/{dashboardID}/cells/{cellID}/view
+        - /api/v2/dashboards/{dashboardID}/labels
+        - /api/v2/dashboards/{dashboardID}/labels/{labelID}
+        - /api/v2/dashboards/{dashboardID}/members
+        - /api/v2/dashboards/{dashboardID}/members/{userID}
+        - /api/v2/dashboards/{dashboardID}/owners
+        - /api/v2/dashboards/{dashboardID}/owners/{userID}
+      title: |-
+        /api/v2/dashboards
+        InfluxDB Cloud API Service
+      tags:
+        - api-v2
+        - dashboards
+      source: static/openapi/influxdb-cloud-v2/paths/ref-api-v2-dashboards.yaml
+      staticFilePath: /openapi/influxdb-cloud-v2/paths/ref-api-v2-dashboards.yaml
+  - path: api/v2/dbrps
+    fields:
+      name: /api/v2/dbrps
+      describes:
+        - /api/v2/dbrps
+        - /api/v2/dbrps/{dbrpID}
+      title: |-
+        /api/v2/dbrps
+        InfluxDB Cloud API Service
+      tags:
+        - api-v2
+        - dbrps
+      source: static/openapi/influxdb-cloud-v2/paths/ref-api-v2-dbrps.yaml
+      staticFilePath: /openapi/influxdb-cloud-v2/paths/ref-api-v2-dbrps.yaml
+  - path: api/v2/delete
+    fields:
+      name: /api/v2/delete
+      describes:
+        - /api/v2/delete
+      title: |-
+        /api/v2/delete
+        InfluxDB Cloud API Service
+      tags:
+        - api-v2
+        - delete
+      source: static/openapi/influxdb-cloud-v2/paths/ref-api-v2-delete.yaml
+      staticFilePath: /openapi/influxdb-cloud-v2/paths/ref-api-v2-delete.yaml
+  - path: api/v2/flags
+    fields:
+      name: /api/v2/flags
+      describes:
+        - /api/v2/flags
+      title: |-
+        /api/v2/flags
+        InfluxDB Cloud API Service
+      tags:
+        - api-v2
+        - flags
+      source: static/openapi/influxdb-cloud-v2/paths/ref-api-v2-flags.yaml
+      staticFilePath: /openapi/influxdb-cloud-v2/paths/ref-api-v2-flags.yaml
+  - path: api/v2/labels
+    fields:
+      name: /api/v2/labels
+      describes:
+        - /api/v2/labels
+        - /api/v2/labels/{labelID}
+      title: |-
+        /api/v2/labels
+        InfluxDB Cloud API Service
+      tags:
+        - api-v2
+        - labels
+      source: static/openapi/influxdb-cloud-v2/paths/ref-api-v2-labels.yaml
+      staticFilePath: /openapi/influxdb-cloud-v2/paths/ref-api-v2-labels.yaml
+  - path: api/v2/maps
+    fields:
+      name: /api/v2/maps
+      describes:
+        - /api/v2/maps/mapToken
+      title: |-
+        /api/v2/maps
+        InfluxDB Cloud API Service
+      tags:
+        - api-v2
+        - maps
+      source: static/openapi/influxdb-cloud-v2/paths/ref-api-v2-maps.yaml
+      staticFilePath: /openapi/influxdb-cloud-v2/paths/ref-api-v2-maps.yaml
+  - path: api/v2/me
+    fields:
+      name: /api/v2/me
+      describes:
+        - /api/v2/me
+        - /api/v2/me/password
+      title: |-
+        /api/v2/me
+        InfluxDB Cloud API Service
+      tags:
+        - api-v2
+        - me
+      source: static/openapi/influxdb-cloud-v2/paths/ref-api-v2-me.yaml
+      staticFilePath: /openapi/influxdb-cloud-v2/paths/ref-api-v2-me.yaml
+  - path: api/v2/notificationEndpoints
+    fields:
+      name: /api/v2/notificationEndpoints
+      describes:
+        - /api/v2/notificationEndpoints
+        - /api/v2/notificationEndpoints/{endpointID}
+        - /api/v2/notificationEndpoints/{endpointID}/labels
+        - /api/v2/notificationEndpoints/{endpointID}/labels/{labelID}
+      title: |-
+        /api/v2/notificationEndpoints
+        InfluxDB Cloud API Service
+      tags:
+        - api-v2
+        - notificationEndpoints
+      source: >-
+        static/openapi/influxdb-cloud-v2/paths/ref-api-v2-notificationEndpoints.yaml
+      staticFilePath: /openapi/influxdb-cloud-v2/paths/ref-api-v2-notificationEndpoints.yaml
+  - path: api/v2/notificationRules
+    fields:
+      name: /api/v2/notificationRules
+      describes:
+        - /api/v2/notificationRules
+        - /api/v2/notificationRules/{ruleID}
+        - /api/v2/notificationRules/{ruleID}/labels
+        - /api/v2/notificationRules/{ruleID}/labels/{labelID}
+        - /api/v2/notificationRules/{ruleID}/query
+      title: |-
+        /api/v2/notificationRules
+        InfluxDB Cloud API Service
+      tags:
+        - api-v2
+        - notificationRules
+      source: static/openapi/influxdb-cloud-v2/paths/ref-api-v2-notificationRules.yaml
+      staticFilePath: /openapi/influxdb-cloud-v2/paths/ref-api-v2-notificationRules.yaml
+  - path: api/v2/orgs
+    fields:
+      name: /api/v2/orgs
+      describes:
+        - /api/v2/orgs
+        - /api/v2/orgs/{orgID}
+        - /api/v2/orgs/{orgID}/limits
+        - /api/v2/orgs/{orgID}/members
+        - /api/v2/orgs/{orgID}/members/{userID}
+        - /api/v2/orgs/{orgID}/owners
+        - /api/v2/orgs/{orgID}/owners/{userID}
+        - /api/v2/orgs/{orgID}/secrets
+        - /api/v2/orgs/{orgID}/secrets/delete
+        - /api/v2/orgs/{orgID}/secrets/{secretID}
+        - /api/v2/orgs/{orgID}/usage
+      title: |-
+        /api/v2/orgs
+        InfluxDB Cloud API Service
+      tags:
+        - api-v2
+        - orgs
+      source: static/openapi/influxdb-cloud-v2/paths/ref-api-v2-orgs.yaml
+      staticFilePath: /openapi/influxdb-cloud-v2/paths/ref-api-v2-orgs.yaml
+  - path: api/v2/query
+    fields:
+      name: /api/v2/query
+      describes:
+        - /api/v2/query
+        - /api/v2/query/analyze
+        - /api/v2/query/ast
+        - /api/v2/query/suggestions
+        - /api/v2/query/suggestions/{name}
+      title: |-
+        /api/v2/query
+        InfluxDB Cloud API Service
+      tags:
+        - api-v2
+        - query
+      source: static/openapi/influxdb-cloud-v2/paths/ref-api-v2-query.yaml
+      staticFilePath: /openapi/influxdb-cloud-v2/paths/ref-api-v2-query.yaml
+  - path: api/v2/resources
+    fields:
+      name: /api/v2/resources
+      describes:
+        - /api/v2/resources
+      title: |-
+        /api/v2/resources
+        InfluxDB Cloud API Service
+      tags:
+        - api-v2
+        - resources
+      source: static/openapi/influxdb-cloud-v2/paths/ref-api-v2-resources.yaml
+      staticFilePath: /openapi/influxdb-cloud-v2/paths/ref-api-v2-resources.yaml
+  - path: api/v2/scripts
+    fields:
+      name: /api/v2/scripts
+      describes:
+        - /api/v2/scripts
+        - /api/v2/scripts/{scriptID}
+        - /api/v2/scripts/{scriptID}/invoke
+        - /api/v2/scripts/{scriptID}/params
+      title: |-
+        /api/v2/scripts
+        InfluxDB Cloud API Service
+      tags:
+        - api-v2
+        - scripts
+      source: static/openapi/influxdb-cloud-v2/paths/ref-api-v2-scripts.yaml
+      staticFilePath: /openapi/influxdb-cloud-v2/paths/ref-api-v2-scripts.yaml
+  - path: api/v2/setup
+    fields:
+      name: /api/v2/setup
+      describes:
+        - /api/v2/setup
+        - /api/v2/setup/user
+      title: |-
+        /api/v2/setup
+        InfluxDB Cloud API Service
+      tags:
+        - api-v2
+        - setup
+      source: static/openapi/influxdb-cloud-v2/paths/ref-api-v2-setup.yaml
+      staticFilePath: /openapi/influxdb-cloud-v2/paths/ref-api-v2-setup.yaml
+  - path: api/v2/signin
+    fields:
+      name: /api/v2/signin
+      describes:
+        - /api/v2/signin
+      title: |-
+        /api/v2/signin
+        InfluxDB Cloud API Service
+      tags:
+        - api-v2
+        - signin
+      source: static/openapi/influxdb-cloud-v2/paths/ref-api-v2-signin.yaml
+      staticFilePath: /openapi/influxdb-cloud-v2/paths/ref-api-v2-signin.yaml
+  - path: api/v2/signout
+    fields:
+      name: /api/v2/signout
+      describes:
+        - /api/v2/signout
+      title: |-
+        /api/v2/signout
+        InfluxDB Cloud API Service
+      tags:
+        - api-v2
+        - signout
+      source: static/openapi/influxdb-cloud-v2/paths/ref-api-v2-signout.yaml
+      staticFilePath: /openapi/influxdb-cloud-v2/paths/ref-api-v2-signout.yaml
+  - path: api/v2/stacks
+    fields:
+      name: /api/v2/stacks
+      describes:
+        - /api/v2/stacks
+        - /api/v2/stacks/{stack_id}
+        - /api/v2/stacks/{stack_id}/uninstall
+      title: |-
+        /api/v2/stacks
+        InfluxDB Cloud API Service
+      tags:
+        - api-v2
+        - stacks
+      source: static/openapi/influxdb-cloud-v2/paths/ref-api-v2-stacks.yaml
+      staticFilePath: /openapi/influxdb-cloud-v2/paths/ref-api-v2-stacks.yaml
+  - path: api/v2/tasks
+    fields:
+      name: /api/v2/tasks
+      describes:
+        - /api/v2/tasks
+        - /api/v2/tasks/{taskID}
+        - /api/v2/tasks/{taskID}/labels
+        - /api/v2/tasks/{taskID}/labels/{labelID}
+        - /api/v2/tasks/{taskID}/logs
+        - /api/v2/tasks/{taskID}/members
+        - /api/v2/tasks/{taskID}/members/{userID}
+        - /api/v2/tasks/{taskID}/owners
+        - /api/v2/tasks/{taskID}/owners/{userID}
+        - /api/v2/tasks/{taskID}/runs
+        - /api/v2/tasks/{taskID}/runs/{runID}
+        - /api/v2/tasks/{taskID}/runs/{runID}/logs
+        - /api/v2/tasks/{taskID}/runs/{runID}/retry
+      title: |-
+        /api/v2/tasks
+        InfluxDB Cloud API Service
+      tags:
+        - api-v2
+        - tasks
+      source: static/openapi/influxdb-cloud-v2/paths/ref-api-v2-tasks.yaml
+      staticFilePath: /openapi/influxdb-cloud-v2/paths/ref-api-v2-tasks.yaml
+  - path: api/v2/telegraf
+    fields:
+      name: /api/v2/telegraf
+      describes:
+        - /api/v2/telegraf/plugins
+      title: |-
+        /api/v2/telegraf
+        InfluxDB Cloud API Service
+      tags:
+        - api-v2
+        - telegraf
+      source: static/openapi/influxdb-cloud-v2/paths/ref-api-v2-telegraf.yaml
+      staticFilePath: /openapi/influxdb-cloud-v2/paths/ref-api-v2-telegraf.yaml
+  - path: api/v2/telegrafs
+    fields:
+      name: /api/v2/telegrafs
+      describes:
+        - /api/v2/telegrafs
+        - /api/v2/telegrafs/{telegrafID}
+        - /api/v2/telegrafs/{telegrafID}/labels
+        - /api/v2/telegrafs/{telegrafID}/labels/{labelID}
+        - /api/v2/telegrafs/{telegrafID}/members
+        - /api/v2/telegrafs/{telegrafID}/members/{userID}
+        - /api/v2/telegrafs/{telegrafID}/owners
+        - /api/v2/telegrafs/{telegrafID}/owners/{userID}
+      title: |-
+        /api/v2/telegrafs
+        InfluxDB Cloud API Service
+      tags:
+        - api-v2
+        - telegrafs
+      source: static/openapi/influxdb-cloud-v2/paths/ref-api-v2-telegrafs.yaml
+      staticFilePath: /openapi/influxdb-cloud-v2/paths/ref-api-v2-telegrafs.yaml
+  - path: api/v2/templates
+    fields:
+      name: /api/v2/templates
+      describes:
+        - /api/v2/templates/apply
+        - /api/v2/templates/export
+      title: |-
+        /api/v2/templates
+        InfluxDB Cloud API Service
+      tags:
+        - api-v2
+        - templates
+      source: static/openapi/influxdb-cloud-v2/paths/ref-api-v2-templates.yaml
+      staticFilePath: /openapi/influxdb-cloud-v2/paths/ref-api-v2-templates.yaml
+  - path: api/v2/users
+    fields:
+      name: /api/v2/users
+      describes:
+        - /api/v2/users
+        - /api/v2/users/{userID}
+        - /api/v2/users/{userID}/password
+      title: |-
+        /api/v2/users
+        InfluxDB Cloud API Service
+      tags:
+        - api-v2
+        - users
+      source: static/openapi/influxdb-cloud-v2/paths/ref-api-v2-users.yaml
+      staticFilePath: /openapi/influxdb-cloud-v2/paths/ref-api-v2-users.yaml
+  - path: api/v2/variables
+    fields:
+      name: /api/v2/variables
+      describes:
+        - /api/v2/variables
+        - /api/v2/variables/{variableID}
+        - /api/v2/variables/{variableID}/labels
+        - /api/v2/variables/{variableID}/labels/{labelID}
+      title: |-
+        /api/v2/variables
+        InfluxDB Cloud API Service
+      tags:
+        - api-v2
+        - variables
+      source: static/openapi/influxdb-cloud-v2/paths/ref-api-v2-variables.yaml
+      staticFilePath: /openapi/influxdb-cloud-v2/paths/ref-api-v2-variables.yaml
+  - path: api/v2/write
+    fields:
+      name: /api/v2/write
+      describes:
+        - /api/v2/write
+      title: |-
+        /api/v2/write
+        InfluxDB Cloud API Service
+      tags:
+        - api-v2
+        - write
+      source: static/openapi/influxdb-cloud-v2/paths/ref-api-v2-write.yaml
+      staticFilePath: /openapi/influxdb-cloud-v2/paths/ref-api-v2-write.yaml
+  - path: api/v2
+    fields:
+      name: /api/v2
+      describes:
+        - /api/v2
+      title: |-
+        /api/v2
+        InfluxDB Cloud API Service
+      tags:
+        - api
+        - v2
+      source: static/openapi/influxdb-cloud-v2/paths/ref-api-v2.yaml
+      staticFilePath: /openapi/influxdb-cloud-v2/paths/ref-api-v2.yaml
+  - path: legacy/authorizations
+    fields:
+      name: /legacy/authorizations
+      describes:
+        - /legacy/authorizations
+        - /legacy/authorizations/{authID}
+        - /legacy/authorizations/{authID}/password
+      title: |-
+        /legacy/authorizations
+        InfluxDB Cloud API Service
+      tags:
+        - legacy
+        - authorizations
+      source: static/openapi/influxdb-cloud-v2/paths/ref-legacy-authorizations.yaml
+      staticFilePath: /openapi/influxdb-cloud-v2/paths/ref-legacy-authorizations.yaml
+  - path: ping
+    fields:
+      name: /ping
+      describes:
+        - /ping
+      title: |-
+        /ping
+        InfluxDB Cloud API Service
+      tags:
+        - ''
+        - ping
+      source: static/openapi/influxdb-cloud-v2/paths/ref-ping.yaml
+      staticFilePath: /openapi/influxdb-cloud-v2/paths/ref-ping.yaml
+  - path: query
+    fields:
+      name: /query
+      describes:
+        - /query
+      title: |-
+        /query
+        InfluxDB Cloud API Service
+      tags:
+        - ''
+        - query
+      source: static/openapi/influxdb-cloud-v2/paths/ref-query.yaml
+      staticFilePath: /openapi/influxdb-cloud-v2/paths/ref-query.yaml
+  - path: write
+    fields:
+      name: /write
+      describes:
+        - /write
+      title: |-
+        /write
+        InfluxDB Cloud API Service
+      tags:
+        - ''
+        - write
+      source: static/openapi/influxdb-cloud-v2/paths/ref-write.yaml
+      staticFilePath: /openapi/influxdb-cloud-v2/paths/ref-write.yaml
diff --git a/data/article_data/influxdb/clustered/articles.json b/data/article_data/influxdb/clustered/articles.json
new file mode 100644
index 0000000000..edb580a8c6
--- /dev/null
+++ b/data/article_data/influxdb/clustered/articles.json
@@ -0,0 +1,66 @@
+{
+  "articles": [
+    {
+      "path": "api/databases/{databaseName}/tables",
+      "fields": {
+        "name": "/databases/{databaseName}/tables",
+        "describes": [
+          "/databases/{databaseName}/tables"
+        ],
+        "menuName": "/databases/{databaseName}/tables",
+        "title": "/databases/{databaseName}/tables",
+        "tags": [
+          "databases-{databaseName}",
+          "tables"
+        ],
+        "apiTags": [
+          "Tables"
+        ],
+        "source": "static/openapi/influxdb-clustered/paths/openapi-databases-{databaseName}-tables.yaml",
+        "staticFilePath": "/openapi/influxdb-clustered/paths/openapi-databases-{databaseName}-tables.yaml"
+      }
+    },
+    {
+      "path": "api/databases",
+      "fields": {
+        "name": "/databases",
+        "describes": [
+          "/databases",
+          "/databases/{databaseName}"
+        ],
+        "menuName": "/databases",
+        "title": "/databases",
+        "tags": [
+          "",
+          "databases"
+        ],
+        "apiTags": [
+          "Databases"
+        ],
+        "source": "static/openapi/influxdb-clustered/paths/openapi-databases.yaml",
+        "staticFilePath": "/openapi/influxdb-clustered/paths/openapi-databases.yaml"
+      }
+    },
+    {
+      "path": "api/tokens",
+      "fields": {
+        "name": "/tokens",
+        "describes": [
+          "/tokens",
+          "/tokens/{tokenId}"
+        ],
+        "menuName": "/tokens",
+        "title": "/tokens",
+        "tags": [
+          "",
+          "tokens"
+        ],
+        "apiTags": [
+          "Database tokens"
+        ],
+        "source": "static/openapi/influxdb-clustered/paths/openapi-tokens.yaml",
+        "staticFilePath": "/openapi/influxdb-clustered/paths/openapi-tokens.yaml"
+      }
+    }
+  ]
+}
\ No newline at end of file
diff --git a/data/article_data/influxdb/clustered/articles.yml b/data/article_data/influxdb/clustered/articles.yml
new file mode 100644
index 0000000000..b2d6347131
--- /dev/null
+++ b/data/article_data/influxdb/clustered/articles.yml
@@ -0,0 +1,47 @@
+articles:
+  - path: api/databases/{databaseName}/tables
+    fields:
+      name: /databases/{databaseName}/tables
+      describes:
+        - /databases/{databaseName}/tables
+      menuName: /databases/{databaseName}/tables
+      title: /databases/{databaseName}/tables
+      tags:
+        - databases-{databaseName}
+        - tables
+      apiTags:
+        - Tables
+      source: >-
+        static/openapi/influxdb-clustered/paths/openapi-databases-{databaseName}-tables.yaml
+      staticFilePath: >-
+        /openapi/influxdb-clustered/paths/openapi-databases-{databaseName}-tables.yaml
+  - path: api/databases
+    fields:
+      name: /databases
+      describes:
+        - /databases
+        - /databases/{databaseName}
+      menuName: /databases
+      title: /databases
+      tags:
+        - ''
+        - databases
+      apiTags:
+        - Databases
+      source: static/openapi/influxdb-clustered/paths/openapi-databases.yaml
+      staticFilePath: /openapi/influxdb-clustered/paths/openapi-databases.yaml
+  - path: api/tokens
+    fields:
+      name: /tokens
+      describes:
+        - /tokens
+        - /tokens/{tokenId}
+      menuName: /tokens
+      title: /tokens
+      tags:
+        - ''
+        - tokens
+      apiTags:
+        - Database tokens
+      source: static/openapi/influxdb-clustered/paths/openapi-tokens.yaml
+      staticFilePath: /openapi/influxdb-clustered/paths/openapi-tokens.yaml
diff --git a/data/article_data/influxdb/influxdb3_core/articles.json b/data/article_data/influxdb/influxdb3_core/articles.json
new file mode 100644
index 0000000000..ff6c0f9c0e
--- /dev/null
+++ b/data/article_data/influxdb/influxdb3_core/articles.json
@@ -0,0 +1,661 @@
+{
+  "articles": [
+    {
+      "path": "api/auth-token",
+      "fields": {
+        "name": "Auth token",
+        "describes": [
+          "/api/v3/configure/token/admin",
+          "/api/v3/configure/token/admin/regenerate",
+          "/api/v3/configure/token",
+          "/api/v3/configure/token/named_admin"
+        ],
+        "title": "Auth token",
+        "description": "Manage tokens for authentication and authorization",
+        "tag": "Auth token",
+        "isConceptual": false,
+        "menuGroup": "Other",
+        "operations": [
+          {
+            "operationId": "PostCreateAdminToken",
+            "method": "POST",
+            "path": "/api/v3/configure/token/admin",
+            "summary": "Create admin token",
+            "tags": [
+              "Auth token"
+            ]
+          },
+          {
+            "operationId": "PostRegenerateAdminToken",
+            "method": "POST",
+            "path": "/api/v3/configure/token/admin/regenerate",
+            "summary": "Regenerate admin token",
+            "tags": [
+              "Auth token"
+            ]
+          },
+          {
+            "operationId": "DeleteToken",
+            "method": "DELETE",
+            "path": "/api/v3/configure/token",
+            "summary": "Delete token",
+            "tags": [
+              "Auth token"
+            ]
+          },
+          {
+            "operationId": "PostCreateNamedAdminToken",
+            "method": "POST",
+            "path": "/api/v3/configure/token/named_admin",
+            "summary": "Create named admin token",
+            "tags": [
+              "Auth token"
+            ]
+          }
+        ],
+        "tagDescription": "Manage tokens for authentication and authorization",
+        "source": "static/openapi/influxdb3-core/tags/tags/ref-auth-token.yaml",
+        "staticFilePath": "/openapi/influxdb3-core/tags/tags/ref-auth-token.yaml"
+      }
+    },
+    {
+      "path": "api/authentication",
+      "fields": {
+        "name": "Authentication",
+        "describes": [
+          "/api/v3/configure/token/admin",
+          "/api/v3/configure/token/admin/regenerate",
+          "/api/v3/configure/token",
+          "/api/v3/configure/token/named_admin"
+        ],
+        "title": "Authentication",
+        "description": "Depending on your workflow, use one of the following schemes to authenticate to the InfluxDB 3 API:\n\n| Authentication scheme | Works with |\n|:----------------------|:-----------|\n| Bearer authentication | All endpoints |\n| Token authentication  | v1, v2 endpoints |\n| Basic authentication  | v1 endpoints |\n| Querystring authentication | v1 endpoints |\n\nSee the **Security Schemes** section below for details on each authentication method.\n",
+        "tag": "Authentication",
+        "isConceptual": true,
+        "menuGroup": "Concepts",
+        "operations": [
+          {
+            "operationId": "PostCreateAdminToken",
+            "method": "POST",
+            "path": "/api/v3/configure/token/admin",
+            "summary": "Create admin token",
+            "tags": [
+              "Authentication"
+            ]
+          },
+          {
+            "operationId": "PostRegenerateAdminToken",
+            "method": "POST",
+            "path": "/api/v3/configure/token/admin/regenerate",
+            "summary": "Regenerate admin token",
+            "tags": [
+              "Authentication"
+            ]
+          },
+          {
+            "operationId": "DeleteToken",
+            "method": "DELETE",
+            "path": "/api/v3/configure/token",
+            "summary": "Delete token",
+            "tags": [
+              "Authentication"
+            ]
+          },
+          {
+            "operationId": "PostCreateNamedAdminToken",
+            "method": "POST",
+            "path": "/api/v3/configure/token/named_admin",
+            "summary": "Create named admin token",
+            "tags": [
+              "Authentication"
+            ]
+          }
+        ],
+        "tagDescription": "Depending on your workflow, use one of the following schemes to authenticate to the InfluxDB 3 API:\n\n| Authentication scheme | Works with |\n|:----------------------|:-----------|\n| Bearer authentication | All endpoints |\n| Token authentication  | v1, v2 endpoints |\n| Basic authentication  | v1 endpoints |\n| Querystring authentication | v1 endpoints |\n\nSee the **Security Schemes** section below for details on each authentication method.\n",
+        "source": "static/openapi/influxdb3-core/tags/tags/ref-authentication.yaml",
+        "staticFilePath": "/openapi/influxdb3-core/tags/tags/ref-authentication.yaml"
+      }
+    },
+    {
+      "path": "api/cache-data",
+      "fields": {
+        "name": "Cache data",
+        "describes": [
+          "/api/v3/configure/distinct_cache",
+          "/api/v3/configure/last_cache"
+        ],
+        "title": "Cache data",
+        "description": "Manage the in-memory cache.\n\n#### Distinct Value Cache\n\nThe Distinct Value Cache (DVC) lets you cache distinct\nvalues of one or more columns in a table, improving the performance of\nqueries that return distinct tag and field values. \n\nThe DVC is an in-memory cache that stores distinct values for specific columns\nin a table. When you create an DVC, you can specify what columns' distinct\nvalues to cache, the maximum number of distinct value combinations to cache, and\nthe maximum age of cached values. A DVC is associated with a table, which can\nhave multiple DVCs.\n\n#### Last value cache\n\nThe Last Value Cache (LVC) lets you cache the most recent\nvalues for specific fields in a table, improving the performance of queries that\nreturn the most recent value of a field for specific series or the last N values\nof a field.\n\nThe LVC is an in-memory cache that stores the last N number of values for\nspecific fields of series in a table. When you create an LVC, you can specify\nwhat fields to cache, what tags to use to identify each series, and the\nnumber of values to cache for each unique series.\nAn LVC is associated with a table, which can have multiple LVCs.\n\n#### Related guides\n\n- [Manage the Distinct Value Cache](/influxdb3/core/admin/distinct-value-cache/)\n- [Manage the Last Value Cache](/influxdb3/core/admin/last-value-cache/)\n",
+        "tag": "Cache data",
+        "isConceptual": false,
+        "menuGroup": "Data Operations",
+        "operations": [
+          {
+            "operationId": "PostConfigureDistinctCache",
+            "method": "POST",
+            "path": "/api/v3/configure/distinct_cache",
+            "summary": "Create distinct cache",
+            "tags": [
+              "Cache data"
+            ]
+          },
+          {
+            "operationId": "DeleteConfigureDistinctCache",
+            "method": "DELETE",
+            "path": "/api/v3/configure/distinct_cache",
+            "summary": "Delete distinct cache",
+            "tags": [
+              "Cache data"
+            ]
+          },
+          {
+            "operationId": "PostConfigureLastCache",
+            "method": "POST",
+            "path": "/api/v3/configure/last_cache",
+            "summary": "Create last cache",
+            "tags": [
+              "Cache data"
+            ]
+          },
+          {
+            "operationId": "DeleteConfigureLastCache",
+            "method": "DELETE",
+            "path": "/api/v3/configure/last_cache",
+            "summary": "Delete last cache",
+            "tags": [
+              "Cache data"
+            ]
+          }
+        ],
+        "tagDescription": "Manage the in-memory cache.\n\n#### Distinct Value Cache\n\nThe Distinct Value Cache (DVC) lets you cache distinct\nvalues of one or more columns in a table, improving the performance of\nqueries that return distinct tag and field values. \n\nThe DVC is an in-memory cache that stores distinct values for specific columns\nin a table. When you create an DVC, you can specify what columns' distinct\nvalues to cache, the maximum number of distinct value combinations to cache, and\nthe maximum age of cached values. A DVC is associated with a table, which can\nhave multiple DVCs.\n\n#### Last value cache\n\nThe Last Value Cache (LVC) lets you cache the most recent\nvalues for specific fields in a table, improving the performance of queries that\nreturn the most recent value of a field for specific series or the last N values\nof a field.\n\nThe LVC is an in-memory cache that stores the last N number of values for\nspecific fields of series in a table. When you create an LVC, you can specify\nwhat fields to cache, what tags to use to identify each series, and the\nnumber of values to cache for each unique series.\nAn LVC is associated with a table, which can have multiple LVCs.\n\n#### Related guides\n\n- [Manage the Distinct Value Cache](/influxdb3/core/admin/distinct-value-cache/)\n- [Manage the Last Value Cache](/influxdb3/core/admin/last-value-cache/)\n",
+        "source": "static/openapi/influxdb3-core/tags/tags/ref-cache-data.yaml",
+        "staticFilePath": "/openapi/influxdb3-core/tags/tags/ref-cache-data.yaml"
+      }
+    },
+    {
+      "path": "api/database",
+      "fields": {
+        "name": "Database",
+        "describes": [
+          "/api/v3/configure/database",
+          "/api/v3/configure/database/retention_period"
+        ],
+        "title": "Database",
+        "description": "Manage databases",
+        "tag": "Database",
+        "isConceptual": false,
+        "menuGroup": "Administration",
+        "operations": [
+          {
+            "operationId": "GetConfigureDatabase",
+            "method": "GET",
+            "path": "/api/v3/configure/database",
+            "summary": "List databases",
+            "tags": [
+              "Database"
+            ]
+          },
+          {
+            "operationId": "PostConfigureDatabase",
+            "method": "POST",
+            "path": "/api/v3/configure/database",
+            "summary": "Create a database",
+            "tags": [
+              "Database"
+            ]
+          },
+          {
+            "operationId": "DeleteConfigureDatabase",
+            "method": "DELETE",
+            "path": "/api/v3/configure/database",
+            "summary": "Delete a database",
+            "tags": [
+              "Database"
+            ]
+          },
+          {
+            "operationId": "DeleteDatabaseRetentionPeriod",
+            "method": "DELETE",
+            "path": "/api/v3/configure/database/retention_period",
+            "summary": "Remove database retention period",
+            "tags": [
+              "Database"
+            ]
+          }
+        ],
+        "tagDescription": "Manage databases",
+        "source": "static/openapi/influxdb3-core/tags/tags/ref-database.yaml",
+        "staticFilePath": "/openapi/influxdb3-core/tags/tags/ref-database.yaml"
+      }
+    },
+    {
+      "path": "api/headers-and-parameters",
+      "fields": {
+        "name": "Headers and parameters",
+        "describes": [],
+        "title": "Headers and parameters",
+        "description": "Most InfluxDB API endpoints require parameters in the request--for example, specifying the database to use.\n\n### Common parameters\n\nThe following table shows common parameters used by many InfluxDB API endpoints.\nMany endpoints may require other parameters in the query string or in the\nrequest body that perform functions specific to those endpoints.\n\n| Query parameter          | Value type            | Description                                |\n|:------------------------ |:--------------------- |:-------------------------------------------|\n| `db`                 | string                | The database name |\n\nInfluxDB HTTP API endpoints use standard HTTP request and response headers.\nThe following table shows common headers used by many InfluxDB API endpoints.\nSome endpoints may use other headers that perform functions more specific to those endpoints--for example,\nthe write endpoints accept the `Content-Encoding` header to indicate that line protocol is compressed in the request body.\n\n| Header                   | Value type            | Description                                |\n|:------------------------ |:--------------------- |:-------------------------------------------|\n| `Accept`                 | string                | The content type that the client can understand. |\n| `Authorization`          | string                | The authorization scheme and credential. |\n| `Content-Length`         | integer               | The size of the entity-body, in bytes. |\n| `Content-Type`           | string                | The format of the data in the request body. |\n",
+        "tag": "Headers and parameters",
+        "isConceptual": true,
+        "menuGroup": "Concepts",
+        "operations": [],
+        "tagDescription": "Most InfluxDB API endpoints require parameters in the request--for example, specifying the database to use.\n\n### Common parameters\n\nThe following table shows common parameters used by many InfluxDB API endpoints.\nMany endpoints may require other parameters in the query string or in the\nrequest body that perform functions specific to those endpoints.\n\n| Query parameter          | Value type            | Description                                |\n|:------------------------ |:--------------------- |:-------------------------------------------|\n| `db`                 | string                | The database name |\n\nInfluxDB HTTP API endpoints use standard HTTP request and response headers.\nThe following table shows common headers used by many InfluxDB API endpoints.\nSome endpoints may use other headers that perform functions more specific to those endpoints--for example,\nthe write endpoints accept the `Content-Encoding` header to indicate that line protocol is compressed in the request body.\n\n| Header                   | Value type            | Description                                |\n|:------------------------ |:--------------------- |:-------------------------------------------|\n| `Accept`                 | string                | The content type that the client can understand. |\n| `Authorization`          | string                | The authorization scheme and credential. |\n| `Content-Length`         | integer               | The size of the entity-body, in bytes. |\n| `Content-Type`           | string                | The format of the data in the request body. |\n",
+        "source": "static/openapi/influxdb3-core/tags/tags/ref-headers-and-parameters.yaml",
+        "staticFilePath": "/openapi/influxdb3-core/tags/tags/ref-headers-and-parameters.yaml"
+      }
+    },
+    {
+      "path": "api/migrate-from-influxdb-v1-or-v2",
+      "fields": {
+        "name": "Migrate from InfluxDB v1 or v2",
+        "describes": [],
+        "title": "Migrate from InfluxDB v1 or v2",
+        "description": "Migrate your existing InfluxDB v1 or v2 workloads to InfluxDB 3.\n\nInfluxDB 3 provides compatibility endpoints that work with InfluxDB 1.x and 2.x client libraries and tools.\nOperations marked with <span class=\"api-compat-badge api-compat-badge--v1\">v1</span> or <span class=\"api-compat-badge api-compat-badge--v2\">v2</span> badges are compatible with the respective InfluxDB version.\n\n### Migration guides\n\n- [Migrate from InfluxDB v1](/influxdb3/core/guides/migrate/influxdb-1x/) - For users migrating from InfluxDB 1.x\n- [Migrate from InfluxDB v2](/influxdb3/core/guides/migrate/influxdb-2x/) - For users migrating from InfluxDB 2.x or Cloud\n- [Use compatibility APIs to write data](/influxdb3/core/write-data/http-api/compatibility-apis/) - v1 and v2 write endpoints\n- [Use the v1 HTTP query API](/influxdb3/core/query-data/execute-queries/influxdb-v1-api/) - InfluxQL queries via HTTP\n",
+        "tag": "Migrate from InfluxDB v1 or v2",
+        "isConceptual": true,
+        "menuGroup": "Other",
+        "operations": [],
+        "tagDescription": "Migrate your existing InfluxDB v1 or v2 workloads to InfluxDB 3.\n\nInfluxDB 3 provides compatibility endpoints that work with InfluxDB 1.x and 2.x client libraries and tools.\nOperations marked with <span class=\"api-compat-badge api-compat-badge--v1\">v1</span> or <span class=\"api-compat-badge api-compat-badge--v2\">v2</span> badges are compatible with the respective InfluxDB version.\n\n### Migration guides\n\n- [Migrate from InfluxDB v1](/influxdb3/core/guides/migrate/influxdb-1x/) - For users migrating from InfluxDB 1.x\n- [Migrate from InfluxDB v2](/influxdb3/core/guides/migrate/influxdb-2x/) - For users migrating from InfluxDB 2.x or Cloud\n- [Use compatibility APIs to write data](/influxdb3/core/write-data/http-api/compatibility-apis/) - v1 and v2 write endpoints\n- [Use the v1 HTTP query API](/influxdb3/core/query-data/execute-queries/influxdb-v1-api/) - InfluxQL queries via HTTP\n",
+        "source": "static/openapi/influxdb3-core/tags/tags/ref-migrate-from-influxdb-v1-or-v2.yaml",
+        "staticFilePath": "/openapi/influxdb3-core/tags/tags/ref-migrate-from-influxdb-v1-or-v2.yaml"
+      }
+    },
+    {
+      "path": "api/processing-engine",
+      "fields": {
+        "name": "Processing engine",
+        "describes": [
+          "/api/v3/configure/processing_engine_trigger",
+          "/api/v3/configure/processing_engine_trigger/disable",
+          "/api/v3/configure/processing_engine_trigger/enable",
+          "/api/v3/configure/plugin_environment/install_packages",
+          "/api/v3/configure/plugin_environment/install_requirements",
+          "/api/v3/plugin_test/wal",
+          "/api/v3/plugin_test/schedule",
+          "/api/v3/engine/{request_path}",
+          "/api/v3/plugins/files",
+          "/api/v3/plugins/directory"
+        ],
+        "title": "Processing engine",
+        "description": "Manage Processing engine triggers, test plugins, and send requests to trigger On Request plugins.\n\nInfluxDB 3 Core provides the InfluxDB 3 processing engine, an embedded Python VM that can dynamically load and trigger Python plugins in response to events in your database.\nUse Processing engine plugins and triggers to run code and perform tasks for different database events.\n\nTo get started with the processing engine, see the [Processing engine and Python plugins](/influxdb3/core/processing-engine/) guide.\n",
+        "tag": "Processing engine",
+        "isConceptual": false,
+        "menuGroup": "Processing Engine",
+        "operations": [
+          {
+            "operationId": "PostConfigureProcessingEngineTrigger",
+            "method": "POST",
+            "path": "/api/v3/configure/processing_engine_trigger",
+            "summary": "Create processing engine trigger",
+            "tags": [
+              "Processing engine"
+            ]
+          },
+          {
+            "operationId": "DeleteConfigureProcessingEngineTrigger",
+            "method": "DELETE",
+            "path": "/api/v3/configure/processing_engine_trigger",
+            "summary": "Delete processing engine trigger",
+            "tags": [
+              "Processing engine"
+            ]
+          },
+          {
+            "operationId": "PostDisableProcessingEngineTrigger",
+            "method": "POST",
+            "path": "/api/v3/configure/processing_engine_trigger/disable",
+            "summary": "Disable processing engine trigger",
+            "tags": [
+              "Processing engine"
+            ]
+          },
+          {
+            "operationId": "PostEnableProcessingEngineTrigger",
+            "method": "POST",
+            "path": "/api/v3/configure/processing_engine_trigger/enable",
+            "summary": "Enable processing engine trigger",
+            "tags": [
+              "Processing engine"
+            ]
+          },
+          {
+            "operationId": "PostInstallPluginPackages",
+            "method": "POST",
+            "path": "/api/v3/configure/plugin_environment/install_packages",
+            "summary": "Install plugin packages",
+            "tags": [
+              "Processing engine"
+            ]
+          },
+          {
+            "operationId": "PostInstallPluginRequirements",
+            "method": "POST",
+            "path": "/api/v3/configure/plugin_environment/install_requirements",
+            "summary": "Install plugin requirements",
+            "tags": [
+              "Processing engine"
+            ]
+          },
+          {
+            "operationId": "PostTestWALPlugin",
+            "method": "POST",
+            "path": "/api/v3/plugin_test/wal",
+            "summary": "Test WAL plugin",
+            "tags": [
+              "Processing engine"
+            ]
+          },
+          {
+            "operationId": "PostTestSchedulingPlugin",
+            "method": "POST",
+            "path": "/api/v3/plugin_test/schedule",
+            "summary": "Test scheduling plugin",
+            "tags": [
+              "Processing engine"
+            ]
+          },
+          {
+            "operationId": "GetProcessingEnginePluginRequest",
+            "method": "GET",
+            "path": "/api/v3/engine/{request_path}",
+            "summary": "On Request processing engine plugin request",
+            "tags": [
+              "Processing engine"
+            ]
+          },
+          {
+            "operationId": "PostProcessingEnginePluginRequest",
+            "method": "POST",
+            "path": "/api/v3/engine/{request_path}",
+            "summary": "On Request processing engine plugin request",
+            "tags": [
+              "Processing engine"
+            ]
+          },
+          {
+            "operationId": "PutPluginFile",
+            "method": "PUT",
+            "path": "/api/v3/plugins/files",
+            "summary": "Update plugin file",
+            "tags": [
+              "Processing engine"
+            ]
+          },
+          {
+            "operationId": "PutPluginDirectory",
+            "method": "PUT",
+            "path": "/api/v3/plugins/directory",
+            "summary": "Update plugin directory",
+            "tags": [
+              "Processing engine"
+            ]
+          }
+        ],
+        "tagDescription": "Manage Processing engine triggers, test plugins, and send requests to trigger On Request plugins.\n\nInfluxDB 3 Core provides the InfluxDB 3 processing engine, an embedded Python VM that can dynamically load and trigger Python plugins in response to events in your database.\nUse Processing engine plugins and triggers to run code and perform tasks for different database events.\n\nTo get started with the processing engine, see the [Processing engine and Python plugins](/influxdb3/core/processing-engine/) guide.\n",
+        "source": "static/openapi/influxdb3-core/tags/tags/ref-processing-engine.yaml",
+        "staticFilePath": "/openapi/influxdb3-core/tags/tags/ref-processing-engine.yaml"
+      }
+    },
+    {
+      "path": "api/query-data",
+      "fields": {
+        "name": "Query data",
+        "describes": [
+          "/api/v3/query_sql",
+          "/api/v3/query_influxql",
+          "/query"
+        ],
+        "title": "Query data",
+        "description": "Query data using SQL or InfluxQL",
+        "tag": "Query data",
+        "isConceptual": false,
+        "menuGroup": "Data Operations",
+        "operations": [
+          {
+            "operationId": "GetExecuteQuerySQL",
+            "method": "GET",
+            "path": "/api/v3/query_sql",
+            "summary": "Execute SQL query",
+            "tags": [
+              "Query data"
+            ]
+          },
+          {
+            "operationId": "PostExecuteQuerySQL",
+            "method": "POST",
+            "path": "/api/v3/query_sql",
+            "summary": "Execute SQL query",
+            "tags": [
+              "Query data"
+            ]
+          },
+          {
+            "operationId": "GetExecuteInfluxQLQuery",
+            "method": "GET",
+            "path": "/api/v3/query_influxql",
+            "summary": "Execute InfluxQL query",
+            "tags": [
+              "Query data"
+            ]
+          },
+          {
+            "operationId": "PostExecuteQueryInfluxQL",
+            "method": "POST",
+            "path": "/api/v3/query_influxql",
+            "summary": "Execute InfluxQL query",
+            "tags": [
+              "Query data"
+            ]
+          },
+          {
+            "operationId": "GetV1ExecuteQuery",
+            "method": "GET",
+            "path": "/query",
+            "summary": "Execute InfluxQL query (v1-compatible)",
+            "tags": [
+              "Query data"
+            ],
+            "compatVersion": "v1",
+            "externalDocs": {
+              "description": "Use the InfluxDB v1 HTTP query API and InfluxQL to query data",
+              "url": "/influxdb3/core/query-data/execute-queries/influxdb-v1-api/"
+            }
+          },
+          {
+            "operationId": "PostExecuteV1Query",
+            "method": "POST",
+            "path": "/query",
+            "summary": "Execute InfluxQL query (v1-compatible)",
+            "tags": [
+              "Query data"
+            ],
+            "compatVersion": "v1",
+            "externalDocs": {
+              "description": "Use the InfluxDB v1 HTTP query API and InfluxQL to query data",
+              "url": "/influxdb3/core/query-data/execute-queries/influxdb-v1-api/"
+            }
+          }
+        ],
+        "tagDescription": "Query data using SQL or InfluxQL",
+        "related": [
+          "/influxdb3/core/query-data/execute-queries/influxdb-v1-api/"
+        ],
+        "source": "static/openapi/influxdb3-core/tags/tags/ref-query-data.yaml",
+        "staticFilePath": "/openapi/influxdb3-core/tags/tags/ref-query-data.yaml"
+      }
+    },
+    {
+      "path": "api/quick-start",
+      "fields": {
+        "name": "Quick start",
+        "describes": [],
+        "title": "Quick start",
+        "description": "1. [Create an admin token](#section/Authentication) to authorize API requests.\n\n   ```bash\n   curl -X POST \"http://localhost:8181/api/v3/configure/token/admin\"\n   ```\n2. [Check the status](#section/Server-information) of the InfluxDB server.\n\n   ```bash\n   curl \"http://localhost:8181/health\" \\\n      --header \"Authorization: Bearer ADMIN_TOKEN\"\n   ```\n\n3. [Write data](#operation/PostWriteLP) to InfluxDB.\n\n   ```bash\n   curl \"http://localhost:8181/api/v3/write_lp?db=sensors&precision=auto\"\n     --header \"Authorization: Bearer ADMIN_TOKEN\" \\\n     --data-raw \"home,room=Kitchen temp=72.0\n    home,room=Living\\ room temp=71.5\"\n   ```\n\n   If all data is written, the response is `204 No Content`.\n\n4. [Query data](#operation/GetExecuteQuerySQL) from InfluxDB.\n\n   ```bash\n   curl -G \"http://localhost:8181/api/v3/query_sql\" \\\n     --header \"Authorization: Bearer ADMIN_TOKEN\" \\\n     --data-urlencode \"db=sensors\" \\\n     --data-urlencode \"q=SELECT * FROM home WHERE room='Living room'\" \\\n     --data-urlencode \"format=jsonl\"\n   ```\n   \n   Output:\n\n   ```jsonl\n   {\"room\":\"Living room\",\"temp\":71.5,\"time\":\"2025-02-25T20:19:34.984098\"}\n   ```\n  \nFor more information about using InfluxDB 3 Core, see the [Get started](/influxdb3/core/get-started/) guide.\n",
+        "tag": "Quick start",
+        "isConceptual": true,
+        "menuGroup": "Concepts",
+        "operations": [],
+        "tagDescription": "1. [Create an admin token](#section/Authentication) to authorize API requests.\n\n   ```bash\n   curl -X POST \"http://localhost:8181/api/v3/configure/token/admin\"\n   ```\n2. [Check the status](#section/Server-information) of the InfluxDB server.\n\n   ```bash\n   curl \"http://localhost:8181/health\" \\\n      --header \"Authorization: Bearer ADMIN_TOKEN\"\n   ```\n\n3. [Write data](#operation/PostWriteLP) to InfluxDB.\n\n   ```bash\n   curl \"http://localhost:8181/api/v3/write_lp?db=sensors&precision=auto\"\n     --header \"Authorization: Bearer ADMIN_TOKEN\" \\\n     --data-raw \"home,room=Kitchen temp=72.0\n    home,room=Living\\ room temp=71.5\"\n   ```\n\n   If all data is written, the response is `204 No Content`.\n\n4. [Query data](#operation/GetExecuteQuerySQL) from InfluxDB.\n\n   ```bash\n   curl -G \"http://localhost:8181/api/v3/query_sql\" \\\n     --header \"Authorization: Bearer ADMIN_TOKEN\" \\\n     --data-urlencode \"db=sensors\" \\\n     --data-urlencode \"q=SELECT * FROM home WHERE room='Living room'\" \\\n     --data-urlencode \"format=jsonl\"\n   ```\n   \n   Output:\n\n   ```jsonl\n   {\"room\":\"Living room\",\"temp\":71.5,\"time\":\"2025-02-25T20:19:34.984098\"}\n   ```\n  \nFor more information about using InfluxDB 3 Core, see the [Get started](/influxdb3/core/get-started/) guide.\n",
+        "source": "static/openapi/influxdb3-core/tags/tags/ref-quick-start.yaml",
+        "staticFilePath": "/openapi/influxdb3-core/tags/tags/ref-quick-start.yaml"
+      }
+    },
+    {
+      "path": "api/server-information",
+      "fields": {
+        "name": "Server information",
+        "describes": [
+          "/health",
+          "/api/v1/health",
+          "/ping",
+          "/metrics"
+        ],
+        "title": "Server information",
+        "description": "Retrieve server metrics, status, and version information",
+        "tag": "Server information",
+        "isConceptual": false,
+        "menuGroup": "Server",
+        "operations": [
+          {
+            "operationId": "GetHealth",
+            "method": "GET",
+            "path": "/health",
+            "summary": "Health check",
+            "tags": [
+              "Server information"
+            ]
+          },
+          {
+            "operationId": "GetHealthV1",
+            "method": "GET",
+            "path": "/api/v1/health",
+            "summary": "Health check (v1-compatible)",
+            "tags": [
+              "Server information"
+            ],
+            "compatVersion": "v1"
+          },
+          {
+            "operationId": "GetPing",
+            "method": "GET",
+            "path": "/ping",
+            "summary": "Ping the server",
+            "tags": [
+              "Server information"
+            ]
+          },
+          {
+            "operationId": "GetMetrics",
+            "method": "GET",
+            "path": "/metrics",
+            "summary": "Metrics",
+            "tags": [
+              "Server information"
+            ]
+          }
+        ],
+        "tagDescription": "Retrieve server metrics, status, and version information",
+        "source": "static/openapi/influxdb3-core/tags/tags/ref-server-information.yaml",
+        "staticFilePath": "/openapi/influxdb3-core/tags/tags/ref-server-information.yaml"
+      }
+    },
+    {
+      "path": "api/table",
+      "fields": {
+        "name": "Table",
+        "describes": [
+          "/api/v3/configure/table"
+        ],
+        "title": "Table",
+        "description": "Manage table schemas and data",
+        "tag": "Table",
+        "isConceptual": false,
+        "menuGroup": "Administration",
+        "operations": [
+          {
+            "operationId": "PostConfigureTable",
+            "method": "POST",
+            "path": "/api/v3/configure/table",
+            "summary": "Create a table",
+            "tags": [
+              "Table"
+            ]
+          },
+          {
+            "operationId": "DeleteConfigureTable",
+            "method": "DELETE",
+            "path": "/api/v3/configure/table",
+            "summary": "Delete a table",
+            "tags": [
+              "Table"
+            ]
+          }
+        ],
+        "tagDescription": "Manage table schemas and data",
+        "source": "static/openapi/influxdb3-core/tags/tags/ref-table.yaml",
+        "staticFilePath": "/openapi/influxdb3-core/tags/tags/ref-table.yaml"
+      }
+    },
+    {
+      "path": "api/write-data",
+      "fields": {
+        "name": "Write data",
+        "describes": [
+          "/write",
+          "/api/v2/write",
+          "/api/v3/write_lp"
+        ],
+        "title": "Write data",
+        "description": "Write data to InfluxDB 3 using line protocol format.\n\n#### Timestamp precision across write APIs\n\nInfluxDB 3 provides multiple write endpoints for compatibility with different InfluxDB versions.\nThe following table compares timestamp precision support across v1, v2, and v3 write APIs:\n\n| Precision | v1 (`/write`) | v2 (`/api/v2/write`) | v3 (`/api/v3/write_lp`) |\n|-----------|---------------|----------------------|-------------------------|\n| **Auto detection** | ❌ No | ❌ No | ✅ `auto` (default) |\n| **Seconds** | ✅ `s` | ✅ `s` | ✅ `second` |\n| **Milliseconds** | ✅ `ms` | ✅ `ms` | ✅ `millisecond` |\n| **Microseconds** | ✅ `u` or `µ` | ✅ `us` | ✅ `microsecond` |\n| **Nanoseconds** | ✅ `ns` | ✅ `ns` | ✅ `nanosecond` |\n| **Minutes** | ✅ `m` | ❌ No | ❌ No |\n| **Hours** | ✅ `h` | ❌ No | ❌ No |\n| **Default** | Nanosecond | Nanosecond | **Auto** (guessed) |\n\nAll timestamps are stored internally as nanoseconds.\n",
+        "tag": "Write data",
+        "isConceptual": false,
+        "menuGroup": "Data Operations",
+        "operations": [
+          {
+            "operationId": "PostV1Write",
+            "method": "POST",
+            "path": "/write",
+            "summary": "Write line protocol (v1-compatible)",
+            "tags": [
+              "Write data"
+            ],
+            "compatVersion": "v1",
+            "externalDocs": {
+              "description": "Use compatibility APIs to write data",
+              "url": "/influxdb3/core/write-data/http-api/compatibility-apis/"
+            }
+          },
+          {
+            "operationId": "PostV2Write",
+            "method": "POST",
+            "path": "/api/v2/write",
+            "summary": "Write line protocol (v2-compatible)",
+            "tags": [
+              "Write data"
+            ],
+            "compatVersion": "v2",
+            "externalDocs": {
+              "description": "Use compatibility APIs to write data",
+              "url": "/influxdb3/core/write-data/http-api/compatibility-apis/"
+            }
+          },
+          {
+            "operationId": "PostWriteLP",
+            "method": "POST",
+            "path": "/api/v3/write_lp",
+            "summary": "Write line protocol",
+            "tags": [
+              "Write data"
+            ]
+          }
+        ],
+        "tagDescription": "Write data to InfluxDB 3 using line protocol format.\n\n#### Timestamp precision across write APIs\n\nInfluxDB 3 provides multiple write endpoints for compatibility with different InfluxDB versions.\nThe following table compares timestamp precision support across v1, v2, and v3 write APIs:\n\n| Precision | v1 (`/write`) | v2 (`/api/v2/write`) | v3 (`/api/v3/write_lp`) |\n|-----------|---------------|----------------------|-------------------------|\n| **Auto detection** | ❌ No | ❌ No | ✅ `auto` (default) |\n| **Seconds** | ✅ `s` | ✅ `s` | ✅ `second` |\n| **Milliseconds** | ✅ `ms` | ✅ `ms` | ✅ `millisecond` |\n| **Microseconds** | ✅ `u` or `µ` | ✅ `us` | ✅ `microsecond` |\n| **Nanoseconds** | ✅ `ns` | ✅ `ns` | ✅ `nanosecond` |\n| **Minutes** | ✅ `m` | ❌ No | ❌ No |\n| **Hours** | ✅ `h` | ❌ No | ❌ No |\n| **Default** | Nanosecond | Nanosecond | **Auto** (guessed) |\n\nAll timestamps are stored internally as nanoseconds.\n",
+        "related": [
+          "/influxdb3/core/write-data/http-api/compatibility-apis/"
+        ],
+        "source": "static/openapi/influxdb3-core/tags/tags/ref-write-data.yaml",
+        "staticFilePath": "/openapi/influxdb3-core/tags/tags/ref-write-data.yaml"
+      }
+    }
+  ]
+}
\ No newline at end of file
diff --git a/data/article_data/influxdb/influxdb3_core/articles.yml b/data/article_data/influxdb/influxdb3_core/articles.yml
new file mode 100644
index 0000000000..c8f317c954
--- /dev/null
+++ b/data/article_data/influxdb/influxdb3_core/articles.yml
@@ -0,0 +1,989 @@
+articles:
+  - path: api/auth-token
+    fields:
+      name: Auth token
+      describes:
+        - /api/v3/configure/token/admin
+        - /api/v3/configure/token/admin/regenerate
+        - /api/v3/configure/token
+        - /api/v3/configure/token/named_admin
+      title: Auth token
+      description: Manage tokens for authentication and authorization
+      tag: Auth token
+      isConceptual: false
+      menuGroup: Other
+      operations:
+        - operationId: PostCreateAdminToken
+          method: POST
+          path: /api/v3/configure/token/admin
+          summary: Create admin token
+          tags:
+            - Auth token
+        - operationId: PostRegenerateAdminToken
+          method: POST
+          path: /api/v3/configure/token/admin/regenerate
+          summary: Regenerate admin token
+          tags:
+            - Auth token
+        - operationId: DeleteToken
+          method: DELETE
+          path: /api/v3/configure/token
+          summary: Delete token
+          tags:
+            - Auth token
+        - operationId: PostCreateNamedAdminToken
+          method: POST
+          path: /api/v3/configure/token/named_admin
+          summary: Create named admin token
+          tags:
+            - Auth token
+      tagDescription: Manage tokens for authentication and authorization
+      source: static/openapi/influxdb3-core/tags/tags/ref-auth-token.yaml
+      staticFilePath: /openapi/influxdb3-core/tags/tags/ref-auth-token.yaml
+  - path: api/authentication
+    fields:
+      name: Authentication
+      describes:
+        - /api/v3/configure/token/admin
+        - /api/v3/configure/token/admin/regenerate
+        - /api/v3/configure/token
+        - /api/v3/configure/token/named_admin
+      title: Authentication
+      description: >
+        Depending on your workflow, use one of the following schemes to
+        authenticate to the InfluxDB 3 API:
+
+
+        | Authentication scheme | Works with |
+
+        |:----------------------|:-----------|
+
+        | Bearer authentication | All endpoints |
+
+        | Token authentication  | v1, v2 endpoints |
+
+        | Basic authentication  | v1 endpoints |
+
+        | Querystring authentication | v1 endpoints |
+
+
+        See the **Security Schemes** section below for details on each
+        authentication method.
+      tag: Authentication
+      isConceptual: true
+      menuGroup: Concepts
+      operations:
+        - operationId: PostCreateAdminToken
+          method: POST
+          path: /api/v3/configure/token/admin
+          summary: Create admin token
+          tags:
+            - Authentication
+        - operationId: PostRegenerateAdminToken
+          method: POST
+          path: /api/v3/configure/token/admin/regenerate
+          summary: Regenerate admin token
+          tags:
+            - Authentication
+        - operationId: DeleteToken
+          method: DELETE
+          path: /api/v3/configure/token
+          summary: Delete token
+          tags:
+            - Authentication
+        - operationId: PostCreateNamedAdminToken
+          method: POST
+          path: /api/v3/configure/token/named_admin
+          summary: Create named admin token
+          tags:
+            - Authentication
+      tagDescription: >
+        Depending on your workflow, use one of the following schemes to
+        authenticate to the InfluxDB 3 API:
+
+
+        | Authentication scheme | Works with |
+
+        |:----------------------|:-----------|
+
+        | Bearer authentication | All endpoints |
+
+        | Token authentication  | v1, v2 endpoints |
+
+        | Basic authentication  | v1 endpoints |
+
+        | Querystring authentication | v1 endpoints |
+
+
+        See the **Security Schemes** section below for details on each
+        authentication method.
+      source: static/openapi/influxdb3-core/tags/tags/ref-authentication.yaml
+      staticFilePath: /openapi/influxdb3-core/tags/tags/ref-authentication.yaml
+  - path: api/cache-data
+    fields:
+      name: Cache data
+      describes:
+        - /api/v3/configure/distinct_cache
+        - /api/v3/configure/last_cache
+      title: Cache data
+      description: >
+        Manage the in-memory cache.
+
+
+        #### Distinct Value Cache
+
+
+        The Distinct Value Cache (DVC) lets you cache distinct
+
+        values of one or more columns in a table, improving the performance of
+
+        queries that return distinct tag and field values. 
+
+
+        The DVC is an in-memory cache that stores distinct values for specific
+        columns
+
+        in a table. When you create an DVC, you can specify what columns'
+        distinct
+
+        values to cache, the maximum number of distinct value combinations to
+        cache, and
+
+        the maximum age of cached values. A DVC is associated with a table,
+        which can
+
+        have multiple DVCs.
+
+
+        #### Last value cache
+
+
+        The Last Value Cache (LVC) lets you cache the most recent
+
+        values for specific fields in a table, improving the performance of
+        queries that
+
+        return the most recent value of a field for specific series or the last
+        N values
+
+        of a field.
+
+
+        The LVC is an in-memory cache that stores the last N number of values
+        for
+
+        specific fields of series in a table. When you create an LVC, you can
+        specify
+
+        what fields to cache, what tags to use to identify each series, and the
+
+        number of values to cache for each unique series.
+
+        An LVC is associated with a table, which can have multiple LVCs.
+
+
+        #### Related guides
+
+
+        - [Manage the Distinct Value
+        Cache](/influxdb3/core/admin/distinct-value-cache/)
+
+        - [Manage the Last Value Cache](/influxdb3/core/admin/last-value-cache/)
+      tag: Cache data
+      isConceptual: false
+      menuGroup: Data Operations
+      operations:
+        - operationId: PostConfigureDistinctCache
+          method: POST
+          path: /api/v3/configure/distinct_cache
+          summary: Create distinct cache
+          tags:
+            - Cache data
+        - operationId: DeleteConfigureDistinctCache
+          method: DELETE
+          path: /api/v3/configure/distinct_cache
+          summary: Delete distinct cache
+          tags:
+            - Cache data
+        - operationId: PostConfigureLastCache
+          method: POST
+          path: /api/v3/configure/last_cache
+          summary: Create last cache
+          tags:
+            - Cache data
+        - operationId: DeleteConfigureLastCache
+          method: DELETE
+          path: /api/v3/configure/last_cache
+          summary: Delete last cache
+          tags:
+            - Cache data
+      tagDescription: >
+        Manage the in-memory cache.
+
+
+        #### Distinct Value Cache
+
+
+        The Distinct Value Cache (DVC) lets you cache distinct
+
+        values of one or more columns in a table, improving the performance of
+
+        queries that return distinct tag and field values. 
+
+
+        The DVC is an in-memory cache that stores distinct values for specific
+        columns
+
+        in a table. When you create an DVC, you can specify what columns'
+        distinct
+
+        values to cache, the maximum number of distinct value combinations to
+        cache, and
+
+        the maximum age of cached values. A DVC is associated with a table,
+        which can
+
+        have multiple DVCs.
+
+
+        #### Last value cache
+
+
+        The Last Value Cache (LVC) lets you cache the most recent
+
+        values for specific fields in a table, improving the performance of
+        queries that
+
+        return the most recent value of a field for specific series or the last
+        N values
+
+        of a field.
+
+
+        The LVC is an in-memory cache that stores the last N number of values
+        for
+
+        specific fields of series in a table. When you create an LVC, you can
+        specify
+
+        what fields to cache, what tags to use to identify each series, and the
+
+        number of values to cache for each unique series.
+
+        An LVC is associated with a table, which can have multiple LVCs.
+
+
+        #### Related guides
+
+
+        - [Manage the Distinct Value
+        Cache](/influxdb3/core/admin/distinct-value-cache/)
+
+        - [Manage the Last Value Cache](/influxdb3/core/admin/last-value-cache/)
+      source: static/openapi/influxdb3-core/tags/tags/ref-cache-data.yaml
+      staticFilePath: /openapi/influxdb3-core/tags/tags/ref-cache-data.yaml
+  - path: api/database
+    fields:
+      name: Database
+      describes:
+        - /api/v3/configure/database
+        - /api/v3/configure/database/retention_period
+      title: Database
+      description: Manage databases
+      tag: Database
+      isConceptual: false
+      menuGroup: Administration
+      operations:
+        - operationId: GetConfigureDatabase
+          method: GET
+          path: /api/v3/configure/database
+          summary: List databases
+          tags:
+            - Database
+        - operationId: PostConfigureDatabase
+          method: POST
+          path: /api/v3/configure/database
+          summary: Create a database
+          tags:
+            - Database
+        - operationId: DeleteConfigureDatabase
+          method: DELETE
+          path: /api/v3/configure/database
+          summary: Delete a database
+          tags:
+            - Database
+        - operationId: DeleteDatabaseRetentionPeriod
+          method: DELETE
+          path: /api/v3/configure/database/retention_period
+          summary: Remove database retention period
+          tags:
+            - Database
+      tagDescription: Manage databases
+      source: static/openapi/influxdb3-core/tags/tags/ref-database.yaml
+      staticFilePath: /openapi/influxdb3-core/tags/tags/ref-database.yaml
+  - path: api/headers-and-parameters
+    fields:
+      name: Headers and parameters
+      describes: []
+      title: Headers and parameters
+      description: >
+        Most InfluxDB API endpoints require parameters in the request--for
+        example, specifying the database to use.
+
+
+        ### Common parameters
+
+
+        The following table shows common parameters used by many InfluxDB API
+        endpoints.
+
+        Many endpoints may require other parameters in the query string or in
+        the
+
+        request body that perform functions specific to those endpoints.
+
+
+        | Query parameter          | Value type            |
+        Description                                |
+
+        |:------------------------ |:---------------------
+        |:-------------------------------------------|
+
+        | `db`                 | string                | The database name |
+
+
+        InfluxDB HTTP API endpoints use standard HTTP request and response
+        headers.
+
+        The following table shows common headers used by many InfluxDB API
+        endpoints.
+
+        Some endpoints may use other headers that perform functions more
+        specific to those endpoints--for example,
+
+        the write endpoints accept the `Content-Encoding` header to indicate
+        that line protocol is compressed in the request body.
+
+
+        | Header                   | Value type            |
+        Description                                |
+
+        |:------------------------ |:---------------------
+        |:-------------------------------------------|
+
+        | `Accept`                 | string                | The content type
+        that the client can understand. |
+
+        | `Authorization`          | string                | The authorization
+        scheme and credential. |
+
+        | `Content-Length`         | integer               | The size of the
+        entity-body, in bytes. |
+
+        | `Content-Type`           | string                | The format of the
+        data in the request body. |
+      tag: Headers and parameters
+      isConceptual: true
+      menuGroup: Concepts
+      operations: []
+      tagDescription: >
+        Most InfluxDB API endpoints require parameters in the request--for
+        example, specifying the database to use.
+
+
+        ### Common parameters
+
+
+        The following table shows common parameters used by many InfluxDB API
+        endpoints.
+
+        Many endpoints may require other parameters in the query string or in
+        the
+
+        request body that perform functions specific to those endpoints.
+
+
+        | Query parameter          | Value type            |
+        Description                                |
+
+        |:------------------------ |:---------------------
+        |:-------------------------------------------|
+
+        | `db`                 | string                | The database name |
+
+
+        InfluxDB HTTP API endpoints use standard HTTP request and response
+        headers.
+
+        The following table shows common headers used by many InfluxDB API
+        endpoints.
+
+        Some endpoints may use other headers that perform functions more
+        specific to those endpoints--for example,
+
+        the write endpoints accept the `Content-Encoding` header to indicate
+        that line protocol is compressed in the request body.
+
+
+        | Header                   | Value type            |
+        Description                                |
+
+        |:------------------------ |:---------------------
+        |:-------------------------------------------|
+
+        | `Accept`                 | string                | The content type
+        that the client can understand. |
+
+        | `Authorization`          | string                | The authorization
+        scheme and credential. |
+
+        | `Content-Length`         | integer               | The size of the
+        entity-body, in bytes. |
+
+        | `Content-Type`           | string                | The format of the
+        data in the request body. |
+      source: static/openapi/influxdb3-core/tags/tags/ref-headers-and-parameters.yaml
+      staticFilePath: /openapi/influxdb3-core/tags/tags/ref-headers-and-parameters.yaml
+  - path: api/migrate-from-influxdb-v1-or-v2
+    fields:
+      name: Migrate from InfluxDB v1 or v2
+      describes: []
+      title: Migrate from InfluxDB v1 or v2
+      description: >
+        Migrate your existing InfluxDB v1 or v2 workloads to InfluxDB 3.
+
+
+        InfluxDB 3 provides compatibility endpoints that work with InfluxDB 1.x
+        and 2.x client libraries and tools.
+
+        Operations marked with <span class="api-compat-badge
+        api-compat-badge--v1">v1</span> or <span class="api-compat-badge
+        api-compat-badge--v2">v2</span> badges are compatible with the
+        respective InfluxDB version.
+
+
+        ### Migration guides
+
+
+        - [Migrate from InfluxDB
+        v1](/influxdb3/core/guides/migrate/influxdb-1x/) - For users migrating
+        from InfluxDB 1.x
+
+        - [Migrate from InfluxDB
+        v2](/influxdb3/core/guides/migrate/influxdb-2x/) - For users migrating
+        from InfluxDB 2.x or Cloud
+
+        - [Use compatibility APIs to write
+        data](/influxdb3/core/write-data/http-api/compatibility-apis/) - v1 and
+        v2 write endpoints
+
+        - [Use the v1 HTTP query
+        API](/influxdb3/core/query-data/execute-queries/influxdb-v1-api/) -
+        InfluxQL queries via HTTP
+      tag: Migrate from InfluxDB v1 or v2
+      isConceptual: true
+      menuGroup: Other
+      operations: []
+      tagDescription: >
+        Migrate your existing InfluxDB v1 or v2 workloads to InfluxDB 3.
+
+
+        InfluxDB 3 provides compatibility endpoints that work with InfluxDB 1.x
+        and 2.x client libraries and tools.
+
+        Operations marked with <span class="api-compat-badge
+        api-compat-badge--v1">v1</span> or <span class="api-compat-badge
+        api-compat-badge--v2">v2</span> badges are compatible with the
+        respective InfluxDB version.
+
+
+        ### Migration guides
+
+
+        - [Migrate from InfluxDB
+        v1](/influxdb3/core/guides/migrate/influxdb-1x/) - For users migrating
+        from InfluxDB 1.x
+
+        - [Migrate from InfluxDB
+        v2](/influxdb3/core/guides/migrate/influxdb-2x/) - For users migrating
+        from InfluxDB 2.x or Cloud
+
+        - [Use compatibility APIs to write
+        data](/influxdb3/core/write-data/http-api/compatibility-apis/) - v1 and
+        v2 write endpoints
+
+        - [Use the v1 HTTP query
+        API](/influxdb3/core/query-data/execute-queries/influxdb-v1-api/) -
+        InfluxQL queries via HTTP
+      source: >-
+        static/openapi/influxdb3-core/tags/tags/ref-migrate-from-influxdb-v1-or-v2.yaml
+      staticFilePath: >-
+        /openapi/influxdb3-core/tags/tags/ref-migrate-from-influxdb-v1-or-v2.yaml
+  - path: api/processing-engine
+    fields:
+      name: Processing engine
+      describes:
+        - /api/v3/configure/processing_engine_trigger
+        - /api/v3/configure/processing_engine_trigger/disable
+        - /api/v3/configure/processing_engine_trigger/enable
+        - /api/v3/configure/plugin_environment/install_packages
+        - /api/v3/configure/plugin_environment/install_requirements
+        - /api/v3/plugin_test/wal
+        - /api/v3/plugin_test/schedule
+        - /api/v3/engine/{request_path}
+        - /api/v3/plugins/files
+        - /api/v3/plugins/directory
+      title: Processing engine
+      description: >
+        Manage Processing engine triggers, test plugins, and send requests to
+        trigger On Request plugins.
+
+
+        InfluxDB 3 Core provides the InfluxDB 3 processing engine, an embedded
+        Python VM that can dynamically load and trigger Python plugins in
+        response to events in your database.
+
+        Use Processing engine plugins and triggers to run code and perform tasks
+        for different database events.
+
+
+        To get started with the processing engine, see the [Processing engine
+        and Python plugins](/influxdb3/core/processing-engine/) guide.
+      tag: Processing engine
+      isConceptual: false
+      menuGroup: Processing Engine
+      operations:
+        - operationId: PostConfigureProcessingEngineTrigger
+          method: POST
+          path: /api/v3/configure/processing_engine_trigger
+          summary: Create processing engine trigger
+          tags:
+            - Processing engine
+        - operationId: DeleteConfigureProcessingEngineTrigger
+          method: DELETE
+          path: /api/v3/configure/processing_engine_trigger
+          summary: Delete processing engine trigger
+          tags:
+            - Processing engine
+        - operationId: PostDisableProcessingEngineTrigger
+          method: POST
+          path: /api/v3/configure/processing_engine_trigger/disable
+          summary: Disable processing engine trigger
+          tags:
+            - Processing engine
+        - operationId: PostEnableProcessingEngineTrigger
+          method: POST
+          path: /api/v3/configure/processing_engine_trigger/enable
+          summary: Enable processing engine trigger
+          tags:
+            - Processing engine
+        - operationId: PostInstallPluginPackages
+          method: POST
+          path: /api/v3/configure/plugin_environment/install_packages
+          summary: Install plugin packages
+          tags:
+            - Processing engine
+        - operationId: PostInstallPluginRequirements
+          method: POST
+          path: /api/v3/configure/plugin_environment/install_requirements
+          summary: Install plugin requirements
+          tags:
+            - Processing engine
+        - operationId: PostTestWALPlugin
+          method: POST
+          path: /api/v3/plugin_test/wal
+          summary: Test WAL plugin
+          tags:
+            - Processing engine
+        - operationId: PostTestSchedulingPlugin
+          method: POST
+          path: /api/v3/plugin_test/schedule
+          summary: Test scheduling plugin
+          tags:
+            - Processing engine
+        - operationId: GetProcessingEnginePluginRequest
+          method: GET
+          path: /api/v3/engine/{request_path}
+          summary: On Request processing engine plugin request
+          tags:
+            - Processing engine
+        - operationId: PostProcessingEnginePluginRequest
+          method: POST
+          path: /api/v3/engine/{request_path}
+          summary: On Request processing engine plugin request
+          tags:
+            - Processing engine
+        - operationId: PutPluginFile
+          method: PUT
+          path: /api/v3/plugins/files
+          summary: Update plugin file
+          tags:
+            - Processing engine
+        - operationId: PutPluginDirectory
+          method: PUT
+          path: /api/v3/plugins/directory
+          summary: Update plugin directory
+          tags:
+            - Processing engine
+      tagDescription: >
+        Manage Processing engine triggers, test plugins, and send requests to
+        trigger On Request plugins.
+
+
+        InfluxDB 3 Core provides the InfluxDB 3 processing engine, an embedded
+        Python VM that can dynamically load and trigger Python plugins in
+        response to events in your database.
+
+        Use Processing engine plugins and triggers to run code and perform tasks
+        for different database events.
+
+
+        To get started with the processing engine, see the [Processing engine
+        and Python plugins](/influxdb3/core/processing-engine/) guide.
+      source: static/openapi/influxdb3-core/tags/tags/ref-processing-engine.yaml
+      staticFilePath: /openapi/influxdb3-core/tags/tags/ref-processing-engine.yaml
+  - path: api/query-data
+    fields:
+      name: Query data
+      describes:
+        - /api/v3/query_sql
+        - /api/v3/query_influxql
+        - /query
+      title: Query data
+      description: Query data using SQL or InfluxQL
+      tag: Query data
+      isConceptual: false
+      menuGroup: Data Operations
+      operations:
+        - operationId: GetExecuteQuerySQL
+          method: GET
+          path: /api/v3/query_sql
+          summary: Execute SQL query
+          tags:
+            - Query data
+        - operationId: PostExecuteQuerySQL
+          method: POST
+          path: /api/v3/query_sql
+          summary: Execute SQL query
+          tags:
+            - Query data
+        - operationId: GetExecuteInfluxQLQuery
+          method: GET
+          path: /api/v3/query_influxql
+          summary: Execute InfluxQL query
+          tags:
+            - Query data
+        - operationId: PostExecuteQueryInfluxQL
+          method: POST
+          path: /api/v3/query_influxql
+          summary: Execute InfluxQL query
+          tags:
+            - Query data
+        - operationId: GetV1ExecuteQuery
+          method: GET
+          path: /query
+          summary: Execute InfluxQL query (v1-compatible)
+          tags:
+            - Query data
+          compatVersion: v1
+          externalDocs:
+            description: Use the InfluxDB v1 HTTP query API and InfluxQL to query data
+            url: /influxdb3/core/query-data/execute-queries/influxdb-v1-api/
+        - operationId: PostExecuteV1Query
+          method: POST
+          path: /query
+          summary: Execute InfluxQL query (v1-compatible)
+          tags:
+            - Query data
+          compatVersion: v1
+          externalDocs:
+            description: Use the InfluxDB v1 HTTP query API and InfluxQL to query data
+            url: /influxdb3/core/query-data/execute-queries/influxdb-v1-api/
+      tagDescription: Query data using SQL or InfluxQL
+      related:
+        - /influxdb3/core/query-data/execute-queries/influxdb-v1-api/
+      source: static/openapi/influxdb3-core/tags/tags/ref-query-data.yaml
+      staticFilePath: /openapi/influxdb3-core/tags/tags/ref-query-data.yaml
+  - path: api/quick-start
+    fields:
+      name: Quick start
+      describes: []
+      title: Quick start
+      description: >
+        1. [Create an admin token](#section/Authentication) to authorize API
+        requests.
+
+           ```bash
+           curl -X POST "http://localhost:8181/api/v3/configure/token/admin"
+           ```
+        2. [Check the status](#section/Server-information) of the InfluxDB
+        server.
+
+           ```bash
+           curl "http://localhost:8181/health" \
+              --header "Authorization: Bearer ADMIN_TOKEN"
+           ```
+
+        3. [Write data](#operation/PostWriteLP) to InfluxDB.
+
+           ```bash
+           curl "http://localhost:8181/api/v3/write_lp?db=sensors&precision=auto"
+             --header "Authorization: Bearer ADMIN_TOKEN" \
+             --data-raw "home,room=Kitchen temp=72.0
+            home,room=Living\ room temp=71.5"
+           ```
+
+           If all data is written, the response is `204 No Content`.
+
+        4. [Query data](#operation/GetExecuteQuerySQL) from InfluxDB.
+
+           ```bash
+           curl -G "http://localhost:8181/api/v3/query_sql" \
+             --header "Authorization: Bearer ADMIN_TOKEN" \
+             --data-urlencode "db=sensors" \
+             --data-urlencode "q=SELECT * FROM home WHERE room='Living room'" \
+             --data-urlencode "format=jsonl"
+           ```
+           
+           Output:
+
+           ```jsonl
+           {"room":"Living room","temp":71.5,"time":"2025-02-25T20:19:34.984098"}
+           ```
+          
+        For more information about using InfluxDB 3 Core, see the [Get
+        started](/influxdb3/core/get-started/) guide.
+      tag: Quick start
+      isConceptual: true
+      menuGroup: Concepts
+      operations: []
+      tagDescription: >
+        1. [Create an admin token](#section/Authentication) to authorize API
+        requests.
+
+           ```bash
+           curl -X POST "http://localhost:8181/api/v3/configure/token/admin"
+           ```
+        2. [Check the status](#section/Server-information) of the InfluxDB
+        server.
+
+           ```bash
+           curl "http://localhost:8181/health" \
+              --header "Authorization: Bearer ADMIN_TOKEN"
+           ```
+
+        3. [Write data](#operation/PostWriteLP) to InfluxDB.
+
+           ```bash
+           curl "http://localhost:8181/api/v3/write_lp?db=sensors&precision=auto"
+             --header "Authorization: Bearer ADMIN_TOKEN" \
+             --data-raw "home,room=Kitchen temp=72.0
+            home,room=Living\ room temp=71.5"
+           ```
+
+           If all data is written, the response is `204 No Content`.
+
+        4. [Query data](#operation/GetExecuteQuerySQL) from InfluxDB.
+
+           ```bash
+           curl -G "http://localhost:8181/api/v3/query_sql" \
+             --header "Authorization: Bearer ADMIN_TOKEN" \
+             --data-urlencode "db=sensors" \
+             --data-urlencode "q=SELECT * FROM home WHERE room='Living room'" \
+             --data-urlencode "format=jsonl"
+           ```
+           
+           Output:
+
+           ```jsonl
+           {"room":"Living room","temp":71.5,"time":"2025-02-25T20:19:34.984098"}
+           ```
+          
+        For more information about using InfluxDB 3 Core, see the [Get
+        started](/influxdb3/core/get-started/) guide.
+      source: static/openapi/influxdb3-core/tags/tags/ref-quick-start.yaml
+      staticFilePath: /openapi/influxdb3-core/tags/tags/ref-quick-start.yaml
+  - path: api/server-information
+    fields:
+      name: Server information
+      describes:
+        - /health
+        - /api/v1/health
+        - /ping
+        - /metrics
+      title: Server information
+      description: Retrieve server metrics, status, and version information
+      tag: Server information
+      isConceptual: false
+      menuGroup: Server
+      operations:
+        - operationId: GetHealth
+          method: GET
+          path: /health
+          summary: Health check
+          tags:
+            - Server information
+        - operationId: GetHealthV1
+          method: GET
+          path: /api/v1/health
+          summary: Health check (v1-compatible)
+          tags:
+            - Server information
+          compatVersion: v1
+        - operationId: GetPing
+          method: GET
+          path: /ping
+          summary: Ping the server
+          tags:
+            - Server information
+        - operationId: GetMetrics
+          method: GET
+          path: /metrics
+          summary: Metrics
+          tags:
+            - Server information
+      tagDescription: Retrieve server metrics, status, and version information
+      source: static/openapi/influxdb3-core/tags/tags/ref-server-information.yaml
+      staticFilePath: /openapi/influxdb3-core/tags/tags/ref-server-information.yaml
+  - path: api/table
+    fields:
+      name: Table
+      describes:
+        - /api/v3/configure/table
+      title: Table
+      description: Manage table schemas and data
+      tag: Table
+      isConceptual: false
+      menuGroup: Administration
+      operations:
+        - operationId: PostConfigureTable
+          method: POST
+          path: /api/v3/configure/table
+          summary: Create a table
+          tags:
+            - Table
+        - operationId: DeleteConfigureTable
+          method: DELETE
+          path: /api/v3/configure/table
+          summary: Delete a table
+          tags:
+            - Table
+      tagDescription: Manage table schemas and data
+      source: static/openapi/influxdb3-core/tags/tags/ref-table.yaml
+      staticFilePath: /openapi/influxdb3-core/tags/tags/ref-table.yaml
+  - path: api/write-data
+    fields:
+      name: Write data
+      describes:
+        - /write
+        - /api/v2/write
+        - /api/v3/write_lp
+      title: Write data
+      description: >
+        Write data to InfluxDB 3 using line protocol format.
+
+
+        #### Timestamp precision across write APIs
+
+
+        InfluxDB 3 provides multiple write endpoints for compatibility with
+        different InfluxDB versions.
+
+        The following table compares timestamp precision support across v1, v2,
+        and v3 write APIs:
+
+
+        | Precision | v1 (`/write`) | v2 (`/api/v2/write`) | v3
+        (`/api/v3/write_lp`) |
+
+        |-----------|---------------|----------------------|-------------------------|
+
+        | **Auto detection** | ❌ No | ❌ No | ✅ `auto` (default) |
+
+        | **Seconds** | ✅ `s` | ✅ `s` | ✅ `second` |
+
+        | **Milliseconds** | ✅ `ms` | ✅ `ms` | ✅ `millisecond` |
+
+        | **Microseconds** | ✅ `u` or `µ` | ✅ `us` | ✅ `microsecond` |
+
+        | **Nanoseconds** | ✅ `ns` | ✅ `ns` | ✅ `nanosecond` |
+
+        | **Minutes** | ✅ `m` | ❌ No | ❌ No |
+
+        | **Hours** | ✅ `h` | ❌ No | ❌ No |
+
+        | **Default** | Nanosecond | Nanosecond | **Auto** (guessed) |
+
+
+        All timestamps are stored internally as nanoseconds.
+      tag: Write data
+      isConceptual: false
+      menuGroup: Data Operations
+      operations:
+        - operationId: PostV1Write
+          method: POST
+          path: /write
+          summary: Write line protocol (v1-compatible)
+          tags:
+            - Write data
+          compatVersion: v1
+          externalDocs:
+            description: Use compatibility APIs to write data
+            url: /influxdb3/core/write-data/http-api/compatibility-apis/
+        - operationId: PostV2Write
+          method: POST
+          path: /api/v2/write
+          summary: Write line protocol (v2-compatible)
+          tags:
+            - Write data
+          compatVersion: v2
+          externalDocs:
+            description: Use compatibility APIs to write data
+            url: /influxdb3/core/write-data/http-api/compatibility-apis/
+        - operationId: PostWriteLP
+          method: POST
+          path: /api/v3/write_lp
+          summary: Write line protocol
+          tags:
+            - Write data
+      tagDescription: >
+        Write data to InfluxDB 3 using line protocol format.
+
+
+        #### Timestamp precision across write APIs
+
+
+        InfluxDB 3 provides multiple write endpoints for compatibility with
+        different InfluxDB versions.
+
+        The following table compares timestamp precision support across v1, v2,
+        and v3 write APIs:
+
+
+        | Precision | v1 (`/write`) | v2 (`/api/v2/write`) | v3
+        (`/api/v3/write_lp`) |
+
+        |-----------|---------------|----------------------|-------------------------|
+
+        | **Auto detection** | ❌ No | ❌ No | ✅ `auto` (default) |
+
+        | **Seconds** | ✅ `s` | ✅ `s` | ✅ `second` |
+
+        | **Milliseconds** | ✅ `ms` | ✅ `ms` | ✅ `millisecond` |
+
+        | **Microseconds** | ✅ `u` or `µ` | ✅ `us` | ✅ `microsecond` |
+
+        | **Nanoseconds** | ✅ `ns` | ✅ `ns` | ✅ `nanosecond` |
+
+        | **Minutes** | ✅ `m` | ❌ No | ❌ No |
+
+        | **Hours** | ✅ `h` | ❌ No | ❌ No |
+
+        | **Default** | Nanosecond | Nanosecond | **Auto** (guessed) |
+
+
+        All timestamps are stored internally as nanoseconds.
+      related:
+        - /influxdb3/core/write-data/http-api/compatibility-apis/
+      source: static/openapi/influxdb3-core/tags/tags/ref-write-data.yaml
+      staticFilePath: /openapi/influxdb3-core/tags/tags/ref-write-data.yaml
diff --git a/data/article_data/influxdb/influxdb3_enterprise/articles.json b/data/article_data/influxdb/influxdb3_enterprise/articles.json
new file mode 100644
index 0000000000..7d9b658d44
--- /dev/null
+++ b/data/article_data/influxdb/influxdb3_enterprise/articles.json
@@ -0,0 +1,710 @@
+{
+  "articles": [
+    {
+      "path": "api/auth-token",
+      "fields": {
+        "name": "Auth token",
+        "describes": [
+          "/api/v3/configure/enterprise/token",
+          "/api/v3/configure/token/admin",
+          "/api/v3/configure/token/admin/regenerate",
+          "/api/v3/configure/token",
+          "/api/v3/configure/token/named_admin"
+        ],
+        "title": "Auth token",
+        "description": "Manage tokens for authentication and authorization",
+        "tag": "Auth token",
+        "isConceptual": false,
+        "menuGroup": "Other",
+        "operations": [
+          {
+            "operationId": "PostCreateResourceToken",
+            "method": "POST",
+            "path": "/api/v3/configure/enterprise/token",
+            "summary": "Create a resource token",
+            "tags": [
+              "Auth token"
+            ]
+          },
+          {
+            "operationId": "PostCreateAdminToken",
+            "method": "POST",
+            "path": "/api/v3/configure/token/admin",
+            "summary": "Create admin token",
+            "tags": [
+              "Auth token"
+            ]
+          },
+          {
+            "operationId": "PostRegenerateAdminToken",
+            "method": "POST",
+            "path": "/api/v3/configure/token/admin/regenerate",
+            "summary": "Regenerate admin token",
+            "tags": [
+              "Auth token"
+            ]
+          },
+          {
+            "operationId": "DeleteToken",
+            "method": "DELETE",
+            "path": "/api/v3/configure/token",
+            "summary": "Delete token",
+            "tags": [
+              "Auth token"
+            ]
+          },
+          {
+            "operationId": "PostCreateNamedAdminToken",
+            "method": "POST",
+            "path": "/api/v3/configure/token/named_admin",
+            "summary": "Create named admin token",
+            "tags": [
+              "Auth token"
+            ]
+          }
+        ],
+        "tagDescription": "Manage tokens for authentication and authorization",
+        "source": "static/openapi/influxdb3-enterprise/tags/tags/ref-auth-token.yaml",
+        "staticFilePath": "/openapi/influxdb3-enterprise/tags/tags/ref-auth-token.yaml"
+      }
+    },
+    {
+      "path": "api/authentication",
+      "fields": {
+        "name": "Authentication",
+        "describes": [
+          "/api/v3/configure/enterprise/token",
+          "/api/v3/configure/token/admin",
+          "/api/v3/configure/token/admin/regenerate",
+          "/api/v3/configure/token",
+          "/api/v3/configure/token/named_admin"
+        ],
+        "title": "Authentication",
+        "description": "Depending on your workflow, use one of the following schemes to authenticate to the InfluxDB 3 API:\n| Authentication scheme | Works with |\n|:----------------------|:-----------|\n| Bearer authentication | All endpoints |\n| Token authentication  | v1, v2 endpoints |\n| Basic authentication  | v1 endpoints |\n| Querystring authentication | v1 endpoints |\nSee the **Security Schemes** section below for details on each authentication method.\n",
+        "tag": "Authentication",
+        "isConceptual": true,
+        "menuGroup": "Concepts",
+        "operations": [
+          {
+            "operationId": "PostCreateResourceToken",
+            "method": "POST",
+            "path": "/api/v3/configure/enterprise/token",
+            "summary": "Create a resource token",
+            "tags": [
+              "Authentication"
+            ]
+          },
+          {
+            "operationId": "PostCreateAdminToken",
+            "method": "POST",
+            "path": "/api/v3/configure/token/admin",
+            "summary": "Create admin token",
+            "tags": [
+              "Authentication"
+            ]
+          },
+          {
+            "operationId": "PostRegenerateAdminToken",
+            "method": "POST",
+            "path": "/api/v3/configure/token/admin/regenerate",
+            "summary": "Regenerate admin token",
+            "tags": [
+              "Authentication"
+            ]
+          },
+          {
+            "operationId": "DeleteToken",
+            "method": "DELETE",
+            "path": "/api/v3/configure/token",
+            "summary": "Delete token",
+            "tags": [
+              "Authentication"
+            ]
+          },
+          {
+            "operationId": "PostCreateNamedAdminToken",
+            "method": "POST",
+            "path": "/api/v3/configure/token/named_admin",
+            "summary": "Create named admin token",
+            "tags": [
+              "Authentication"
+            ]
+          }
+        ],
+        "tagDescription": "Depending on your workflow, use one of the following schemes to authenticate to the InfluxDB 3 API:\n| Authentication scheme | Works with |\n|:----------------------|:-----------|\n| Bearer authentication | All endpoints |\n| Token authentication  | v1, v2 endpoints |\n| Basic authentication  | v1 endpoints |\n| Querystring authentication | v1 endpoints |\nSee the **Security Schemes** section below for details on each authentication method.\n",
+        "source": "static/openapi/influxdb3-enterprise/tags/tags/ref-authentication.yaml",
+        "staticFilePath": "/openapi/influxdb3-enterprise/tags/tags/ref-authentication.yaml"
+      }
+    },
+    {
+      "path": "api/cache-data",
+      "fields": {
+        "name": "Cache data",
+        "describes": [
+          "/api/v3/configure/distinct_cache",
+          "/api/v3/configure/last_cache"
+        ],
+        "title": "Cache data",
+        "description": "Manage the in-memory cache.\n#### Distinct Value Cache\nThe Distinct Value Cache (DVC) lets you cache distinct\nvalues of one or more columns in a table, improving the performance of\nqueries that return distinct tag and field values. \nThe DVC is an in-memory cache that stores distinct values for specific columns\nin a table. When you create an DVC, you can specify what columns' distinct\nvalues to cache, the maximum number of distinct value combinations to cache, and\nthe maximum age of cached values. A DVC is associated with a table, which can\nhave multiple DVCs.\n#### Last value cache\nThe Last Value Cache (LVC) lets you cache the most recent\nvalues for specific fields in a table, improving the performance of queries that\nreturn the most recent value of a field for specific series or the last N values\nof a field.\nThe LVC is an in-memory cache that stores the last N number of values for\nspecific fields of series in a table. When you create an LVC, you can specify\nwhat fields to cache, what tags to use to identify each series, and the\nnumber of values to cache for each unique series.\nAn LVC is associated with a table, which can have multiple LVCs.\n#### Related guides\n- [Manage the Distinct Value Cache](/influxdb3/enterprise/admin/distinct-value-cache/)\n- [Manage the Last Value Cache](/influxdb3/enterprise/admin/last-value-cache/)\n",
+        "tag": "Cache data",
+        "isConceptual": false,
+        "menuGroup": "Data Operations",
+        "operations": [
+          {
+            "operationId": "PostConfigureDistinctCache",
+            "method": "POST",
+            "path": "/api/v3/configure/distinct_cache",
+            "summary": "Create distinct cache",
+            "tags": [
+              "Cache data"
+            ]
+          },
+          {
+            "operationId": "DeleteConfigureDistinctCache",
+            "method": "DELETE",
+            "path": "/api/v3/configure/distinct_cache",
+            "summary": "Delete distinct cache",
+            "tags": [
+              "Cache data"
+            ]
+          },
+          {
+            "operationId": "PostConfigureLastCache",
+            "method": "POST",
+            "path": "/api/v3/configure/last_cache",
+            "summary": "Create last cache",
+            "tags": [
+              "Cache data"
+            ]
+          },
+          {
+            "operationId": "DeleteConfigureLastCache",
+            "method": "DELETE",
+            "path": "/api/v3/configure/last_cache",
+            "summary": "Delete last cache",
+            "tags": [
+              "Cache data"
+            ]
+          }
+        ],
+        "tagDescription": "Manage the in-memory cache.\n#### Distinct Value Cache\nThe Distinct Value Cache (DVC) lets you cache distinct\nvalues of one or more columns in a table, improving the performance of\nqueries that return distinct tag and field values. \nThe DVC is an in-memory cache that stores distinct values for specific columns\nin a table. When you create an DVC, you can specify what columns' distinct\nvalues to cache, the maximum number of distinct value combinations to cache, and\nthe maximum age of cached values. A DVC is associated with a table, which can\nhave multiple DVCs.\n#### Last value cache\nThe Last Value Cache (LVC) lets you cache the most recent\nvalues for specific fields in a table, improving the performance of queries that\nreturn the most recent value of a field for specific series or the last N values\nof a field.\nThe LVC is an in-memory cache that stores the last N number of values for\nspecific fields of series in a table. When you create an LVC, you can specify\nwhat fields to cache, what tags to use to identify each series, and the\nnumber of values to cache for each unique series.\nAn LVC is associated with a table, which can have multiple LVCs.\n#### Related guides\n- [Manage the Distinct Value Cache](/influxdb3/enterprise/admin/distinct-value-cache/)\n- [Manage the Last Value Cache](/influxdb3/enterprise/admin/last-value-cache/)\n",
+        "source": "static/openapi/influxdb3-enterprise/tags/tags/ref-cache-data.yaml",
+        "staticFilePath": "/openapi/influxdb3-enterprise/tags/tags/ref-cache-data.yaml"
+      }
+    },
+    {
+      "path": "api/database",
+      "fields": {
+        "name": "Database",
+        "describes": [
+          "/api/v3/configure/database",
+          "/api/v3/configure/database/retention_period",
+          "/api/v3/configure/database/{db}"
+        ],
+        "title": "Database",
+        "description": "Manage databases",
+        "tag": "Database",
+        "isConceptual": false,
+        "menuGroup": "Administration",
+        "operations": [
+          {
+            "operationId": "GetConfigureDatabase",
+            "method": "GET",
+            "path": "/api/v3/configure/database",
+            "summary": "List databases",
+            "tags": [
+              "Database"
+            ]
+          },
+          {
+            "operationId": "PostConfigureDatabase",
+            "method": "POST",
+            "path": "/api/v3/configure/database",
+            "summary": "Create a database",
+            "tags": [
+              "Database"
+            ]
+          },
+          {
+            "operationId": "DeleteConfigureDatabase",
+            "method": "DELETE",
+            "path": "/api/v3/configure/database",
+            "summary": "Delete a database",
+            "tags": [
+              "Database"
+            ]
+          },
+          {
+            "operationId": "DeleteDatabaseRetentionPeriod",
+            "method": "DELETE",
+            "path": "/api/v3/configure/database/retention_period",
+            "summary": "Remove database retention period",
+            "tags": [
+              "Database"
+            ]
+          },
+          {
+            "operationId": "PatchConfigureDatabase",
+            "method": "PATCH",
+            "path": "/api/v3/configure/database/{db}",
+            "summary": "Update a database",
+            "tags": [
+              "Database"
+            ]
+          }
+        ],
+        "tagDescription": "Manage databases",
+        "source": "static/openapi/influxdb3-enterprise/tags/tags/ref-database.yaml",
+        "staticFilePath": "/openapi/influxdb3-enterprise/tags/tags/ref-database.yaml"
+      }
+    },
+    {
+      "path": "api/headers-and-parameters",
+      "fields": {
+        "name": "Headers and parameters",
+        "describes": [],
+        "title": "Headers and parameters",
+        "description": "Most InfluxDB API endpoints require parameters in the request--for example, specifying the database to use.\n### Common parameters\nThe following table shows common parameters used by many InfluxDB API endpoints.\nMany endpoints may require other parameters in the query string or in the\nrequest body that perform functions specific to those endpoints.\n| Query parameter          | Value type            | Description                                |\n|:------------------------ |:--------------------- |:-------------------------------------------|\n| `db`                 | string                | The database name |\nInfluxDB HTTP API endpoints use standard HTTP request and response headers.\nThe following table shows common headers used by many InfluxDB API endpoints.\nSome endpoints may use other headers that perform functions more specific to those endpoints--for example,\nthe write endpoints accept the `Content-Encoding` header to indicate that line protocol is compressed in the request body.\n| Header                   | Value type            | Description                                |\n|:------------------------ |:--------------------- |:-------------------------------------------|\n| `Accept`                 | string                | The content type that the client can understand. |\n| `Authorization`          | string                | The authorization scheme and credential. |\n| `Content-Length`         | integer               | The size of the entity-body, in bytes. |\n| `Content-Type`           | string                | The format of the data in the request body. |\n",
+        "tag": "Headers and parameters",
+        "isConceptual": true,
+        "menuGroup": "Concepts",
+        "operations": [],
+        "tagDescription": "Most InfluxDB API endpoints require parameters in the request--for example, specifying the database to use.\n### Common parameters\nThe following table shows common parameters used by many InfluxDB API endpoints.\nMany endpoints may require other parameters in the query string or in the\nrequest body that perform functions specific to those endpoints.\n| Query parameter          | Value type            | Description                                |\n|:------------------------ |:--------------------- |:-------------------------------------------|\n| `db`                 | string                | The database name |\nInfluxDB HTTP API endpoints use standard HTTP request and response headers.\nThe following table shows common headers used by many InfluxDB API endpoints.\nSome endpoints may use other headers that perform functions more specific to those endpoints--for example,\nthe write endpoints accept the `Content-Encoding` header to indicate that line protocol is compressed in the request body.\n| Header                   | Value type            | Description                                |\n|:------------------------ |:--------------------- |:-------------------------------------------|\n| `Accept`                 | string                | The content type that the client can understand. |\n| `Authorization`          | string                | The authorization scheme and credential. |\n| `Content-Length`         | integer               | The size of the entity-body, in bytes. |\n| `Content-Type`           | string                | The format of the data in the request body. |\n",
+        "source": "static/openapi/influxdb3-enterprise/tags/tags/ref-headers-and-parameters.yaml",
+        "staticFilePath": "/openapi/influxdb3-enterprise/tags/tags/ref-headers-and-parameters.yaml"
+      }
+    },
+    {
+      "path": "api/migrate-from-influxdb-v1-or-v2",
+      "fields": {
+        "name": "Migrate from InfluxDB v1 or v2",
+        "describes": [],
+        "title": "Migrate from InfluxDB v1 or v2",
+        "description": "Migrate your existing InfluxDB v1 or v2 workloads to InfluxDB 3.\nInfluxDB 3 provides compatibility endpoints that work with InfluxDB 1.x and 2.x client libraries and tools.\nOperations marked with <span class=\"api-compat-badge api-compat-badge--v1\">v1</span> or <span class=\"api-compat-badge api-compat-badge--v2\">v2</span> badges are compatible with the respective InfluxDB version.\n### Migration guides\n- [Migrate from InfluxDB v1](/influxdb3/enterprise/guides/migrate/influxdb-1x/) - For users migrating from InfluxDB 1.x\n- [Migrate from InfluxDB v2](/influxdb3/enterprise/guides/migrate/influxdb-2x/) - For users migrating from InfluxDB 2.x or Cloud\n- [Use compatibility APIs to write data](/influxdb3/enterprise/write-data/http-api/compatibility-apis/) - v1 and v2 write endpoints\n- [Use the v1 HTTP query API](/influxdb3/enterprise/query-data/execute-queries/influxdb-v1-api/) - InfluxQL queries via HTTP\n",
+        "tag": "Migrate from InfluxDB v1 or v2",
+        "isConceptual": true,
+        "menuGroup": "Other",
+        "operations": [],
+        "tagDescription": "Migrate your existing InfluxDB v1 or v2 workloads to InfluxDB 3.\nInfluxDB 3 provides compatibility endpoints that work with InfluxDB 1.x and 2.x client libraries and tools.\nOperations marked with <span class=\"api-compat-badge api-compat-badge--v1\">v1</span> or <span class=\"api-compat-badge api-compat-badge--v2\">v2</span> badges are compatible with the respective InfluxDB version.\n### Migration guides\n- [Migrate from InfluxDB v1](/influxdb3/enterprise/guides/migrate/influxdb-1x/) - For users migrating from InfluxDB 1.x\n- [Migrate from InfluxDB v2](/influxdb3/enterprise/guides/migrate/influxdb-2x/) - For users migrating from InfluxDB 2.x or Cloud\n- [Use compatibility APIs to write data](/influxdb3/enterprise/write-data/http-api/compatibility-apis/) - v1 and v2 write endpoints\n- [Use the v1 HTTP query API](/influxdb3/enterprise/query-data/execute-queries/influxdb-v1-api/) - InfluxQL queries via HTTP\n",
+        "source": "static/openapi/influxdb3-enterprise/tags/tags/ref-migrate-from-influxdb-v1-or-v2.yaml",
+        "staticFilePath": "/openapi/influxdb3-enterprise/tags/tags/ref-migrate-from-influxdb-v1-or-v2.yaml"
+      }
+    },
+    {
+      "path": "api/processing-engine",
+      "fields": {
+        "name": "Processing engine",
+        "describes": [
+          "/api/v3/configure/processing_engine_trigger",
+          "/api/v3/configure/processing_engine_trigger/disable",
+          "/api/v3/configure/processing_engine_trigger/enable",
+          "/api/v3/configure/plugin_environment/install_packages",
+          "/api/v3/configure/plugin_environment/install_requirements",
+          "/api/v3/plugin_test/wal",
+          "/api/v3/plugin_test/schedule",
+          "/api/v3/engine/{request_path}",
+          "/api/v3/plugins/files",
+          "/api/v3/plugins/directory"
+        ],
+        "title": "Processing engine",
+        "description": "Manage Processing engine triggers, test plugins, and send requests to trigger On Request plugins.\nInfluxDB 3 Enterprise provides the InfluxDB 3 processing engine, an embedded Python VM that can dynamically load and trigger Python plugins in response to events in your database.\nUse Processing engine plugins and triggers to run code and perform tasks for different database events.\nTo get started with the processing engine, see the [Processing engine and Python plugins](/influxdb3/enterprise/processing-engine/) guide.\n",
+        "tag": "Processing engine",
+        "isConceptual": false,
+        "menuGroup": "Processing Engine",
+        "operations": [
+          {
+            "operationId": "PostConfigureProcessingEngineTrigger",
+            "method": "POST",
+            "path": "/api/v3/configure/processing_engine_trigger",
+            "summary": "Create processing engine trigger",
+            "tags": [
+              "Processing engine"
+            ]
+          },
+          {
+            "operationId": "DeleteConfigureProcessingEngineTrigger",
+            "method": "DELETE",
+            "path": "/api/v3/configure/processing_engine_trigger",
+            "summary": "Delete processing engine trigger",
+            "tags": [
+              "Processing engine"
+            ]
+          },
+          {
+            "operationId": "PostDisableProcessingEngineTrigger",
+            "method": "POST",
+            "path": "/api/v3/configure/processing_engine_trigger/disable",
+            "summary": "Disable processing engine trigger",
+            "tags": [
+              "Processing engine"
+            ]
+          },
+          {
+            "operationId": "PostEnableProcessingEngineTrigger",
+            "method": "POST",
+            "path": "/api/v3/configure/processing_engine_trigger/enable",
+            "summary": "Enable processing engine trigger",
+            "tags": [
+              "Processing engine"
+            ]
+          },
+          {
+            "operationId": "PostInstallPluginPackages",
+            "method": "POST",
+            "path": "/api/v3/configure/plugin_environment/install_packages",
+            "summary": "Install plugin packages",
+            "tags": [
+              "Processing engine"
+            ]
+          },
+          {
+            "operationId": "PostInstallPluginRequirements",
+            "method": "POST",
+            "path": "/api/v3/configure/plugin_environment/install_requirements",
+            "summary": "Install plugin requirements",
+            "tags": [
+              "Processing engine"
+            ]
+          },
+          {
+            "operationId": "PostTestWALPlugin",
+            "method": "POST",
+            "path": "/api/v3/plugin_test/wal",
+            "summary": "Test WAL plugin",
+            "tags": [
+              "Processing engine"
+            ]
+          },
+          {
+            "operationId": "PostTestSchedulingPlugin",
+            "method": "POST",
+            "path": "/api/v3/plugin_test/schedule",
+            "summary": "Test scheduling plugin",
+            "tags": [
+              "Processing engine"
+            ]
+          },
+          {
+            "operationId": "GetProcessingEnginePluginRequest",
+            "method": "GET",
+            "path": "/api/v3/engine/{request_path}",
+            "summary": "On Request processing engine plugin request",
+            "tags": [
+              "Processing engine"
+            ]
+          },
+          {
+            "operationId": "PostProcessingEnginePluginRequest",
+            "method": "POST",
+            "path": "/api/v3/engine/{request_path}",
+            "summary": "On Request processing engine plugin request",
+            "tags": [
+              "Processing engine"
+            ]
+          },
+          {
+            "operationId": "PutPluginFile",
+            "method": "PUT",
+            "path": "/api/v3/plugins/files",
+            "summary": "Update plugin file",
+            "tags": [
+              "Processing engine"
+            ]
+          },
+          {
+            "operationId": "PutPluginDirectory",
+            "method": "PUT",
+            "path": "/api/v3/plugins/directory",
+            "summary": "Update plugin directory",
+            "tags": [
+              "Processing engine"
+            ]
+          }
+        ],
+        "tagDescription": "Manage Processing engine triggers, test plugins, and send requests to trigger On Request plugins.\nInfluxDB 3 Enterprise provides the InfluxDB 3 processing engine, an embedded Python VM that can dynamically load and trigger Python plugins in response to events in your database.\nUse Processing engine plugins and triggers to run code and perform tasks for different database events.\nTo get started with the processing engine, see the [Processing engine and Python plugins](/influxdb3/enterprise/processing-engine/) guide.\n",
+        "source": "static/openapi/influxdb3-enterprise/tags/tags/ref-processing-engine.yaml",
+        "staticFilePath": "/openapi/influxdb3-enterprise/tags/tags/ref-processing-engine.yaml"
+      }
+    },
+    {
+      "path": "api/query-data",
+      "fields": {
+        "name": "Query data",
+        "describes": [
+          "/api/v3/query_sql",
+          "/api/v3/query_influxql",
+          "/query"
+        ],
+        "title": "Query data",
+        "description": "Query data using SQL or InfluxQL",
+        "tag": "Query data",
+        "isConceptual": false,
+        "menuGroup": "Data Operations",
+        "operations": [
+          {
+            "operationId": "GetExecuteQuerySQL",
+            "method": "GET",
+            "path": "/api/v3/query_sql",
+            "summary": "Execute SQL query",
+            "tags": [
+              "Query data"
+            ]
+          },
+          {
+            "operationId": "PostExecuteQuerySQL",
+            "method": "POST",
+            "path": "/api/v3/query_sql",
+            "summary": "Execute SQL query",
+            "tags": [
+              "Query data"
+            ]
+          },
+          {
+            "operationId": "GetExecuteInfluxQLQuery",
+            "method": "GET",
+            "path": "/api/v3/query_influxql",
+            "summary": "Execute InfluxQL query",
+            "tags": [
+              "Query data"
+            ]
+          },
+          {
+            "operationId": "PostExecuteQueryInfluxQL",
+            "method": "POST",
+            "path": "/api/v3/query_influxql",
+            "summary": "Execute InfluxQL query",
+            "tags": [
+              "Query data"
+            ]
+          },
+          {
+            "operationId": "GetV1ExecuteQuery",
+            "method": "GET",
+            "path": "/query",
+            "summary": "Execute InfluxQL query (v1-compatible)",
+            "tags": [
+              "Query data"
+            ],
+            "compatVersion": "v1",
+            "externalDocs": {
+              "description": "Use the InfluxDB v1 HTTP query API and InfluxQL to query data",
+              "url": "/influxdb3/enterprise/query-data/execute-queries/influxdb-v1-api/"
+            }
+          },
+          {
+            "operationId": "PostExecuteV1Query",
+            "method": "POST",
+            "path": "/query",
+            "summary": "Execute InfluxQL query (v1-compatible)",
+            "tags": [
+              "Query data"
+            ],
+            "compatVersion": "v1",
+            "externalDocs": {
+              "description": "Use the InfluxDB v1 HTTP query API and InfluxQL to query data",
+              "url": "/influxdb3/enterprise/query-data/execute-queries/influxdb-v1-api/"
+            }
+          }
+        ],
+        "tagDescription": "Query data using SQL or InfluxQL",
+        "related": [
+          "/influxdb3/enterprise/query-data/execute-queries/influxdb-v1-api/"
+        ],
+        "source": "static/openapi/influxdb3-enterprise/tags/tags/ref-query-data.yaml",
+        "staticFilePath": "/openapi/influxdb3-enterprise/tags/tags/ref-query-data.yaml"
+      }
+    },
+    {
+      "path": "api/quick-start",
+      "fields": {
+        "name": "Quick start",
+        "describes": [],
+        "title": "Quick start",
+        "description": "1. [Create an admin token](#section/Authentication) to authorize API requests.\n   ```bash\n   curl -X POST \"http://localhost:8181/api/v3/configure/token/admin\"\n   ```\n2. [Check the status](#section/Server-information) of the InfluxDB server.\n   ```bash\n   curl \"http://localhost:8181/health\" \\\n      --header \"Authorization: Bearer ADMIN_TOKEN\"\n   ```\n3. [Write data](#operation/PostWriteLP) to InfluxDB.\n   ```bash\n   curl \"http://localhost:8181/api/v3/write_lp?db=sensors&precision=auto\"\n     --header \"Authorization: Bearer ADMIN_TOKEN\" \\\n     --data-raw \"home,room=Kitchen temp=72.0\n    home,room=Living\\ room temp=71.5\"\n   ```\n   If all data is written, the response is `204 No Content`.\n4. [Query data](#operation/GetExecuteQuerySQL) from InfluxDB.\n   ```bash\n   curl -G \"http://localhost:8181/api/v3/query_sql\" \\\n     --header \"Authorization: Bearer ADMIN_TOKEN\" \\\n     --data-urlencode \"db=sensors\" \\\n     --data-urlencode \"q=SELECT * FROM home WHERE room='Living room'\" \\\n     --data-urlencode \"format=jsonl\"\n   ```\n   \n   Output:\n   ```jsonl\n   {\"room\":\"Living room\",\"temp\":71.5,\"time\":\"2025-02-25T20:19:34.984098\"}\n   ```\n  \nFor more information about using InfluxDB 3 Enterprise, see the [Get started](/influxdb3/enterprise/get-started/) guide.\n",
+        "tag": "Quick start",
+        "isConceptual": true,
+        "menuGroup": "Concepts",
+        "operations": [],
+        "tagDescription": "1. [Create an admin token](#section/Authentication) to authorize API requests.\n   ```bash\n   curl -X POST \"http://localhost:8181/api/v3/configure/token/admin\"\n   ```\n2. [Check the status](#section/Server-information) of the InfluxDB server.\n   ```bash\n   curl \"http://localhost:8181/health\" \\\n      --header \"Authorization: Bearer ADMIN_TOKEN\"\n   ```\n3. [Write data](#operation/PostWriteLP) to InfluxDB.\n   ```bash\n   curl \"http://localhost:8181/api/v3/write_lp?db=sensors&precision=auto\"\n     --header \"Authorization: Bearer ADMIN_TOKEN\" \\\n     --data-raw \"home,room=Kitchen temp=72.0\n    home,room=Living\\ room temp=71.5\"\n   ```\n   If all data is written, the response is `204 No Content`.\n4. [Query data](#operation/GetExecuteQuerySQL) from InfluxDB.\n   ```bash\n   curl -G \"http://localhost:8181/api/v3/query_sql\" \\\n     --header \"Authorization: Bearer ADMIN_TOKEN\" \\\n     --data-urlencode \"db=sensors\" \\\n     --data-urlencode \"q=SELECT * FROM home WHERE room='Living room'\" \\\n     --data-urlencode \"format=jsonl\"\n   ```\n   \n   Output:\n   ```jsonl\n   {\"room\":\"Living room\",\"temp\":71.5,\"time\":\"2025-02-25T20:19:34.984098\"}\n   ```\n  \nFor more information about using InfluxDB 3 Enterprise, see the [Get started](/influxdb3/enterprise/get-started/) guide.\n",
+        "source": "static/openapi/influxdb3-enterprise/tags/tags/ref-quick-start.yaml",
+        "staticFilePath": "/openapi/influxdb3-enterprise/tags/tags/ref-quick-start.yaml"
+      }
+    },
+    {
+      "path": "api/server-information",
+      "fields": {
+        "name": "Server information",
+        "describes": [
+          "/health",
+          "/api/v1/health",
+          "/ping",
+          "/metrics",
+          "/api/v3/show/license"
+        ],
+        "title": "Server information",
+        "description": "Retrieve server metrics, status, and version information",
+        "tag": "Server information",
+        "isConceptual": false,
+        "menuGroup": "Server",
+        "operations": [
+          {
+            "operationId": "GetHealth",
+            "method": "GET",
+            "path": "/health",
+            "summary": "Health check",
+            "tags": [
+              "Server information"
+            ]
+          },
+          {
+            "operationId": "GetHealthV1",
+            "method": "GET",
+            "path": "/api/v1/health",
+            "summary": "Health check (v1-compatible)",
+            "tags": [
+              "Server information"
+            ],
+            "compatVersion": "v1"
+          },
+          {
+            "operationId": "GetPing",
+            "method": "GET",
+            "path": "/ping",
+            "summary": "Ping the server",
+            "tags": [
+              "Server information"
+            ]
+          },
+          {
+            "operationId": "GetMetrics",
+            "method": "GET",
+            "path": "/metrics",
+            "summary": "Metrics",
+            "tags": [
+              "Server information"
+            ]
+          },
+          {
+            "operationId": "GetShowLicense",
+            "method": "GET",
+            "path": "/api/v3/show/license",
+            "summary": "Show license information",
+            "tags": [
+              "Server information"
+            ]
+          }
+        ],
+        "tagDescription": "Retrieve server metrics, status, and version information",
+        "source": "static/openapi/influxdb3-enterprise/tags/tags/ref-server-information.yaml",
+        "staticFilePath": "/openapi/influxdb3-enterprise/tags/tags/ref-server-information.yaml"
+      }
+    },
+    {
+      "path": "api/table",
+      "fields": {
+        "name": "Table",
+        "describes": [
+          "/api/v3/configure/table"
+        ],
+        "title": "Table",
+        "description": "Manage table schemas and data",
+        "tag": "Table",
+        "isConceptual": false,
+        "menuGroup": "Administration",
+        "operations": [
+          {
+            "operationId": "PostConfigureTable",
+            "method": "POST",
+            "path": "/api/v3/configure/table",
+            "summary": "Create a table",
+            "tags": [
+              "Table"
+            ]
+          },
+          {
+            "operationId": "PatchConfigureTable",
+            "method": "PATCH",
+            "path": "/api/v3/configure/table",
+            "summary": "Update a table",
+            "tags": [
+              "Table"
+            ]
+          },
+          {
+            "operationId": "DeleteConfigureTable",
+            "method": "DELETE",
+            "path": "/api/v3/configure/table",
+            "summary": "Delete a table",
+            "tags": [
+              "Table"
+            ]
+          }
+        ],
+        "tagDescription": "Manage table schemas and data",
+        "source": "static/openapi/influxdb3-enterprise/tags/tags/ref-table.yaml",
+        "staticFilePath": "/openapi/influxdb3-enterprise/tags/tags/ref-table.yaml"
+      }
+    },
+    {
+      "path": "api/write-data",
+      "fields": {
+        "name": "Write data",
+        "describes": [
+          "/write",
+          "/api/v2/write",
+          "/api/v3/write_lp"
+        ],
+        "title": "Write data",
+        "description": "Write data to InfluxDB 3 using line protocol format.\n#### Timestamp precision across write APIs\nInfluxDB 3 provides multiple write endpoints for compatibility with different InfluxDB versions.\nThe following table compares timestamp precision support across v1, v2, and v3 write APIs:\n| Precision | v1 (`/write`) | v2 (`/api/v2/write`) | v3 (`/api/v3/write_lp`) |\n|-----------|---------------|----------------------|-------------------------|\n| **Auto detection** | ❌ No | ❌ No | ✅ `auto` (default) |\n| **Seconds** | ✅ `s` | ✅ `s` | ✅ `second` |\n| **Milliseconds** | ✅ `ms` | ✅ `ms` | ✅ `millisecond` |\n| **Microseconds** | ✅ `u` or `µ` | ✅ `us` | ✅ `microsecond` |\n| **Nanoseconds** | ✅ `ns` | ✅ `ns` | ✅ `nanosecond` |\n| **Minutes** | ✅ `m` | ❌ No | ❌ No |\n| **Hours** | ✅ `h` | ❌ No | ❌ No |\n| **Default** | Nanosecond | Nanosecond | **Auto** (guessed) |\nAll timestamps are stored internally as nanoseconds.\n",
+        "tag": "Write data",
+        "isConceptual": false,
+        "menuGroup": "Data Operations",
+        "operations": [
+          {
+            "operationId": "PostV1Write",
+            "method": "POST",
+            "path": "/write",
+            "summary": "Write line protocol (v1-compatible)",
+            "tags": [
+              "Write data"
+            ],
+            "compatVersion": "v1",
+            "externalDocs": {
+              "description": "Use compatibility APIs to write data",
+              "url": "/influxdb3/enterprise/write-data/http-api/compatibility-apis/"
+            }
+          },
+          {
+            "operationId": "PostV2Write",
+            "method": "POST",
+            "path": "/api/v2/write",
+            "summary": "Write line protocol (v2-compatible)",
+            "tags": [
+              "Write data"
+            ],
+            "compatVersion": "v2",
+            "externalDocs": {
+              "description": "Use compatibility APIs to write data",
+              "url": "/influxdb3/enterprise/write-data/http-api/compatibility-apis/"
+            }
+          },
+          {
+            "operationId": "PostWriteLP",
+            "method": "POST",
+            "path": "/api/v3/write_lp",
+            "summary": "Write line protocol",
+            "tags": [
+              "Write data"
+            ]
+          }
+        ],
+        "tagDescription": "Write data to InfluxDB 3 using line protocol format.\n#### Timestamp precision across write APIs\nInfluxDB 3 provides multiple write endpoints for compatibility with different InfluxDB versions.\nThe following table compares timestamp precision support across v1, v2, and v3 write APIs:\n| Precision | v1 (`/write`) | v2 (`/api/v2/write`) | v3 (`/api/v3/write_lp`) |\n|-----------|---------------|----------------------|-------------------------|\n| **Auto detection** | ❌ No | ❌ No | ✅ `auto` (default) |\n| **Seconds** | ✅ `s` | ✅ `s` | ✅ `second` |\n| **Milliseconds** | ✅ `ms` | ✅ `ms` | ✅ `millisecond` |\n| **Microseconds** | ✅ `u` or `µ` | ✅ `us` | ✅ `microsecond` |\n| **Nanoseconds** | ✅ `ns` | ✅ `ns` | ✅ `nanosecond` |\n| **Minutes** | ✅ `m` | ❌ No | ❌ No |\n| **Hours** | ✅ `h` | ❌ No | ❌ No |\n| **Default** | Nanosecond | Nanosecond | **Auto** (guessed) |\nAll timestamps are stored internally as nanoseconds.\n",
+        "related": [
+          "/influxdb3/enterprise/write-data/http-api/compatibility-apis/"
+        ],
+        "source": "static/openapi/influxdb3-enterprise/tags/tags/ref-write-data.yaml",
+        "staticFilePath": "/openapi/influxdb3-enterprise/tags/tags/ref-write-data.yaml"
+      }
+    }
+  ]
+}
\ No newline at end of file
diff --git a/data/article_data/influxdb/influxdb3_enterprise/articles.yml b/data/article_data/influxdb/influxdb3_enterprise/articles.yml
new file mode 100644
index 0000000000..acc7d42625
--- /dev/null
+++ b/data/article_data/influxdb/influxdb3_enterprise/articles.yml
@@ -0,0 +1,963 @@
+articles:
+  - path: api/auth-token
+    fields:
+      name: Auth token
+      describes:
+        - /api/v3/configure/enterprise/token
+        - /api/v3/configure/token/admin
+        - /api/v3/configure/token/admin/regenerate
+        - /api/v3/configure/token
+        - /api/v3/configure/token/named_admin
+      title: Auth token
+      description: Manage tokens for authentication and authorization
+      tag: Auth token
+      isConceptual: false
+      menuGroup: Other
+      operations:
+        - operationId: PostCreateResourceToken
+          method: POST
+          path: /api/v3/configure/enterprise/token
+          summary: Create a resource token
+          tags:
+            - Auth token
+        - operationId: PostCreateAdminToken
+          method: POST
+          path: /api/v3/configure/token/admin
+          summary: Create admin token
+          tags:
+            - Auth token
+        - operationId: PostRegenerateAdminToken
+          method: POST
+          path: /api/v3/configure/token/admin/regenerate
+          summary: Regenerate admin token
+          tags:
+            - Auth token
+        - operationId: DeleteToken
+          method: DELETE
+          path: /api/v3/configure/token
+          summary: Delete token
+          tags:
+            - Auth token
+        - operationId: PostCreateNamedAdminToken
+          method: POST
+          path: /api/v3/configure/token/named_admin
+          summary: Create named admin token
+          tags:
+            - Auth token
+      tagDescription: Manage tokens for authentication and authorization
+      source: static/openapi/influxdb3-enterprise/tags/tags/ref-auth-token.yaml
+      staticFilePath: /openapi/influxdb3-enterprise/tags/tags/ref-auth-token.yaml
+  - path: api/authentication
+    fields:
+      name: Authentication
+      describes:
+        - /api/v3/configure/enterprise/token
+        - /api/v3/configure/token/admin
+        - /api/v3/configure/token/admin/regenerate
+        - /api/v3/configure/token
+        - /api/v3/configure/token/named_admin
+      title: Authentication
+      description: >
+        Depending on your workflow, use one of the following schemes to
+        authenticate to the InfluxDB 3 API:
+
+        | Authentication scheme | Works with |
+
+        |:----------------------|:-----------|
+
+        | Bearer authentication | All endpoints |
+
+        | Token authentication  | v1, v2 endpoints |
+
+        | Basic authentication  | v1 endpoints |
+
+        | Querystring authentication | v1 endpoints |
+
+        See the **Security Schemes** section below for details on each
+        authentication method.
+      tag: Authentication
+      isConceptual: true
+      menuGroup: Concepts
+      operations:
+        - operationId: PostCreateResourceToken
+          method: POST
+          path: /api/v3/configure/enterprise/token
+          summary: Create a resource token
+          tags:
+            - Authentication
+        - operationId: PostCreateAdminToken
+          method: POST
+          path: /api/v3/configure/token/admin
+          summary: Create admin token
+          tags:
+            - Authentication
+        - operationId: PostRegenerateAdminToken
+          method: POST
+          path: /api/v3/configure/token/admin/regenerate
+          summary: Regenerate admin token
+          tags:
+            - Authentication
+        - operationId: DeleteToken
+          method: DELETE
+          path: /api/v3/configure/token
+          summary: Delete token
+          tags:
+            - Authentication
+        - operationId: PostCreateNamedAdminToken
+          method: POST
+          path: /api/v3/configure/token/named_admin
+          summary: Create named admin token
+          tags:
+            - Authentication
+      tagDescription: >
+        Depending on your workflow, use one of the following schemes to
+        authenticate to the InfluxDB 3 API:
+
+        | Authentication scheme | Works with |
+
+        |:----------------------|:-----------|
+
+        | Bearer authentication | All endpoints |
+
+        | Token authentication  | v1, v2 endpoints |
+
+        | Basic authentication  | v1 endpoints |
+
+        | Querystring authentication | v1 endpoints |
+
+        See the **Security Schemes** section below for details on each
+        authentication method.
+      source: static/openapi/influxdb3-enterprise/tags/tags/ref-authentication.yaml
+      staticFilePath: /openapi/influxdb3-enterprise/tags/tags/ref-authentication.yaml
+  - path: api/cache-data
+    fields:
+      name: Cache data
+      describes:
+        - /api/v3/configure/distinct_cache
+        - /api/v3/configure/last_cache
+      title: Cache data
+      description: >
+        Manage the in-memory cache.
+
+        #### Distinct Value Cache
+
+        The Distinct Value Cache (DVC) lets you cache distinct
+
+        values of one or more columns in a table, improving the performance of
+
+        queries that return distinct tag and field values. 
+
+        The DVC is an in-memory cache that stores distinct values for specific
+        columns
+
+        in a table. When you create an DVC, you can specify what columns'
+        distinct
+
+        values to cache, the maximum number of distinct value combinations to
+        cache, and
+
+        the maximum age of cached values. A DVC is associated with a table,
+        which can
+
+        have multiple DVCs.
+
+        #### Last value cache
+
+        The Last Value Cache (LVC) lets you cache the most recent
+
+        values for specific fields in a table, improving the performance of
+        queries that
+
+        return the most recent value of a field for specific series or the last
+        N values
+
+        of a field.
+
+        The LVC is an in-memory cache that stores the last N number of values
+        for
+
+        specific fields of series in a table. When you create an LVC, you can
+        specify
+
+        what fields to cache, what tags to use to identify each series, and the
+
+        number of values to cache for each unique series.
+
+        An LVC is associated with a table, which can have multiple LVCs.
+
+        #### Related guides
+
+        - [Manage the Distinct Value
+        Cache](/influxdb3/enterprise/admin/distinct-value-cache/)
+
+        - [Manage the Last Value
+        Cache](/influxdb3/enterprise/admin/last-value-cache/)
+      tag: Cache data
+      isConceptual: false
+      menuGroup: Data Operations
+      operations:
+        - operationId: PostConfigureDistinctCache
+          method: POST
+          path: /api/v3/configure/distinct_cache
+          summary: Create distinct cache
+          tags:
+            - Cache data
+        - operationId: DeleteConfigureDistinctCache
+          method: DELETE
+          path: /api/v3/configure/distinct_cache
+          summary: Delete distinct cache
+          tags:
+            - Cache data
+        - operationId: PostConfigureLastCache
+          method: POST
+          path: /api/v3/configure/last_cache
+          summary: Create last cache
+          tags:
+            - Cache data
+        - operationId: DeleteConfigureLastCache
+          method: DELETE
+          path: /api/v3/configure/last_cache
+          summary: Delete last cache
+          tags:
+            - Cache data
+      tagDescription: >
+        Manage the in-memory cache.
+
+        #### Distinct Value Cache
+
+        The Distinct Value Cache (DVC) lets you cache distinct
+
+        values of one or more columns in a table, improving the performance of
+
+        queries that return distinct tag and field values. 
+
+        The DVC is an in-memory cache that stores distinct values for specific
+        columns
+
+        in a table. When you create an DVC, you can specify what columns'
+        distinct
+
+        values to cache, the maximum number of distinct value combinations to
+        cache, and
+
+        the maximum age of cached values. A DVC is associated with a table,
+        which can
+
+        have multiple DVCs.
+
+        #### Last value cache
+
+        The Last Value Cache (LVC) lets you cache the most recent
+
+        values for specific fields in a table, improving the performance of
+        queries that
+
+        return the most recent value of a field for specific series or the last
+        N values
+
+        of a field.
+
+        The LVC is an in-memory cache that stores the last N number of values
+        for
+
+        specific fields of series in a table. When you create an LVC, you can
+        specify
+
+        what fields to cache, what tags to use to identify each series, and the
+
+        number of values to cache for each unique series.
+
+        An LVC is associated with a table, which can have multiple LVCs.
+
+        #### Related guides
+
+        - [Manage the Distinct Value
+        Cache](/influxdb3/enterprise/admin/distinct-value-cache/)
+
+        - [Manage the Last Value
+        Cache](/influxdb3/enterprise/admin/last-value-cache/)
+      source: static/openapi/influxdb3-enterprise/tags/tags/ref-cache-data.yaml
+      staticFilePath: /openapi/influxdb3-enterprise/tags/tags/ref-cache-data.yaml
+  - path: api/database
+    fields:
+      name: Database
+      describes:
+        - /api/v3/configure/database
+        - /api/v3/configure/database/retention_period
+        - /api/v3/configure/database/{db}
+      title: Database
+      description: Manage databases
+      tag: Database
+      isConceptual: false
+      menuGroup: Administration
+      operations:
+        - operationId: GetConfigureDatabase
+          method: GET
+          path: /api/v3/configure/database
+          summary: List databases
+          tags:
+            - Database
+        - operationId: PostConfigureDatabase
+          method: POST
+          path: /api/v3/configure/database
+          summary: Create a database
+          tags:
+            - Database
+        - operationId: DeleteConfigureDatabase
+          method: DELETE
+          path: /api/v3/configure/database
+          summary: Delete a database
+          tags:
+            - Database
+        - operationId: DeleteDatabaseRetentionPeriod
+          method: DELETE
+          path: /api/v3/configure/database/retention_period
+          summary: Remove database retention period
+          tags:
+            - Database
+        - operationId: PatchConfigureDatabase
+          method: PATCH
+          path: /api/v3/configure/database/{db}
+          summary: Update a database
+          tags:
+            - Database
+      tagDescription: Manage databases
+      source: static/openapi/influxdb3-enterprise/tags/tags/ref-database.yaml
+      staticFilePath: /openapi/influxdb3-enterprise/tags/tags/ref-database.yaml
+  - path: api/headers-and-parameters
+    fields:
+      name: Headers and parameters
+      describes: []
+      title: Headers and parameters
+      description: >
+        Most InfluxDB API endpoints require parameters in the request--for
+        example, specifying the database to use.
+
+        ### Common parameters
+
+        The following table shows common parameters used by many InfluxDB API
+        endpoints.
+
+        Many endpoints may require other parameters in the query string or in
+        the
+
+        request body that perform functions specific to those endpoints.
+
+        | Query parameter          | Value type            |
+        Description                                |
+
+        |:------------------------ |:---------------------
+        |:-------------------------------------------|
+
+        | `db`                 | string                | The database name |
+
+        InfluxDB HTTP API endpoints use standard HTTP request and response
+        headers.
+
+        The following table shows common headers used by many InfluxDB API
+        endpoints.
+
+        Some endpoints may use other headers that perform functions more
+        specific to those endpoints--for example,
+
+        the write endpoints accept the `Content-Encoding` header to indicate
+        that line protocol is compressed in the request body.
+
+        | Header                   | Value type            |
+        Description                                |
+
+        |:------------------------ |:---------------------
+        |:-------------------------------------------|
+
+        | `Accept`                 | string                | The content type
+        that the client can understand. |
+
+        | `Authorization`          | string                | The authorization
+        scheme and credential. |
+
+        | `Content-Length`         | integer               | The size of the
+        entity-body, in bytes. |
+
+        | `Content-Type`           | string                | The format of the
+        data in the request body. |
+      tag: Headers and parameters
+      isConceptual: true
+      menuGroup: Concepts
+      operations: []
+      tagDescription: >
+        Most InfluxDB API endpoints require parameters in the request--for
+        example, specifying the database to use.
+
+        ### Common parameters
+
+        The following table shows common parameters used by many InfluxDB API
+        endpoints.
+
+        Many endpoints may require other parameters in the query string or in
+        the
+
+        request body that perform functions specific to those endpoints.
+
+        | Query parameter          | Value type            |
+        Description                                |
+
+        |:------------------------ |:---------------------
+        |:-------------------------------------------|
+
+        | `db`                 | string                | The database name |
+
+        InfluxDB HTTP API endpoints use standard HTTP request and response
+        headers.
+
+        The following table shows common headers used by many InfluxDB API
+        endpoints.
+
+        Some endpoints may use other headers that perform functions more
+        specific to those endpoints--for example,
+
+        the write endpoints accept the `Content-Encoding` header to indicate
+        that line protocol is compressed in the request body.
+
+        | Header                   | Value type            |
+        Description                                |
+
+        |:------------------------ |:---------------------
+        |:-------------------------------------------|
+
+        | `Accept`                 | string                | The content type
+        that the client can understand. |
+
+        | `Authorization`          | string                | The authorization
+        scheme and credential. |
+
+        | `Content-Length`         | integer               | The size of the
+        entity-body, in bytes. |
+
+        | `Content-Type`           | string                | The format of the
+        data in the request body. |
+      source: >-
+        static/openapi/influxdb3-enterprise/tags/tags/ref-headers-and-parameters.yaml
+      staticFilePath: /openapi/influxdb3-enterprise/tags/tags/ref-headers-and-parameters.yaml
+  - path: api/migrate-from-influxdb-v1-or-v2
+    fields:
+      name: Migrate from InfluxDB v1 or v2
+      describes: []
+      title: Migrate from InfluxDB v1 or v2
+      description: >
+        Migrate your existing InfluxDB v1 or v2 workloads to InfluxDB 3.
+
+        InfluxDB 3 provides compatibility endpoints that work with InfluxDB 1.x
+        and 2.x client libraries and tools.
+
+        Operations marked with <span class="api-compat-badge
+        api-compat-badge--v1">v1</span> or <span class="api-compat-badge
+        api-compat-badge--v2">v2</span> badges are compatible with the
+        respective InfluxDB version.
+
+        ### Migration guides
+
+        - [Migrate from InfluxDB
+        v1](/influxdb3/enterprise/guides/migrate/influxdb-1x/) - For users
+        migrating from InfluxDB 1.x
+
+        - [Migrate from InfluxDB
+        v2](/influxdb3/enterprise/guides/migrate/influxdb-2x/) - For users
+        migrating from InfluxDB 2.x or Cloud
+
+        - [Use compatibility APIs to write
+        data](/influxdb3/enterprise/write-data/http-api/compatibility-apis/) -
+        v1 and v2 write endpoints
+
+        - [Use the v1 HTTP query
+        API](/influxdb3/enterprise/query-data/execute-queries/influxdb-v1-api/)
+        - InfluxQL queries via HTTP
+      tag: Migrate from InfluxDB v1 or v2
+      isConceptual: true
+      menuGroup: Other
+      operations: []
+      tagDescription: >
+        Migrate your existing InfluxDB v1 or v2 workloads to InfluxDB 3.
+
+        InfluxDB 3 provides compatibility endpoints that work with InfluxDB 1.x
+        and 2.x client libraries and tools.
+
+        Operations marked with <span class="api-compat-badge
+        api-compat-badge--v1">v1</span> or <span class="api-compat-badge
+        api-compat-badge--v2">v2</span> badges are compatible with the
+        respective InfluxDB version.
+
+        ### Migration guides
+
+        - [Migrate from InfluxDB
+        v1](/influxdb3/enterprise/guides/migrate/influxdb-1x/) - For users
+        migrating from InfluxDB 1.x
+
+        - [Migrate from InfluxDB
+        v2](/influxdb3/enterprise/guides/migrate/influxdb-2x/) - For users
+        migrating from InfluxDB 2.x or Cloud
+
+        - [Use compatibility APIs to write
+        data](/influxdb3/enterprise/write-data/http-api/compatibility-apis/) -
+        v1 and v2 write endpoints
+
+        - [Use the v1 HTTP query
+        API](/influxdb3/enterprise/query-data/execute-queries/influxdb-v1-api/)
+        - InfluxQL queries via HTTP
+      source: >-
+        static/openapi/influxdb3-enterprise/tags/tags/ref-migrate-from-influxdb-v1-or-v2.yaml
+      staticFilePath: >-
+        /openapi/influxdb3-enterprise/tags/tags/ref-migrate-from-influxdb-v1-or-v2.yaml
+  - path: api/processing-engine
+    fields:
+      name: Processing engine
+      describes:
+        - /api/v3/configure/processing_engine_trigger
+        - /api/v3/configure/processing_engine_trigger/disable
+        - /api/v3/configure/processing_engine_trigger/enable
+        - /api/v3/configure/plugin_environment/install_packages
+        - /api/v3/configure/plugin_environment/install_requirements
+        - /api/v3/plugin_test/wal
+        - /api/v3/plugin_test/schedule
+        - /api/v3/engine/{request_path}
+        - /api/v3/plugins/files
+        - /api/v3/plugins/directory
+      title: Processing engine
+      description: >
+        Manage Processing engine triggers, test plugins, and send requests to
+        trigger On Request plugins.
+
+        InfluxDB 3 Enterprise provides the InfluxDB 3 processing engine, an
+        embedded Python VM that can dynamically load and trigger Python plugins
+        in response to events in your database.
+
+        Use Processing engine plugins and triggers to run code and perform tasks
+        for different database events.
+
+        To get started with the processing engine, see the [Processing engine
+        and Python plugins](/influxdb3/enterprise/processing-engine/) guide.
+      tag: Processing engine
+      isConceptual: false
+      menuGroup: Processing Engine
+      operations:
+        - operationId: PostConfigureProcessingEngineTrigger
+          method: POST
+          path: /api/v3/configure/processing_engine_trigger
+          summary: Create processing engine trigger
+          tags:
+            - Processing engine
+        - operationId: DeleteConfigureProcessingEngineTrigger
+          method: DELETE
+          path: /api/v3/configure/processing_engine_trigger
+          summary: Delete processing engine trigger
+          tags:
+            - Processing engine
+        - operationId: PostDisableProcessingEngineTrigger
+          method: POST
+          path: /api/v3/configure/processing_engine_trigger/disable
+          summary: Disable processing engine trigger
+          tags:
+            - Processing engine
+        - operationId: PostEnableProcessingEngineTrigger
+          method: POST
+          path: /api/v3/configure/processing_engine_trigger/enable
+          summary: Enable processing engine trigger
+          tags:
+            - Processing engine
+        - operationId: PostInstallPluginPackages
+          method: POST
+          path: /api/v3/configure/plugin_environment/install_packages
+          summary: Install plugin packages
+          tags:
+            - Processing engine
+        - operationId: PostInstallPluginRequirements
+          method: POST
+          path: /api/v3/configure/plugin_environment/install_requirements
+          summary: Install plugin requirements
+          tags:
+            - Processing engine
+        - operationId: PostTestWALPlugin
+          method: POST
+          path: /api/v3/plugin_test/wal
+          summary: Test WAL plugin
+          tags:
+            - Processing engine
+        - operationId: PostTestSchedulingPlugin
+          method: POST
+          path: /api/v3/plugin_test/schedule
+          summary: Test scheduling plugin
+          tags:
+            - Processing engine
+        - operationId: GetProcessingEnginePluginRequest
+          method: GET
+          path: /api/v3/engine/{request_path}
+          summary: On Request processing engine plugin request
+          tags:
+            - Processing engine
+        - operationId: PostProcessingEnginePluginRequest
+          method: POST
+          path: /api/v3/engine/{request_path}
+          summary: On Request processing engine plugin request
+          tags:
+            - Processing engine
+        - operationId: PutPluginFile
+          method: PUT
+          path: /api/v3/plugins/files
+          summary: Update plugin file
+          tags:
+            - Processing engine
+        - operationId: PutPluginDirectory
+          method: PUT
+          path: /api/v3/plugins/directory
+          summary: Update plugin directory
+          tags:
+            - Processing engine
+      tagDescription: >
+        Manage Processing engine triggers, test plugins, and send requests to
+        trigger On Request plugins.
+
+        InfluxDB 3 Enterprise provides the InfluxDB 3 processing engine, an
+        embedded Python VM that can dynamically load and trigger Python plugins
+        in response to events in your database.
+
+        Use Processing engine plugins and triggers to run code and perform tasks
+        for different database events.
+
+        To get started with the processing engine, see the [Processing engine
+        and Python plugins](/influxdb3/enterprise/processing-engine/) guide.
+      source: static/openapi/influxdb3-enterprise/tags/tags/ref-processing-engine.yaml
+      staticFilePath: /openapi/influxdb3-enterprise/tags/tags/ref-processing-engine.yaml
+  - path: api/query-data
+    fields:
+      name: Query data
+      describes:
+        - /api/v3/query_sql
+        - /api/v3/query_influxql
+        - /query
+      title: Query data
+      description: Query data using SQL or InfluxQL
+      tag: Query data
+      isConceptual: false
+      menuGroup: Data Operations
+      operations:
+        - operationId: GetExecuteQuerySQL
+          method: GET
+          path: /api/v3/query_sql
+          summary: Execute SQL query
+          tags:
+            - Query data
+        - operationId: PostExecuteQuerySQL
+          method: POST
+          path: /api/v3/query_sql
+          summary: Execute SQL query
+          tags:
+            - Query data
+        - operationId: GetExecuteInfluxQLQuery
+          method: GET
+          path: /api/v3/query_influxql
+          summary: Execute InfluxQL query
+          tags:
+            - Query data
+        - operationId: PostExecuteQueryInfluxQL
+          method: POST
+          path: /api/v3/query_influxql
+          summary: Execute InfluxQL query
+          tags:
+            - Query data
+        - operationId: GetV1ExecuteQuery
+          method: GET
+          path: /query
+          summary: Execute InfluxQL query (v1-compatible)
+          tags:
+            - Query data
+          compatVersion: v1
+          externalDocs:
+            description: Use the InfluxDB v1 HTTP query API and InfluxQL to query data
+            url: /influxdb3/enterprise/query-data/execute-queries/influxdb-v1-api/
+        - operationId: PostExecuteV1Query
+          method: POST
+          path: /query
+          summary: Execute InfluxQL query (v1-compatible)
+          tags:
+            - Query data
+          compatVersion: v1
+          externalDocs:
+            description: Use the InfluxDB v1 HTTP query API and InfluxQL to query data
+            url: /influxdb3/enterprise/query-data/execute-queries/influxdb-v1-api/
+      tagDescription: Query data using SQL or InfluxQL
+      related:
+        - /influxdb3/enterprise/query-data/execute-queries/influxdb-v1-api/
+      source: static/openapi/influxdb3-enterprise/tags/tags/ref-query-data.yaml
+      staticFilePath: /openapi/influxdb3-enterprise/tags/tags/ref-query-data.yaml
+  - path: api/quick-start
+    fields:
+      name: Quick start
+      describes: []
+      title: Quick start
+      description: >
+        1. [Create an admin token](#section/Authentication) to authorize API
+        requests.
+           ```bash
+           curl -X POST "http://localhost:8181/api/v3/configure/token/admin"
+           ```
+        2. [Check the status](#section/Server-information) of the InfluxDB
+        server.
+           ```bash
+           curl "http://localhost:8181/health" \
+              --header "Authorization: Bearer ADMIN_TOKEN"
+           ```
+        3. [Write data](#operation/PostWriteLP) to InfluxDB.
+           ```bash
+           curl "http://localhost:8181/api/v3/write_lp?db=sensors&precision=auto"
+             --header "Authorization: Bearer ADMIN_TOKEN" \
+             --data-raw "home,room=Kitchen temp=72.0
+            home,room=Living\ room temp=71.5"
+           ```
+           If all data is written, the response is `204 No Content`.
+        4. [Query data](#operation/GetExecuteQuerySQL) from InfluxDB.
+           ```bash
+           curl -G "http://localhost:8181/api/v3/query_sql" \
+             --header "Authorization: Bearer ADMIN_TOKEN" \
+             --data-urlencode "db=sensors" \
+             --data-urlencode "q=SELECT * FROM home WHERE room='Living room'" \
+             --data-urlencode "format=jsonl"
+           ```
+           
+           Output:
+           ```jsonl
+           {"room":"Living room","temp":71.5,"time":"2025-02-25T20:19:34.984098"}
+           ```
+          
+        For more information about using InfluxDB 3 Enterprise, see the [Get
+        started](/influxdb3/enterprise/get-started/) guide.
+      tag: Quick start
+      isConceptual: true
+      menuGroup: Concepts
+      operations: []
+      tagDescription: >
+        1. [Create an admin token](#section/Authentication) to authorize API
+        requests.
+           ```bash
+           curl -X POST "http://localhost:8181/api/v3/configure/token/admin"
+           ```
+        2. [Check the status](#section/Server-information) of the InfluxDB
+        server.
+           ```bash
+           curl "http://localhost:8181/health" \
+              --header "Authorization: Bearer ADMIN_TOKEN"
+           ```
+        3. [Write data](#operation/PostWriteLP) to InfluxDB.
+           ```bash
+           curl "http://localhost:8181/api/v3/write_lp?db=sensors&precision=auto"
+             --header "Authorization: Bearer ADMIN_TOKEN" \
+             --data-raw "home,room=Kitchen temp=72.0
+            home,room=Living\ room temp=71.5"
+           ```
+           If all data is written, the response is `204 No Content`.
+        4. [Query data](#operation/GetExecuteQuerySQL) from InfluxDB.
+           ```bash
+           curl -G "http://localhost:8181/api/v3/query_sql" \
+             --header "Authorization: Bearer ADMIN_TOKEN" \
+             --data-urlencode "db=sensors" \
+             --data-urlencode "q=SELECT * FROM home WHERE room='Living room'" \
+             --data-urlencode "format=jsonl"
+           ```
+           
+           Output:
+           ```jsonl
+           {"room":"Living room","temp":71.5,"time":"2025-02-25T20:19:34.984098"}
+           ```
+          
+        For more information about using InfluxDB 3 Enterprise, see the [Get
+        started](/influxdb3/enterprise/get-started/) guide.
+      source: static/openapi/influxdb3-enterprise/tags/tags/ref-quick-start.yaml
+      staticFilePath: /openapi/influxdb3-enterprise/tags/tags/ref-quick-start.yaml
+  - path: api/server-information
+    fields:
+      name: Server information
+      describes:
+        - /health
+        - /api/v1/health
+        - /ping
+        - /metrics
+        - /api/v3/show/license
+      title: Server information
+      description: Retrieve server metrics, status, and version information
+      tag: Server information
+      isConceptual: false
+      menuGroup: Server
+      operations:
+        - operationId: GetHealth
+          method: GET
+          path: /health
+          summary: Health check
+          tags:
+            - Server information
+        - operationId: GetHealthV1
+          method: GET
+          path: /api/v1/health
+          summary: Health check (v1-compatible)
+          tags:
+            - Server information
+          compatVersion: v1
+        - operationId: GetPing
+          method: GET
+          path: /ping
+          summary: Ping the server
+          tags:
+            - Server information
+        - operationId: GetMetrics
+          method: GET
+          path: /metrics
+          summary: Metrics
+          tags:
+            - Server information
+        - operationId: GetShowLicense
+          method: GET
+          path: /api/v3/show/license
+          summary: Show license information
+          tags:
+            - Server information
+      tagDescription: Retrieve server metrics, status, and version information
+      source: >-
+        static/openapi/influxdb3-enterprise/tags/tags/ref-server-information.yaml
+      staticFilePath: /openapi/influxdb3-enterprise/tags/tags/ref-server-information.yaml
+  - path: api/table
+    fields:
+      name: Table
+      describes:
+        - /api/v3/configure/table
+      title: Table
+      description: Manage table schemas and data
+      tag: Table
+      isConceptual: false
+      menuGroup: Administration
+      operations:
+        - operationId: PostConfigureTable
+          method: POST
+          path: /api/v3/configure/table
+          summary: Create a table
+          tags:
+            - Table
+        - operationId: PatchConfigureTable
+          method: PATCH
+          path: /api/v3/configure/table
+          summary: Update a table
+          tags:
+            - Table
+        - operationId: DeleteConfigureTable
+          method: DELETE
+          path: /api/v3/configure/table
+          summary: Delete a table
+          tags:
+            - Table
+      tagDescription: Manage table schemas and data
+      source: static/openapi/influxdb3-enterprise/tags/tags/ref-table.yaml
+      staticFilePath: /openapi/influxdb3-enterprise/tags/tags/ref-table.yaml
+  - path: api/write-data
+    fields:
+      name: Write data
+      describes:
+        - /write
+        - /api/v2/write
+        - /api/v3/write_lp
+      title: Write data
+      description: >
+        Write data to InfluxDB 3 using line protocol format.
+
+        #### Timestamp precision across write APIs
+
+        InfluxDB 3 provides multiple write endpoints for compatibility with
+        different InfluxDB versions.
+
+        The following table compares timestamp precision support across v1, v2,
+        and v3 write APIs:
+
+        | Precision | v1 (`/write`) | v2 (`/api/v2/write`) | v3
+        (`/api/v3/write_lp`) |
+
+        |-----------|---------------|----------------------|-------------------------|
+
+        | **Auto detection** | ❌ No | ❌ No | ✅ `auto` (default) |
+
+        | **Seconds** | ✅ `s` | ✅ `s` | ✅ `second` |
+
+        | **Milliseconds** | ✅ `ms` | ✅ `ms` | ✅ `millisecond` |
+
+        | **Microseconds** | ✅ `u` or `µ` | ✅ `us` | ✅ `microsecond` |
+
+        | **Nanoseconds** | ✅ `ns` | ✅ `ns` | ✅ `nanosecond` |
+
+        | **Minutes** | ✅ `m` | ❌ No | ❌ No |
+
+        | **Hours** | ✅ `h` | ❌ No | ❌ No |
+
+        | **Default** | Nanosecond | Nanosecond | **Auto** (guessed) |
+
+        All timestamps are stored internally as nanoseconds.
+      tag: Write data
+      isConceptual: false
+      menuGroup: Data Operations
+      operations:
+        - operationId: PostV1Write
+          method: POST
+          path: /write
+          summary: Write line protocol (v1-compatible)
+          tags:
+            - Write data
+          compatVersion: v1
+          externalDocs:
+            description: Use compatibility APIs to write data
+            url: /influxdb3/enterprise/write-data/http-api/compatibility-apis/
+        - operationId: PostV2Write
+          method: POST
+          path: /api/v2/write
+          summary: Write line protocol (v2-compatible)
+          tags:
+            - Write data
+          compatVersion: v2
+          externalDocs:
+            description: Use compatibility APIs to write data
+            url: /influxdb3/enterprise/write-data/http-api/compatibility-apis/
+        - operationId: PostWriteLP
+          method: POST
+          path: /api/v3/write_lp
+          summary: Write line protocol
+          tags:
+            - Write data
+      tagDescription: >
+        Write data to InfluxDB 3 using line protocol format.
+
+        #### Timestamp precision across write APIs
+
+        InfluxDB 3 provides multiple write endpoints for compatibility with
+        different InfluxDB versions.
+
+        The following table compares timestamp precision support across v1, v2,
+        and v3 write APIs:
+
+        | Precision | v1 (`/write`) | v2 (`/api/v2/write`) | v3
+        (`/api/v3/write_lp`) |
+
+        |-----------|---------------|----------------------|-------------------------|
+
+        | **Auto detection** | ❌ No | ❌ No | ✅ `auto` (default) |
+
+        | **Seconds** | ✅ `s` | ✅ `s` | ✅ `second` |
+
+        | **Milliseconds** | ✅ `ms` | ✅ `ms` | ✅ `millisecond` |
+
+        | **Microseconds** | ✅ `u` or `µ` | ✅ `us` | ✅ `microsecond` |
+
+        | **Nanoseconds** | ✅ `ns` | ✅ `ns` | ✅ `nanosecond` |
+
+        | **Minutes** | ✅ `m` | ❌ No | ❌ No |
+
+        | **Hours** | ✅ `h` | ❌ No | ❌ No |
+
+        | **Default** | Nanosecond | Nanosecond | **Auto** (guessed) |
+
+        All timestamps are stored internally as nanoseconds.
+      related:
+        - /influxdb3/enterprise/write-data/http-api/compatibility-apis/
+      source: static/openapi/influxdb3-enterprise/tags/tags/ref-write-data.yaml
+      staticFilePath: /openapi/influxdb3-enterprise/tags/tags/ref-write-data.yaml
diff --git a/data/article_data/influxdb/oss-v2/articles.yml b/data/article_data/influxdb/oss-v2/articles.yml
new file mode 100644
index 0000000000..aa37b5a614
--- /dev/null
+++ b/data/article_data/influxdb/oss-v2/articles.yml
@@ -0,0 +1,757 @@
+articles:
+  - path: api/v2/authorizations
+    fields:
+      name: /api/v2/authorizations
+      describes:
+        - /api/v2/authorizations
+        - /api/v2/authorizations/{authID}
+      title: |-
+        /api/v2/authorizations
+        InfluxDB OSS API Service
+      tags:
+        - api-v2
+        - authorizations
+      source: static/openapi/influxdb-oss-v2/paths/ref-api-v2-authorizations.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-api-v2-authorizations.yaml
+  - path: api/v2/backup
+    fields:
+      name: /api/v2/backup
+      describes:
+        - /api/v2/backup/kv
+        - /api/v2/backup/metadata
+        - /api/v2/backup/shards/{shardID}
+      title: |-
+        /api/v2/backup
+        InfluxDB OSS API Service
+      tags:
+        - api-v2
+        - backup
+      source: static/openapi/influxdb-oss-v2/paths/ref-api-v2-backup.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-api-v2-backup.yaml
+  - path: api/v2/buckets
+    fields:
+      name: /api/v2/buckets
+      describes:
+        - /api/v2/buckets
+        - /api/v2/buckets/{bucketID}
+        - /api/v2/buckets/{bucketID}/labels
+        - /api/v2/buckets/{bucketID}/labels/{labelID}
+        - /api/v2/buckets/{bucketID}/members
+        - /api/v2/buckets/{bucketID}/members/{userID}
+        - /api/v2/buckets/{bucketID}/owners
+        - /api/v2/buckets/{bucketID}/owners/{userID}
+      title: |-
+        /api/v2/buckets
+        InfluxDB OSS API Service
+      tags:
+        - api-v2
+        - buckets
+      source: static/openapi/influxdb-oss-v2/paths/ref-api-v2-buckets.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-api-v2-buckets.yaml
+  - path: api/v2/checks
+    fields:
+      name: /api/v2/checks
+      describes:
+        - /api/v2/checks
+        - /api/v2/checks/{checkID}
+        - /api/v2/checks/{checkID}/labels
+        - /api/v2/checks/{checkID}/labels/{labelID}
+        - /api/v2/checks/{checkID}/query
+      title: |-
+        /api/v2/checks
+        InfluxDB OSS API Service
+      tags:
+        - api-v2
+        - checks
+      source: static/openapi/influxdb-oss-v2/paths/ref-api-v2-checks.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-api-v2-checks.yaml
+  - path: api/v2/config
+    fields:
+      name: /api/v2/config
+      describes:
+        - /api/v2/config
+      title: |-
+        /api/v2/config
+        InfluxDB OSS API Service
+      tags:
+        - api-v2
+        - config
+      source: static/openapi/influxdb-oss-v2/paths/ref-api-v2-config.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-api-v2-config.yaml
+  - path: api/v2/dashboards
+    fields:
+      name: /api/v2/dashboards
+      describes:
+        - /api/v2/dashboards
+        - /api/v2/dashboards/{dashboardID}
+        - /api/v2/dashboards/{dashboardID}/cells
+        - /api/v2/dashboards/{dashboardID}/cells/{cellID}
+        - /api/v2/dashboards/{dashboardID}/cells/{cellID}/view
+        - /api/v2/dashboards/{dashboardID}/labels
+        - /api/v2/dashboards/{dashboardID}/labels/{labelID}
+        - /api/v2/dashboards/{dashboardID}/members
+        - /api/v2/dashboards/{dashboardID}/members/{userID}
+        - /api/v2/dashboards/{dashboardID}/owners
+        - /api/v2/dashboards/{dashboardID}/owners/{userID}
+      title: |-
+        /api/v2/dashboards
+        InfluxDB OSS API Service
+      tags:
+        - api-v2
+        - dashboards
+      source: static/openapi/influxdb-oss-v2/paths/ref-api-v2-dashboards.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-api-v2-dashboards.yaml
+  - path: api/v2/dbrps
+    fields:
+      name: /api/v2/dbrps
+      describes:
+        - /api/v2/dbrps
+        - /api/v2/dbrps/{dbrpID}
+      title: |-
+        /api/v2/dbrps
+        InfluxDB OSS API Service
+      tags:
+        - api-v2
+        - dbrps
+      source: static/openapi/influxdb-oss-v2/paths/ref-api-v2-dbrps.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-api-v2-dbrps.yaml
+  - path: api/v2/delete
+    fields:
+      name: /api/v2/delete
+      describes:
+        - /api/v2/delete
+      title: |-
+        /api/v2/delete
+        InfluxDB OSS API Service
+      tags:
+        - api-v2
+        - delete
+      source: static/openapi/influxdb-oss-v2/paths/ref-api-v2-delete.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-api-v2-delete.yaml
+  - path: api/v2/flags
+    fields:
+      name: /api/v2/flags
+      describes:
+        - /api/v2/flags
+      title: |-
+        /api/v2/flags
+        InfluxDB OSS API Service
+      tags:
+        - api-v2
+        - flags
+      source: static/openapi/influxdb-oss-v2/paths/ref-api-v2-flags.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-api-v2-flags.yaml
+  - path: api/v2/labels
+    fields:
+      name: /api/v2/labels
+      describes:
+        - /api/v2/labels
+        - /api/v2/labels/{labelID}
+      title: |-
+        /api/v2/labels
+        InfluxDB OSS API Service
+      tags:
+        - api-v2
+        - labels
+      source: static/openapi/influxdb-oss-v2/paths/ref-api-v2-labels.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-api-v2-labels.yaml
+  - path: api/v2/maps
+    fields:
+      name: /api/v2/maps
+      describes:
+        - /api/v2/maps/mapToken
+      title: |-
+        /api/v2/maps
+        InfluxDB OSS API Service
+      tags:
+        - api-v2
+        - maps
+      source: static/openapi/influxdb-oss-v2/paths/ref-api-v2-maps.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-api-v2-maps.yaml
+  - path: api/v2/me
+    fields:
+      name: /api/v2/me
+      describes:
+        - /api/v2/me
+        - /api/v2/me/password
+      title: |-
+        /api/v2/me
+        InfluxDB OSS API Service
+      tags:
+        - api-v2
+        - me
+      source: static/openapi/influxdb-oss-v2/paths/ref-api-v2-me.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-api-v2-me.yaml
+  - path: api/v2/notificationEndpoints
+    fields:
+      name: /api/v2/notificationEndpoints
+      describes:
+        - /api/v2/notificationEndpoints
+        - /api/v2/notificationEndpoints/{endpointID}
+        - /api/v2/notificationEndpoints/{endpointID}/labels
+        - /api/v2/notificationEndpoints/{endpointID}/labels/{labelID}
+      title: |-
+        /api/v2/notificationEndpoints
+        InfluxDB OSS API Service
+      tags:
+        - api-v2
+        - notificationEndpoints
+      source: >-
+        static/openapi/influxdb-oss-v2/paths/ref-api-v2-notificationEndpoints.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-api-v2-notificationEndpoints.yaml
+  - path: api/v2/notificationRules
+    fields:
+      name: /api/v2/notificationRules
+      describes:
+        - /api/v2/notificationRules
+        - /api/v2/notificationRules/{ruleID}
+        - /api/v2/notificationRules/{ruleID}/labels
+        - /api/v2/notificationRules/{ruleID}/labels/{labelID}
+        - /api/v2/notificationRules/{ruleID}/query
+      title: |-
+        /api/v2/notificationRules
+        InfluxDB OSS API Service
+      tags:
+        - api-v2
+        - notificationRules
+      source: static/openapi/influxdb-oss-v2/paths/ref-api-v2-notificationRules.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-api-v2-notificationRules.yaml
+  - path: api/v2/orgs
+    fields:
+      name: /api/v2/orgs
+      describes:
+        - /api/v2/orgs
+        - /api/v2/orgs/{orgID}
+        - /api/v2/orgs/{orgID}/members
+        - /api/v2/orgs/{orgID}/members/{userID}
+        - /api/v2/orgs/{orgID}/owners
+        - /api/v2/orgs/{orgID}/owners/{userID}
+        - /api/v2/orgs/{orgID}/secrets
+        - /api/v2/orgs/{orgID}/secrets/delete
+        - /api/v2/orgs/{orgID}/secrets/{secretID}
+      title: |-
+        /api/v2/orgs
+        InfluxDB OSS API Service
+      tags:
+        - api-v2
+        - orgs
+      source: static/openapi/influxdb-oss-v2/paths/ref-api-v2-orgs.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-api-v2-orgs.yaml
+  - path: api/v2/query
+    fields:
+      name: /api/v2/query
+      describes:
+        - /api/v2/query
+        - /api/v2/query/analyze
+        - /api/v2/query/ast
+        - /api/v2/query/suggestions
+        - /api/v2/query/suggestions/{name}
+      title: |-
+        /api/v2/query
+        InfluxDB OSS API Service
+      tags:
+        - api-v2
+        - query
+      source: static/openapi/influxdb-oss-v2/paths/ref-api-v2-query.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-api-v2-query.yaml
+  - path: api/v2/remotes
+    fields:
+      name: /api/v2/remotes
+      describes:
+        - /api/v2/remotes
+        - /api/v2/remotes/{remoteID}
+      title: |-
+        /api/v2/remotes
+        InfluxDB OSS API Service
+      tags:
+        - api-v2
+        - remotes
+      source: static/openapi/influxdb-oss-v2/paths/ref-api-v2-remotes.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-api-v2-remotes.yaml
+  - path: api/v2/replications
+    fields:
+      name: /api/v2/replications
+      describes:
+        - /api/v2/replications
+        - /api/v2/replications/{replicationID}
+        - /api/v2/replications/{replicationID}/validate
+      title: |-
+        /api/v2/replications
+        InfluxDB OSS API Service
+      tags:
+        - api-v2
+        - replications
+      source: static/openapi/influxdb-oss-v2/paths/ref-api-v2-replications.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-api-v2-replications.yaml
+  - path: api/v2/resources
+    fields:
+      name: /api/v2/resources
+      describes:
+        - /api/v2/resources
+      title: |-
+        /api/v2/resources
+        InfluxDB OSS API Service
+      tags:
+        - api-v2
+        - resources
+      source: static/openapi/influxdb-oss-v2/paths/ref-api-v2-resources.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-api-v2-resources.yaml
+  - path: api/v2/restore
+    fields:
+      name: /api/v2/restore
+      describes:
+        - /api/v2/restore/bucket/{bucketID}
+        - /api/v2/restore/bucketMetadata
+        - /api/v2/restore/kv
+        - /api/v2/restore/shards/{shardID}
+        - /api/v2/restore/sql
+      title: |-
+        /api/v2/restore
+        InfluxDB OSS API Service
+      tags:
+        - api-v2
+        - restore
+      source: static/openapi/influxdb-oss-v2/paths/ref-api-v2-restore.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-api-v2-restore.yaml
+  - path: api/v2/scrapers
+    fields:
+      name: /api/v2/scrapers
+      describes:
+        - /api/v2/scrapers
+        - /api/v2/scrapers/{scraperTargetID}
+        - /api/v2/scrapers/{scraperTargetID}/labels
+        - /api/v2/scrapers/{scraperTargetID}/labels/{labelID}
+        - /api/v2/scrapers/{scraperTargetID}/members
+        - /api/v2/scrapers/{scraperTargetID}/members/{userID}
+        - /api/v2/scrapers/{scraperTargetID}/owners
+        - /api/v2/scrapers/{scraperTargetID}/owners/{userID}
+      title: |-
+        /api/v2/scrapers
+        InfluxDB OSS API Service
+      tags:
+        - api-v2
+        - scrapers
+      source: static/openapi/influxdb-oss-v2/paths/ref-api-v2-scrapers.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-api-v2-scrapers.yaml
+  - path: api/v2/setup
+    fields:
+      name: /api/v2/setup
+      describes:
+        - /api/v2/setup
+      title: |-
+        /api/v2/setup
+        InfluxDB OSS API Service
+      tags:
+        - api-v2
+        - setup
+      source: static/openapi/influxdb-oss-v2/paths/ref-api-v2-setup.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-api-v2-setup.yaml
+  - path: api/v2/signin
+    fields:
+      name: /api/v2/signin
+      describes:
+        - /api/v2/signin
+      title: |-
+        /api/v2/signin
+        InfluxDB OSS API Service
+      tags:
+        - api-v2
+        - signin
+      source: static/openapi/influxdb-oss-v2/paths/ref-api-v2-signin.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-api-v2-signin.yaml
+  - path: api/v2/signout
+    fields:
+      name: /api/v2/signout
+      describes:
+        - /api/v2/signout
+      title: |-
+        /api/v2/signout
+        InfluxDB OSS API Service
+      tags:
+        - api-v2
+        - signout
+      source: static/openapi/influxdb-oss-v2/paths/ref-api-v2-signout.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-api-v2-signout.yaml
+  - path: api/v2/sources
+    fields:
+      name: /api/v2/sources
+      describes:
+        - /api/v2/sources
+        - /api/v2/sources/{sourceID}
+        - /api/v2/sources/{sourceID}/buckets
+        - /api/v2/sources/{sourceID}/health
+      title: |-
+        /api/v2/sources
+        InfluxDB OSS API Service
+      tags:
+        - api-v2
+        - sources
+      source: static/openapi/influxdb-oss-v2/paths/ref-api-v2-sources.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-api-v2-sources.yaml
+  - path: api/v2/stacks
+    fields:
+      name: /api/v2/stacks
+      describes:
+        - /api/v2/stacks
+        - /api/v2/stacks/{stack_id}
+        - /api/v2/stacks/{stack_id}/uninstall
+      title: |-
+        /api/v2/stacks
+        InfluxDB OSS API Service
+      tags:
+        - api-v2
+        - stacks
+      source: static/openapi/influxdb-oss-v2/paths/ref-api-v2-stacks.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-api-v2-stacks.yaml
+  - path: api/v2/tasks
+    fields:
+      name: /api/v2/tasks
+      describes:
+        - /api/v2/tasks
+        - /api/v2/tasks/{taskID}
+        - /api/v2/tasks/{taskID}/labels
+        - /api/v2/tasks/{taskID}/labels/{labelID}
+        - /api/v2/tasks/{taskID}/logs
+        - /api/v2/tasks/{taskID}/members
+        - /api/v2/tasks/{taskID}/members/{userID}
+        - /api/v2/tasks/{taskID}/owners
+        - /api/v2/tasks/{taskID}/owners/{userID}
+        - /api/v2/tasks/{taskID}/runs
+        - /api/v2/tasks/{taskID}/runs/{runID}
+        - /api/v2/tasks/{taskID}/runs/{runID}/logs
+        - /api/v2/tasks/{taskID}/runs/{runID}/retry
+      title: |-
+        /api/v2/tasks
+        InfluxDB OSS API Service
+      tags:
+        - api-v2
+        - tasks
+      source: static/openapi/influxdb-oss-v2/paths/ref-api-v2-tasks.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-api-v2-tasks.yaml
+  - path: api/v2/telegraf
+    fields:
+      name: /api/v2/telegraf
+      describes:
+        - /api/v2/telegraf/plugins
+      title: |-
+        /api/v2/telegraf
+        InfluxDB OSS API Service
+      tags:
+        - api-v2
+        - telegraf
+      source: static/openapi/influxdb-oss-v2/paths/ref-api-v2-telegraf.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-api-v2-telegraf.yaml
+  - path: api/v2/telegrafs
+    fields:
+      name: /api/v2/telegrafs
+      describes:
+        - /api/v2/telegrafs
+        - /api/v2/telegrafs/{telegrafID}
+        - /api/v2/telegrafs/{telegrafID}/labels
+        - /api/v2/telegrafs/{telegrafID}/labels/{labelID}
+        - /api/v2/telegrafs/{telegrafID}/members
+        - /api/v2/telegrafs/{telegrafID}/members/{userID}
+        - /api/v2/telegrafs/{telegrafID}/owners
+        - /api/v2/telegrafs/{telegrafID}/owners/{userID}
+      title: |-
+        /api/v2/telegrafs
+        InfluxDB OSS API Service
+      tags:
+        - api-v2
+        - telegrafs
+      source: static/openapi/influxdb-oss-v2/paths/ref-api-v2-telegrafs.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-api-v2-telegrafs.yaml
+  - path: api/v2/templates
+    fields:
+      name: /api/v2/templates
+      describes:
+        - /api/v2/templates/apply
+        - /api/v2/templates/export
+      title: |-
+        /api/v2/templates
+        InfluxDB OSS API Service
+      tags:
+        - api-v2
+        - templates
+      source: static/openapi/influxdb-oss-v2/paths/ref-api-v2-templates.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-api-v2-templates.yaml
+  - path: api/v2/users
+    fields:
+      name: /api/v2/users
+      describes:
+        - /api/v2/users
+        - /api/v2/users/{userID}
+        - /api/v2/users/{userID}/password
+      title: |-
+        /api/v2/users
+        InfluxDB OSS API Service
+      tags:
+        - api-v2
+        - users
+      source: static/openapi/influxdb-oss-v2/paths/ref-api-v2-users.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-api-v2-users.yaml
+  - path: api/v2/variables
+    fields:
+      name: /api/v2/variables
+      describes:
+        - /api/v2/variables
+        - /api/v2/variables/{variableID}
+        - /api/v2/variables/{variableID}/labels
+        - /api/v2/variables/{variableID}/labels/{labelID}
+      title: |-
+        /api/v2/variables
+        InfluxDB OSS API Service
+      tags:
+        - api-v2
+        - variables
+      source: static/openapi/influxdb-oss-v2/paths/ref-api-v2-variables.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-api-v2-variables.yaml
+  - path: api/v2/write
+    fields:
+      name: /api/v2/write
+      describes:
+        - /api/v2/write
+      title: |-
+        /api/v2/write
+        InfluxDB OSS API Service
+      tags:
+        - api-v2
+        - write
+      source: static/openapi/influxdb-oss-v2/paths/ref-api-v2-write.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-api-v2-write.yaml
+  - path: api/v2
+    fields:
+      name: /api/v2
+      describes:
+        - /api/v2
+      title: |-
+        /api/v2
+        InfluxDB OSS API Service
+      tags:
+        - api
+        - v2
+      source: static/openapi/influxdb-oss-v2/paths/ref-api-v2.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-api-v2.yaml
+  - path: debug/pprof/all
+    fields:
+      name: /debug/pprof/all
+      describes:
+        - /debug/pprof/all
+      title: |-
+        /debug/pprof/all
+        InfluxDB OSS API Service
+      tags:
+        - debug-pprof
+        - all
+      source: static/openapi/influxdb-oss-v2/paths/ref-debug-pprof-all.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-debug-pprof-all.yaml
+  - path: debug/pprof/allocs
+    fields:
+      name: /debug/pprof/allocs
+      describes:
+        - /debug/pprof/allocs
+      title: |-
+        /debug/pprof/allocs
+        InfluxDB OSS API Service
+      tags:
+        - debug-pprof
+        - allocs
+      source: static/openapi/influxdb-oss-v2/paths/ref-debug-pprof-allocs.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-debug-pprof-allocs.yaml
+  - path: debug/pprof/block
+    fields:
+      name: /debug/pprof/block
+      describes:
+        - /debug/pprof/block
+      title: |-
+        /debug/pprof/block
+        InfluxDB OSS API Service
+      tags:
+        - debug-pprof
+        - block
+      source: static/openapi/influxdb-oss-v2/paths/ref-debug-pprof-block.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-debug-pprof-block.yaml
+  - path: debug/pprof/cmdline
+    fields:
+      name: /debug/pprof/cmdline
+      describes:
+        - /debug/pprof/cmdline
+      title: |-
+        /debug/pprof/cmdline
+        InfluxDB OSS API Service
+      tags:
+        - debug-pprof
+        - cmdline
+      source: static/openapi/influxdb-oss-v2/paths/ref-debug-pprof-cmdline.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-debug-pprof-cmdline.yaml
+  - path: debug/pprof/goroutine
+    fields:
+      name: /debug/pprof/goroutine
+      describes:
+        - /debug/pprof/goroutine
+      title: |-
+        /debug/pprof/goroutine
+        InfluxDB OSS API Service
+      tags:
+        - debug-pprof
+        - goroutine
+      source: static/openapi/influxdb-oss-v2/paths/ref-debug-pprof-goroutine.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-debug-pprof-goroutine.yaml
+  - path: debug/pprof/heap
+    fields:
+      name: /debug/pprof/heap
+      describes:
+        - /debug/pprof/heap
+      title: |-
+        /debug/pprof/heap
+        InfluxDB OSS API Service
+      tags:
+        - debug-pprof
+        - heap
+      source: static/openapi/influxdb-oss-v2/paths/ref-debug-pprof-heap.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-debug-pprof-heap.yaml
+  - path: debug/pprof/mutex
+    fields:
+      name: /debug/pprof/mutex
+      describes:
+        - /debug/pprof/mutex
+      title: |-
+        /debug/pprof/mutex
+        InfluxDB OSS API Service
+      tags:
+        - debug-pprof
+        - mutex
+      source: static/openapi/influxdb-oss-v2/paths/ref-debug-pprof-mutex.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-debug-pprof-mutex.yaml
+  - path: debug/pprof/profile
+    fields:
+      name: /debug/pprof/profile
+      describes:
+        - /debug/pprof/profile
+      title: |-
+        /debug/pprof/profile
+        InfluxDB OSS API Service
+      tags:
+        - debug-pprof
+        - profile
+      source: static/openapi/influxdb-oss-v2/paths/ref-debug-pprof-profile.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-debug-pprof-profile.yaml
+  - path: debug/pprof/threadcreate
+    fields:
+      name: /debug/pprof/threadcreate
+      describes:
+        - /debug/pprof/threadcreate
+      title: |-
+        /debug/pprof/threadcreate
+        InfluxDB OSS API Service
+      tags:
+        - debug-pprof
+        - threadcreate
+      source: static/openapi/influxdb-oss-v2/paths/ref-debug-pprof-threadcreate.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-debug-pprof-threadcreate.yaml
+  - path: debug/pprof/trace
+    fields:
+      name: /debug/pprof/trace
+      describes:
+        - /debug/pprof/trace
+      title: |-
+        /debug/pprof/trace
+        InfluxDB OSS API Service
+      tags:
+        - debug-pprof
+        - trace
+      source: static/openapi/influxdb-oss-v2/paths/ref-debug-pprof-trace.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-debug-pprof-trace.yaml
+  - path: health
+    fields:
+      name: /health
+      describes:
+        - /health
+      title: |-
+        /health
+        InfluxDB OSS API Service
+      tags:
+        - ''
+        - health
+      source: static/openapi/influxdb-oss-v2/paths/ref-health.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-health.yaml
+  - path: legacy/authorizations
+    fields:
+      name: /legacy/authorizations
+      describes:
+        - /legacy/authorizations
+        - /legacy/authorizations/{authID}
+        - /legacy/authorizations/{authID}/password
+      title: |-
+        /legacy/authorizations
+        InfluxDB OSS API Service
+      tags:
+        - legacy
+        - authorizations
+      source: static/openapi/influxdb-oss-v2/paths/ref-legacy-authorizations.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-legacy-authorizations.yaml
+  - path: metrics
+    fields:
+      name: /metrics
+      describes:
+        - /metrics
+      title: |-
+        /metrics
+        InfluxDB OSS API Service
+      tags:
+        - ''
+        - metrics
+      source: static/openapi/influxdb-oss-v2/paths/ref-metrics.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-metrics.yaml
+  - path: ping
+    fields:
+      name: /ping
+      describes:
+        - /ping
+      title: |-
+        /ping
+        InfluxDB OSS API Service
+      tags:
+        - ''
+        - ping
+      source: static/openapi/influxdb-oss-v2/paths/ref-ping.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-ping.yaml
+  - path: query
+    fields:
+      name: /query
+      describes:
+        - /query
+      title: |-
+        /query
+        InfluxDB OSS API Service
+      tags:
+        - ''
+        - query
+      source: static/openapi/influxdb-oss-v2/paths/ref-query.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-query.yaml
+  - path: ready
+    fields:
+      name: /ready
+      describes:
+        - /ready
+      title: |-
+        /ready
+        InfluxDB OSS API Service
+      tags:
+        - ''
+        - ready
+      source: static/openapi/influxdb-oss-v2/paths/ref-ready.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-ready.yaml
+  - path: write
+    fields:
+      name: /write
+      describes:
+        - /write
+      title: |-
+        /write
+        InfluxDB OSS API Service
+      tags:
+        - ''
+        - write
+      source: static/openapi/influxdb-oss-v2/paths/ref-write.yaml
+      staticFilePath: /openapi/influxdb-oss-v2/paths/ref-write.yaml
diff --git a/docs/plans/2024-12-10-standalone-operation-pages-design.md b/docs/plans/2024-12-10-standalone-operation-pages-design.md
new file mode 100644
index 0000000000..54d084ddc6
--- /dev/null
+++ b/docs/plans/2024-12-10-standalone-operation-pages-design.md
@@ -0,0 +1,181 @@
+# Standalone API Operation Pages Design
+
+## Overview
+
+Create individual pages for each API operation with path-based URLs, rendered using RapiDoc Mini with existing tag-level OpenAPI specs.
+
+## Goals
+
+- **SEO/discoverability**: Each operation indexable with its own URL and metadata
+- **Deep linking**: Reliable bookmarkable/shareable URLs for specific operations
+- **Navigation UX**: Sidebar links navigate to actual pages (not hash fragments)
+- **Content customization**: Foundation for adding operation-specific guides and examples
+
+## URL Structure
+
+Path-based URLs with HTTP method as the final segment:
+
+| Operation          | API Path                            | Page URL                             |
+| ------------------ | ----------------------------------- | ------------------------------------ |
+| PostV1Write        | `POST /write`                       | `/api/write/post/`                   |
+| PostV2Write        | `POST /api/v2/write`                | `/api/v2/write/post/`                |
+| PostWriteLP        | `POST /api/v3/write_lp`             | `/api/v3/write_lp/post/`             |
+| GetV1ExecuteQuery  | `GET /query`                        | `/api/query/get/`                    |
+| PostExecuteV1Query | `POST /query`                       | `/api/query/post/`                   |
+| GetExecuteQuerySQL | `GET /api/v3/query_sql`             | `/api/v3/query_sql/get/`             |
+| GetDatabases       | `GET /api/v3/configure/database`    | `/api/v3/configure/database/get/`    |
+| DeleteDatabase     | `DELETE /api/v3/configure/database` | `/api/v3/configure/database/delete/` |
+
+## Architecture
+
+### Existing Components (unchanged)
+
+- **Tag pages**: `/api/write-data/`, `/api/query-data/` etc. remain as landing pages
+- **Tag-level specs**: `static/openapi/influxdb-{product}/tags/tags/ref-{tag}.yaml` (\~30-50KB each)
+- **Sidebar structure**: Tag-based groups with operation summaries as link text
+
+### New Components
+
+1. **Operation page content files**: Generated at path-based locations
+2. **Operation page template**: Hugo layout using RapiDoc Mini
+3. **Updated sidebar links**: Point to path-based URLs instead of hash fragments
+
+## Content File Structure
+
+Generated operation pages at `content/influxdb3/{product}/api/{path}/{method}/_index.md`:
+
+```yaml
+---
+title: Write line protocol (v1-compatible)
+description: Write data using InfluxDB v1-compatible line protocol endpoint
+type: api-operation
+layout: operation
+# RapiDoc Mini configuration
+specFile: /openapi/influxdb-influxdb3_core/tags/tags/ref-write-data.yaml
+matchPaths: post /write
+# Operation metadata
+operationId: PostV1Write
+method: POST
+apiPath: /write
+tag: Write data
+compatVersion: v1
+# Links
+related:
+  - /influxdb3/core/write-data/http-api/compatibility-apis/
+---
+```
+
+## Hugo Template
+
+New layout `layouts/api-operation/operation.html`:
+
+```html
+{{ define "main" }}
+<article class="api-operation-page">
+  <header>
+    <h1>{{ .Title }}</h1>
+    <div class="api-operation-meta">
+      <span class="api-method api-method--{{ lower .Params.method }}">{{ .Params.method }}</span>
+      <code class="api-path">{{ .Params.apiPath }}</code>
+      {{ with .Params.compatVersion }}
+      <span class="api-compat-badge api-compat-badge--{{ . }}">{{ . }}</span>
+      {{ end }}
+    </div>
+  </header>
+
+  <rapi-doc-mini
+    spec-url="{{ .Params.specFile }}"
+    match-paths="{{ .Params.matchPaths }}"
+    theme="light"
+    bg-color="transparent"
+    paths-expanded="true"
+    schema-expand-level="1">
+  </rapi-doc-mini>
+
+  {{ with .Params.related }}
+  <aside class="related-content">
+    <h2>Related documentation</h2>
+    <ul>
+      {{ range . }}
+      <li><a href="{{ . }}">{{ . }}</a></li>
+      {{ end }}
+    </ul>
+  </aside>
+  {{ end }}
+</article>
+{{ end }}
+```
+
+## Sidebar Navigation Changes
+
+Update `layouts/partials/sidebar/api-menu-items.html` to generate path-based URLs:
+
+**Before:**
+
+```go
+{{ $fragment := printf "#operation/%s" .operationId }}
+{{ $fullUrl := printf "%s%s" $tagPageUrl $fragment }}
+```
+
+**After:**
+
+```go
+{{ $apiPath := .path }}
+{{ $method := lower .method }}
+{{ $pathSlug := $apiPath | replaceRE "^/" "" }}
+{{ $operationUrl := printf "/%s/%s/api/%s/%s/" $product $version $pathSlug $method | relURL }}
+```
+
+## Generator Changes
+
+Update `api-docs/scripts/openapi-paths-to-hugo-data/index.ts`:
+
+1. Add new function `generateOperationPages()` that creates content files for each operation
+2. Include operation metadata: specFile path, matchPaths filter, tag association
+3. Call from `generateHugoDataByTag()` after generating tag-based articles
+
+## File Generation Summary
+
+For InfluxDB 3 Core (\~43 operations), this creates:
+
+- \~43 new content files at `content/influxdb3/core/api/{path}/{method}/_index.md`
+- No new spec files (reuses existing tag-level specs)
+
+## Data Flow
+
+```
+OpenAPI Spec
+    ↓
+Generator extracts operations
+    ↓
+Creates content files with frontmatter (specFile, matchPaths, metadata)
+    ↓
+Hugo builds pages using api-operation/operation.html template
+    ↓
+RapiDoc Mini loads tag-level spec, filters to single operation client-side
+```
+
+## Testing Plan
+
+1. Generate operation pages for Core product
+2. Verify URLs resolve correctly
+3. Verify RapiDoc Mini renders single operation
+4. Verify sidebar links navigate to operation pages
+5. Test deep linking (direct URL access)
+6. Check page titles and meta descriptions for SEO
+
+## Future Improvements
+
+- Generate operation-level specs for smaller payloads (if performance issues arise)
+- Add custom content sections per operation
+- Implement operation search/filtering on tag pages
+
+## Migration Notes
+
+When migrating other product specs from Redoc to RapiDoc:
+
+1. **Remove `x-tagGroups`**: This is a Redoc-specific extension for sidebar navigation grouping. RapiDoc doesn't use it. The Hugo sidebar uses `data/api_nav_groups.yml` instead.
+
+2. **Ensure tag consistency**: The sidebar navigation (`api_nav_groups.yml`) must match the tag names in the spec's `tags` section exactly.
+
+3. **Single-tag operations**: Operations should ideally have a single tag to avoid duplicate rendering. If an operation has multiple tags, the generator restricts it to the primary tag in tag-specific specs.
diff --git a/docs/plans/2024-12-12-api-code-review-fixes.md b/docs/plans/2024-12-12-api-code-review-fixes.md
new file mode 100644
index 0000000000..6360c9f69e
--- /dev/null
+++ b/docs/plans/2024-12-12-api-code-review-fixes.md
@@ -0,0 +1,779 @@
+# API Code Review Fixes Implementation Plan
+
+> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
+
+**Goal:** Fix code review violations by extracting inline JavaScript from rapidoc.html into a TypeScript component and removing unused Scalar renderer code.
+
+**Architecture:** Create a new `api-rapidoc.ts` TypeScript component following the established component pattern (same as `rapidoc-mini.ts`). The component handles theme synchronization, shadow DOM manipulation, and MutationObserver setup. Remove the Scalar renderer, api-tabs component, and associated partials since they're no longer used.
+
+**Tech Stack:** TypeScript, Hugo templates, SCSS, Cypress
+
+***
+
+## Task 1: Create api-rapidoc.ts TypeScript Component
+
+**Files:**
+
+- Create: `assets/js/components/api-rapidoc.ts`
+
+**Step 1: Create the TypeScript component file**
+
+Create `assets/js/components/api-rapidoc.ts` with the following content:
+
+```typescript
+/**
+ * RapiDoc API Documentation Component
+ *
+ * Initializes the full RapiDoc renderer with theme synchronization.
+ * This is the component version of the inline JavaScript from rapidoc.html.
+ *
+ * Features:
+ * - Theme detection from Hugo's stylesheet toggle system
+ * - Automatic theme synchronization when user toggles dark/light mode
+ * - Shadow DOM manipulation to hide unwanted UI elements
+ * - CSS custom property injection for styling
+ *
+ * Usage:
+ * <div data-component="api-rapidoc" data-spec-url="/path/to/spec.yml"></div>
+ *
+ * The component expects a <rapi-doc> element to already exist in the container
+ * (created by Hugo template) or will wait for it to be added.
+ */
+
+import { getPreference } from '../services/local-storage.js';
+
+interface ComponentOptions {
+  component: HTMLElement;
+}
+
+interface ThemeColors {
+  theme: 'light' | 'dark';
+  bgColor: string;
+  textColor: string;
+  headerColor: string;
+  primaryColor: string;
+  navBgColor: string;
+  navTextColor: string;
+  navHoverBgColor: string;
+  navHoverTextColor: string;
+  navAccentColor: string;
+  codeTheme: string;
+}
+
+type CleanupFn = () => void;
+
+/**
+ * Get current theme from localStorage (source of truth for Hugo theme system)
+ */
+function getTheme(): 'dark' | 'light' {
+  const theme = getPreference('theme');
+  return theme === 'dark' ? 'dark' : 'light';
+}
+
+/**
+ * Get theme colors matching Hugo SCSS variables
+ */
+function getThemeColors(isDark: boolean): ThemeColors {
+  if (isDark) {
+    return {
+      theme: 'dark',
+      bgColor: '#14141F',        // $grey10 ($article-bg in dark theme)
+      textColor: '#D4D7DD',      // $g15-platinum
+      headerColor: '#D4D7DD',
+      primaryColor: '#a0a0ff',
+      navBgColor: '#1a1a2a',
+      navTextColor: '#D4D7DD',
+      navHoverBgColor: '#252535',
+      navHoverTextColor: '#ffffff',
+      navAccentColor: '#a0a0ff',
+      codeTheme: 'monokai',
+    };
+  }
+
+  return {
+    theme: 'light',
+    bgColor: '#ffffff',          // $g20-white
+    textColor: '#2b2b2b',
+    headerColor: '#020a47',      // $br-dark-blue
+    primaryColor: '#020a47',
+    navBgColor: '#f7f8fa',
+    navTextColor: '#2b2b2b',
+    navHoverBgColor: '#e8e8f0',
+    navHoverTextColor: '#020a47',
+    navAccentColor: '#020a47',
+    codeTheme: 'prism',
+  };
+}
+
+/**
+ * Apply theme to RapiDoc element
+ */
+function applyTheme(rapiDoc: HTMLElement): void {
+  const isDark = getTheme() === 'dark';
+  const colors = getThemeColors(isDark);
+
+  rapiDoc.setAttribute('theme', colors.theme);
+  rapiDoc.setAttribute('bg-color', colors.bgColor);
+  rapiDoc.setAttribute('text-color', colors.textColor);
+  rapiDoc.setAttribute('header-color', colors.headerColor);
+  rapiDoc.setAttribute('primary-color', colors.primaryColor);
+  rapiDoc.setAttribute('nav-bg-color', colors.navBgColor);
+  rapiDoc.setAttribute('nav-text-color', colors.navTextColor);
+  rapiDoc.setAttribute('nav-hover-bg-color', colors.navHoverBgColor);
+  rapiDoc.setAttribute('nav-hover-text-color', colors.navHoverTextColor);
+  rapiDoc.setAttribute('nav-accent-color', colors.navAccentColor);
+  rapiDoc.setAttribute('code-theme', colors.codeTheme);
+}
+
+/**
+ * Set custom CSS properties on RapiDoc element
+ */
+function setInputBorderStyles(rapiDoc: HTMLElement): void {
+  rapiDoc.style.setProperty('--border-color', '#00A3FF');
+}
+
+/**
+ * Hide unwanted elements in RapiDoc shadow DOM
+ */
+function hideExpandCollapseControls(rapiDoc: HTMLElement): void {
+  const maxAttempts = 10;
+  let attempts = 0;
+
+  const tryHide = (): void => {
+    attempts++;
+
+    try {
+      const shadowRoot = rapiDoc.shadowRoot;
+      if (!shadowRoot) {
+        if (attempts < maxAttempts) {
+          setTimeout(tryHide, 500);
+        }
+        return;
+      }
+
+      // Find all elements and hide those containing "Expand all" / "Collapse all"
+      const allElements = shadowRoot.querySelectorAll('*');
+      let hiddenCount = 0;
+
+      allElements.forEach((element) => {
+        const text = element.textContent || '';
+
+        if (text.includes('Expand all') || text.includes('Collapse all')) {
+          (element as HTMLElement).style.display = 'none';
+          if (element.parentElement) {
+            element.parentElement.style.display = 'none';
+          }
+          hiddenCount++;
+        }
+      });
+
+      // Hide "Overview" headings
+      const headings = shadowRoot.querySelectorAll('h1, h2, h3, h4');
+      headings.forEach((heading) => {
+        const text = (heading.textContent || '').trim();
+        if (text.includes('Overview')) {
+          (heading as HTMLElement).style.display = 'none';
+          hiddenCount++;
+        }
+      });
+
+      // Inject CSS as backup
+      const style = document.createElement('style');
+      style.textContent = `
+        .section-gap.section-tag,
+        [id*="overview"],
+        .regular-font.section-gap:empty,
+        h1:empty, h2:empty, h3:empty {
+          display: none !important;
+        }
+      `;
+      shadowRoot.appendChild(style);
+
+      if (hiddenCount === 0 && attempts < maxAttempts) {
+        setTimeout(tryHide, 500);
+      }
+    } catch (e) {
+      if (attempts < maxAttempts) {
+        setTimeout(tryHide, 500);
+      }
+    }
+  };
+
+  setTimeout(tryHide, 500);
+}
+
+/**
+ * Watch for theme changes via stylesheet toggle
+ */
+function watchThemeChanges(rapiDoc: HTMLElement): CleanupFn {
+  const handleThemeChange = (): void => {
+    applyTheme(rapiDoc);
+  };
+
+  // Watch stylesheet disabled attribute changes (Hugo theme.js toggles this)
+  const observer = new MutationObserver((mutations) => {
+    for (const mutation of mutations) {
+      if (
+        mutation.type === 'attributes' &&
+        mutation.target instanceof HTMLLinkElement &&
+        mutation.target.title?.includes('theme')
+      ) {
+        handleThemeChange();
+        break;
+      }
+      // Also watch data-theme changes as fallback
+      if (mutation.attributeName === 'data-theme') {
+        handleThemeChange();
+      }
+    }
+  });
+
+  // Observe head for stylesheet changes
+  observer.observe(document.head, {
+    attributes: true,
+    attributeFilter: ['disabled'],
+    subtree: true,
+  });
+
+  // Observe documentElement for data-theme changes
+  observer.observe(document.documentElement, {
+    attributes: true,
+    attributeFilter: ['data-theme'],
+  });
+
+  return (): void => {
+    observer.disconnect();
+  };
+}
+
+/**
+ * Initialize RapiDoc component
+ */
+export default function ApiRapiDoc({
+  component,
+}: ComponentOptions): CleanupFn | void {
+  // Find the rapi-doc element inside the container
+  const rapiDoc = component.querySelector('rapi-doc') as HTMLElement | null;
+
+  if (!rapiDoc) {
+    console.warn('[API RapiDoc] No rapi-doc element found in container');
+    return;
+  }
+
+  // Apply initial theme
+  applyTheme(rapiDoc);
+
+  // Set custom CSS properties
+  if (customElements && customElements.whenDefined) {
+    customElements.whenDefined('rapi-doc').then(() => {
+      setInputBorderStyles(rapiDoc);
+      setTimeout(() => setInputBorderStyles(rapiDoc), 500);
+    });
+  } else {
+    setInputBorderStyles(rapiDoc);
+    setTimeout(() => setInputBorderStyles(rapiDoc), 500);
+  }
+
+  // Hide unwanted UI elements
+  hideExpandCollapseControls(rapiDoc);
+
+  // Watch for theme changes
+  return watchThemeChanges(rapiDoc);
+}
+```
+
+**Step 2: Verify the file was created correctly**
+
+Run: `head -30 assets/js/components/api-rapidoc.ts`
+Expected: File header and imports visible
+
+**Step 3: Commit**
+
+```bash
+git add assets/js/components/api-rapidoc.ts
+git commit -m "feat(api): Create api-rapidoc TypeScript component
+
+Extract inline JavaScript from rapidoc.html into a proper TypeScript
+component following the established component pattern."
+```
+
+***
+
+## Task 2: Register api-rapidoc Component in main.js
+
+**Files:**
+
+- Modify: `assets/js/main.js:49-88`
+
+**Step 1: Add import for ApiRapiDoc**
+
+Add this import after line 52 (after RapiDocMini import):
+
+```javascript
+import ApiRapiDoc from './components/api-rapidoc.ts';
+```
+
+**Step 2: Register component in componentRegistry**
+
+Add this entry in the componentRegistry object (after line 87, the 'rapidoc-mini' entry):
+
+```javascript
+  'api-rapidoc': ApiRapiDoc,
+```
+
+**Step 3: Verify changes**
+
+Run: `grep -n "api-rapidoc\|ApiRapiDoc" assets/js/main.js`
+Expected: Both the import and registry entry appear
+
+**Step 4: Commit**
+
+```bash
+git add assets/js/main.js
+git commit -m "feat(api): Register api-rapidoc component in main.js"
+```
+
+***
+
+## Task 3: Update rapidoc.html to Use Component Pattern
+
+**Files:**
+
+- Modify: `layouts/partials/api/rapidoc.html`
+
+**Step 1: Replace inline JavaScript with data-component attribute**
+
+Replace the entire content of `layouts/partials/api/rapidoc.html` with:
+
+```html
+{{/*
+  RapiDoc API Documentation Renderer
+
+  Primary API documentation renderer using RapiDoc with "Mix your own HTML" slots.
+  See: https://rapidocweb.com/examples.html
+
+  Required page params:
+  - staticFilePath: Path to the OpenAPI specification file
+
+  Optional page params:
+  - operationId: Specific operation to display (renders only that operation)
+  - tag: Tag to filter operations by
+
+  RapiDoc slots available for custom content:
+  - slot="header" - Custom header
+  - slot="footer" - Custom footer
+  - slot="overview" - Custom overview content
+  - slot="auth" - Custom authentication section
+  - slot="nav-logo" - Custom navigation logo
+*/}}
+
+{{ $specPath := .Params.staticFilePath }}
+{{ $specPathJSON := replace $specPath ".yaml" ".json" | replace ".yml" ".json" }}
+{{ $operationId := .Params.operationId | default "" }}
+{{ $tag := .Params.tag | default "" }}
+
+{{/* Machine-readable links for AI agent discovery */}}
+{{ if $specPath }}
+<link rel="alternate" type="application/x-yaml" href="{{ $specPath | absURL }}" title="OpenAPI Specification (YAML)" />
+<link rel="alternate" type="application/json" href="{{ $specPathJSON | absURL }}" title="OpenAPI Specification (JSON)" />
+{{ end }}
+
+<div class="api-reference-wrapper" data-component="api-rapidoc">
+  {{/* RapiDoc component with slot-based customization */}}
+  <rapi-doc
+    id="api-doc"
+    spec-url="{{ $specPath }}"
+    theme="light"
+    bg-color="#ffffff"
+    text-color="#2b2b2b"
+    header-color="#020a47"
+    primary-color="#00A3FF"
+    nav-bg-color="#f7f8fa"
+    nav-text-color="#2b2b2b"
+    nav-hover-bg-color="#e8e8f0"
+    nav-hover-text-color="#020a47"
+    nav-accent-color="#020a47"
+    regular-font="Proxima Nova, -apple-system, BlinkMacSystemFont, sans-serif"
+    mono-font="IBM Plex Mono, Monaco, Consolas, monospace"
+    font-size="large"
+    render-style="view"
+    layout="column"
+    schema-style="table"
+    default-schema-tab="model"
+    response-area-height="400px"
+    show-header="false"
+    show-info="false"
+    show-side-nav="false"
+    show-components="false"
+    allow-authentication="true"
+    allow-try="false"
+    allow-spec-url-load="false"
+    allow-spec-file-load="false"
+    allow-server-selection="false"
+    allow-search="false"
+    fill-request-fields-with-example="true"
+    persist-auth="false"
+    {{ if $operationId }}goto-path="op/{{ $operationId }}"{{ end }}
+    {{ if $tag }}match-paths="tag/{{ $tag }}"{{ end }}
+  >
+    {{/* Custom overview slot - Hugo page content */}}
+    {{ with .Content }}
+    <div slot="overview">
+      {{ . }}
+    </div>
+    {{ end }}
+
+    {{/* Custom examples from frontmatter */}}
+    {{ with .Params.examples }}
+    <div slot="footer" class="api-custom-examples">
+      <h3>Examples</h3>
+      {{ range . }}
+      <div class="api-example">
+        <h4>{{ .title }}</h4>
+        {{ with .description }}<p>{{ . | markdownify }}</p>{{ end }}
+        <pre><code class="language-{{ .lang | default "bash" }}">{{ .code }}</code></pre>
+      </div>
+      {{ end }}
+    </div>
+    {{ end }}
+  </rapi-doc>
+</div>
+
+{{/* Load RapiDoc from CDN */}}
+<script type="module" src="https://unpkg.com/rapidoc/dist/rapidoc-min.js"></script>
+
+<style>
+.api-reference-wrapper {
+  width: 100%;
+}
+
+rapi-doc {
+  width: 100%;
+  min-height: 600px;
+  display: block;
+  /* Override RapiDoc's internal font sizes to match Hugo docs */
+  --font-size-small: 15px;
+  --font-size-mono: 15px;
+  --font-size-regular: 17px;
+  /* Match Hugo theme backgrounds - light mode default */
+  --bg: #ffffff;
+  --bg2: #f7f8fa;
+  --bg3: #eef0f3;
+  /* Input field border styling - subtle with transparency */
+  --border-color: rgba(0, 163, 255, 0.25);
+  --light-border-color: rgba(0, 163, 255, 0.15);
+  /* HTTP method colors - lighter palette for light theme */
+  --blue: #00A3FF;        /* $b-pool - GET */
+  --green: #34BB55;       /* $gr-rainforest - POST */
+  --orange: #FFB94A;      /* $y-pineapple - PUT (distinct from red) */
+  --red: #F95F53;         /* $r-curacao - DELETE */
+  --purple: #9b2aff;      /* $br-new-purple - PATCH */
+}
+
+/* Dark mode overrides - match Hugo $grey10: #14141F */
+[data-theme="dark"] rapi-doc,
+html:has(link[title="dark-theme"]:not([disabled])) rapi-doc {
+  --bg: #14141F;
+  /* Subtle border colors for dark mode with transparency */
+  --border-color: rgba(0, 163, 255, 0.35);
+  --light-border-color: rgba(0, 163, 255, 0.2);
+  --bg2: #1a1a2a;
+  --bg3: #252535;
+  --fg: #D4D7DD;
+  --fg2: #c8ccd2;
+  --fg3: #b0b4ba;
+  /* HTTP method colors - darker palette for dark theme */
+  --blue: #066FC5;        /* $b-ocean - GET */
+  --green: #009F5F;       /* $gr-viridian - POST */
+  --orange: #FFC800;      /* $y-thunder - PUT (brighter for dark mode) */
+  --red: #DC4E58;         /* $r-fire - DELETE */
+  --purple: #8E1FC3;      /* $p-amethyst - PATCH */
+}
+
+/* Custom examples section styling */
+.api-custom-examples {
+  padding: 1.5rem;
+  background: var(--bg2, #f7f8fa);
+  border-radius: 4px;
+  margin-top: 1rem;
+}
+
+.api-custom-examples h3 {
+  margin-top: 0;
+  margin-bottom: 1rem;
+  font-size: 1.1rem;
+}
+
+.api-example {
+  margin-bottom: 1.5rem;
+}
+
+.api-example:last-child {
+  margin-bottom: 0;
+}
+
+.api-example h4 {
+  margin: 0 0 0.5rem 0;
+  font-size: 1rem;
+}
+
+.api-example pre {
+  margin: 0;
+  padding: 1rem;
+  background: var(--bg3, #eef0f3);
+  border-radius: 4px;
+  overflow-x: auto;
+}
+</style>
+```
+
+**Step 2: Verify the inline script is removed**
+
+Run: `grep -c "<script>" layouts/partials/api/rapidoc.html`
+Expected: `1` (only the CDN script tag, no inline JavaScript)
+
+**Step 3: Commit**
+
+```bash
+git add layouts/partials/api/rapidoc.html
+git commit -m "refactor(api): Replace inline JS with data-component in rapidoc.html
+
+Remove ~230 lines of inline JavaScript and use the new api-rapidoc
+TypeScript component via data-component attribute instead."
+```
+
+***
+
+## Task 4: Remove Scalar Renderer and Related Code
+
+**Files:**
+
+- Delete: `layouts/partials/api/scalar.html`
+- Delete: `assets/js/components/api-scalar.ts`
+- Modify: `layouts/partials/api/renderer.html`
+- Modify: `assets/js/main.js`
+- Modify: `config/_default/hugo.yml`
+
+**Step 1: Delete scalar.html partial**
+
+Run: `rm layouts/partials/api/scalar.html`
+
+**Step 2: Delete api-scalar.ts component**
+
+Run: `rm assets/js/components/api-scalar.ts`
+
+**Step 3: Simplify renderer.html to only use RapiDoc**
+
+Replace the content of `layouts/partials/api/renderer.html` with:
+
+```html
+{{/*
+  API Renderer
+
+  Renders API documentation using RapiDoc.
+
+  Required page params:
+  - staticFilePath: Path to the OpenAPI specification file
+*/}}
+
+{{ partial "api/rapidoc.html" . }}
+```
+
+**Step 4: Remove ApiScalar from main.js**
+
+Remove the import line:
+
+```javascript
+import ApiScalar from './components/api-scalar.ts';
+```
+
+Remove the registry entry:
+
+```javascript
+  'api-scalar': ApiScalar,
+```
+
+**Step 5: Remove apiRenderer config from hugo.yml**
+
+Remove these lines from `config/_default/hugo.yml`:
+
+```yaml
+  # API documentation renderer: "scalar" (default) or "rapidoc"
+  apiRenderer: rapidoc
+```
+
+**Step 6: Verify deletions**
+
+Run: `ls layouts/partials/api/scalar.html assets/js/components/api-scalar.ts 2>&1`
+Expected: "No such file or directory" for both
+
+Run: `grep -c "ApiScalar\|api-scalar" assets/js/main.js`
+Expected: `0`
+
+**Step 7: Commit**
+
+```bash
+git add -A
+git commit -m "refactor(api): Remove Scalar renderer and related code
+
+Remove unused Scalar API documentation renderer:
+- Delete layouts/partials/api/scalar.html
+- Delete assets/js/components/api-scalar.ts
+- Simplify renderer.html to only use RapiDoc
+- Remove ApiScalar from main.js component registry
+- Remove apiRenderer config option from hugo.yml"
+```
+
+***
+
+## Task 5: Remove Deprecated api-tabs Component
+
+**Files:**
+
+- Delete: `assets/js/components/api-tabs.ts`
+- Delete: `layouts/partials/api/tabs.html`
+- Delete: `layouts/partials/api/tab-panels.html`
+- Modify: `assets/js/main.js`
+
+**Step 1: Delete api-tabs.ts**
+
+Run: `rm assets/js/components/api-tabs.ts`
+
+**Step 2: Delete tabs.html partial**
+
+Run: `rm layouts/partials/api/tabs.html`
+
+**Step 3: Delete tab-panels.html partial**
+
+Run: `rm layouts/partials/api/tab-panels.html`
+
+**Step 4: Remove ApiTabs from main.js**
+
+Remove the import line:
+
+```javascript
+import ApiTabs from './components/api-tabs.ts';
+```
+
+Remove the registry entry:
+
+```javascript
+  'api-tabs': ApiTabs,
+```
+
+**Step 5: Verify deletions**
+
+Run: `ls assets/js/components/api-tabs.ts layouts/partials/api/tabs.html layouts/partials/api/tab-panels.html 2>&1`
+Expected: "No such file or directory" for all
+
+Run: `grep -c "ApiTabs\|api-tabs" assets/js/main.js`
+Expected: `0`
+
+**Step 6: Commit**
+
+```bash
+git add -A
+git commit -m "refactor(api): Remove deprecated api-tabs component
+
+Remove unused tabs component and partials:
+- Delete assets/js/components/api-tabs.ts
+- Delete layouts/partials/api/tabs.html
+- Delete layouts/partials/api/tab-panels.html
+- Remove ApiTabs from main.js component registry
+
+The new architecture renders content directly without tabs."
+```
+
+***
+
+## Task 6: Update Cypress Tests
+
+**Files:**
+
+- Modify: `cypress/e2e/content/api-reference.cy.js`
+
+**Step 1: Remove tab-related tests**
+
+Remove the tests that reference tabs, tab-panels, and the 3-column layout tests that expect tabs. The tests for the basic API reference pages and RapiDoc Mini should remain.
+
+Specifically, remove:
+
+1. The `describe('API reference 3-column layout', ...)` block that tests tabs (lines 134-275)
+2. Keep the basic API reference tests and RapiDoc Mini tests
+
+**Step 2: Verify tests still work**
+
+Run: `node cypress/support/run-e2e-specs.js --spec "cypress/e2e/content/api-reference.cy.js" content/influxdb3/core/api/_index.md`
+Expected: Tests pass
+
+**Step 3: Commit**
+
+```bash
+git add cypress/e2e/content/api-reference.cy.js
+git commit -m "test(api): Remove deprecated tab-related tests
+
+Remove tests for tabs and 3-column layout that no longer exist.
+Keep basic API reference tests and RapiDoc Mini component tests."
+```
+
+***
+
+## Task 7: Run Full Test Suite and Verify
+
+**Files:**
+
+- None (verification only)
+
+**Step 1: Build Hugo site**
+
+Run: `npx hugo --quiet`
+Expected: Build succeeds without errors
+
+**Step 2: Start Hugo server**
+
+Run: `npx hugo server &`
+Expected: Server starts on port 1313
+
+**Step 3: Test API pages load correctly**
+
+Run: `curl -s -o /dev/null -w "%{http_code}" http://localhost:1313/influxdb3/core/api/`
+Expected: `200`
+
+Run: `curl -s -o /dev/null -w "%{http_code}" http://localhost:1313/influxdb3/core/api/write/post/`
+Expected: `200`
+
+**Step 4: Run Cypress API tests**
+
+Run: `node cypress/support/run-e2e-specs.js --spec "cypress/e2e/content/api-reference.cy.js" content/influxdb3/core/api/_index.md`
+Expected: All tests pass
+
+**Step 5: Stop Hugo server**
+
+Run: `pkill -f "hugo server"`
+
+**Step 6: Final commit if any fixes needed**
+
+```bash
+git status
+# If any files need fixing, make changes and commit
+```
+
+***
+
+## Summary
+
+This plan:
+
+1. Creates `api-rapidoc.ts` - a TypeScript component extracting \~230 lines of inline JS from rapidoc.html
+2. Registers the new component in main.js
+3. Updates rapidoc.html to use `data-component` pattern instead of inline scripts
+4. Removes unused Scalar renderer code (scalar.html, api-scalar.ts, config option)
+5. Removes deprecated tabs components (api-tabs.ts, tabs.html, tab-panels.html)
+6. Updates Cypress tests to remove tab-related tests
+7. Verifies everything works with Hugo build and test suite
+
+Total files changed:
+
+- 1 file created: `assets/js/components/api-rapidoc.ts`
+- 5 files deleted: scalar.html, api-scalar.ts, api-tabs.ts, tabs.html, tab-panels.html
+- 4 files modified: rapidoc.html, renderer.html, main.js, hugo.yml, api-reference.cy.js
diff --git a/layouts/_default/api.html b/layouts/_default/api.html
index 68a09ae661..bee90952e4 100644
--- a/layouts/_default/api.html
+++ b/layouts/_default/api.html
@@ -1 +1,33 @@
-{{ .Content }}
+{{/*
+  API Documentation Default Layout
+
+  Full page layout for API documentation using the renderer abstraction.
+  The renderer (Scalar or RapiDoc) is selected via site.Params.apiRenderer.
+
+  Required frontmatter:
+  - staticFilePath: Path to the OpenAPI specification file
+*/}}
+
+{{ partial "header.html" . }}
+{{ partial "topnav.html" . }}
+
+<div class="page-wrapper">
+  {{ partial "sidebar.html" . }}
+  <div class="content-wrapper">
+    <article class="article article--content api-reference" role="main">
+      <header class="article--header">
+        <h1 class="article--title">{{ .Title }}</h1>
+        {{ with .Description }}
+        <p class="article--description">{{ . }}</p>
+        {{ end }}
+      </header>
+
+      {{/* Render API documentation using the configured renderer */}}
+      {{ partial "api/renderer.html" . }}
+
+    </article>
+    <div class="copyright">&copy; {{ now.Year }} InfluxData, Inc.</div>
+  </div>
+</div>
+
+{{ partial "footer.html" . }}
diff --git a/layouts/api-operation/operation.html b/layouts/api-operation/operation.html
new file mode 100644
index 0000000000..f839d27ac4
--- /dev/null
+++ b/layouts/api-operation/operation.html
@@ -0,0 +1,73 @@
+{{/*
+  API Operation Page Layout
+
+  Standalone page for a single API operation, rendered using RapiDoc Mini.
+  Uses existing tag-level OpenAPI specs with client-side filtering via match-paths.
+
+  Required frontmatter:
+  - title: Operation display name (e.g., "Write line protocol (v1-compatible)")
+  - description: SEO description
+  - specFile: Path to tag-level OpenAPI spec
+  - matchPaths: RapiDoc Mini filter (e.g., "post /write")
+  - operationId: The operationId from the spec
+  - method: HTTP method (GET, POST, PUT, DELETE, etc.)
+  - apiPath: The API path (e.g., "/write", "/api/v2/write")
+
+  Optional frontmatter:
+  - compatVersion: v1 or v2 for compatibility badges
+  - tag: Associated tag name
+  - related: Array of related documentation paths
+*/}}
+
+{{ partial "header.html" . }}
+{{ partial "topnav.html" . }}
+
+<div class="page-wrapper">
+  {{/* Left: Existing Hugo sidebar */}}
+  {{ partial "sidebar.html" . }}
+
+  {{/* Center + Right: Content and TOC */}}
+  <div class="content-wrapper api-content">
+    <div class="api-main">
+      <article class="article article--content api-reference api-operation-page" role="main">
+        {{/* Visually hidden h1 for SEO/accessibility - RapiDoc shows visible title */}}
+        <h1 class="sr-only">{{ .Title }}</h1>
+
+        {{/* Download OpenAPI spec button - positioned above RapiDoc */}}
+        {{ with .Params.specFile }}
+        <div class="api-spec-actions">
+          <a href="{{ . }}" class="btn api-spec-download" download>
+            <svg width="16" height="16" viewBox="0 0 16 16" fill="currentColor" aria-hidden="true">
+              <path d="M8 12L3 7h3V2h4v5h3L8 12z"/>
+              <path d="M1 14h14v2H1v-2z"/>
+            </svg>
+            Download OpenAPI Spec
+          </a>
+        </div>
+        {{ end }}
+
+        {{/* Hugo page content shown as overview */}}
+        {{ with .Content }}
+        <section class="api-content-overview">
+          {{ . }}
+        </section>
+        {{ end }}
+
+        {{/* RapiDoc Mini renderer for single operation */}}
+        {{ with .Params.specFile }}
+        <section class="api-renderer-section">
+          {{ partial "api/rapidoc-mini.html" $ }}
+        </section>
+        {{ end }}
+
+        {{/* Related documentation links */}}
+        {{ partial "article/related.html" . }}
+
+      </article>
+    </div>
+
+    {{/* Right sidebar hidden - operation pages have no TOC headings */}}
+  </div>
+</div>
+
+{{ partial "footer.html" . }}
diff --git a/layouts/api/list.html b/layouts/api/list.html
new file mode 100644
index 0000000000..cd860cb898
--- /dev/null
+++ b/layouts/api/list.html
@@ -0,0 +1,101 @@
+{{/*
+  API Documentation Layout
+
+  Handles two cases:
+  1. Section index (no 'tag' param) - shows list of tag pages from article data
+  2. Tag pages (has 'tag' param) - shows operations list and description
+
+  For conceptual pages (isConceptual: true), shows content without operations list.
+*/}}
+
+{{ partial "header.html" . }}
+{{ partial "topnav.html" . }}
+
+<div class="page-wrapper">
+  {{ partial "sidebar.html" . }}
+
+  <div class="content-wrapper api-content">
+    <div class="api-main">
+      <article class="article article--content api-reference" role="main">
+        <header class="article--header">
+          <h1 class="article--title">{{ .Title }}</h1>
+          {{ with .Description }}
+          <p class="article--description">{{ . }}</p>
+          {{ end }}
+        </header>
+
+        {{/* Check if this is a section index (no tag param) or a tag page */}}
+        {{ $hasTag := isset .Params "tag" }}
+
+        {{ if not $hasTag }}
+        {{/* SECTION INDEX - Show tag pages from article data */}}
+        {{ partial "api/section-children.html" . }}
+
+        {{ else }}
+        {{/* TAG PAGE - Show operations or conceptual content */}}
+        {{ $isConceptual := .Params.isConceptual | default false }}
+
+        {{ if $isConceptual }}
+        {{/* Conceptual Page - Show content directly */}}
+        <section class="api-conceptual-content">
+          {{ with .Content }}
+            {{ . }}
+          {{ else }}
+            {{ with .Params.tagDescription }}
+              {{ . | markdownify }}
+            {{ end }}
+          {{ end }}
+        </section>
+
+        {{ else }}
+        {{/* Operational Page - Show operations list then description */}}
+        {{ $operations := .Params.operations }}
+        {{ if $operations }}
+        <section class="api-operations-list">
+          <h2 id="endpoints">Endpoints</h2>
+          <div class="api-operations-grid">
+            {{ range $operations }}
+            {{ $apiBase := $.Parent.RelPermalink }}
+            {{ $operationURL := printf "%s%s/%s/" $apiBase .path (lower .method) }}
+            <a href="{{ $operationURL }}" class="api-operation-card">
+              <span class="api-method api-method--{{ lower .method }}">{{ upper .method }}</span>
+              <code class="api-path">{{ .path }}</code>
+              <span class="api-operation-summary">{{ .summary }}</span>
+            </a>
+            {{ end }}
+          </div>
+        </section>
+        {{ end }}
+
+        {{/* Overview - full tag description after endpoints */}}
+        {{ $desc := .Description | strings.TrimSpace }}
+        {{ if gt (len $desc) 0 }}
+        <section class="api-description">
+          <h2 id="overview">Overview</h2>
+          {{ $desc | markdownify }}
+        </section>
+        {{ end }}
+
+        {{/* Hugo page content if any */}}
+        {{ with .Content }}
+        <section class="api-content-body">
+          {{ . }}
+        </section>
+        {{ end }}
+
+        {{ end }}
+        {{ end }}
+
+        {{ partial "article/related.html" . }}
+
+      </article>
+    </div>
+
+    <aside class="api-toc" data-component="api-toc">
+      <h4 class="api-toc-header">ON THIS PAGE</h4>
+      <nav class="api-toc-nav"></nav>
+    </aside>
+  </div>
+</div>
+
+{{ partial "footer.html" . }}
diff --git a/layouts/api/single.html b/layouts/api/single.html
new file mode 100644
index 0000000000..362acbc8d4
--- /dev/null
+++ b/layouts/api/single.html
@@ -0,0 +1,122 @@
+{{/*
+  API Documentation Single Page Layout
+
+  Used for:
+  - Individual operation pages (nested under tag pages)
+  - Conceptual pages (isConceptual: true) like Authentication, Quick start
+
+  For operation pages:
+  - Renders RapiDoc with "Mix your own HTML" slots for custom content
+  - Shows method badge, path, and operation details
+
+  For conceptual pages:
+  - Shows Hugo content or tagDescription markdown
+
+  Required frontmatter:
+  - title: Page title
+  - staticFilePath: Path to OpenAPI spec (for operation pages)
+  - operationId: Operation ID to render (for operation pages)
+  - isConceptual: true (for conceptual pages)
+*/}}
+
+{{ partial "header.html" . }}
+{{ partial "topnav.html" . }}
+
+<div class="page-wrapper">
+  {{/* Left: Existing Hugo sidebar (includes API nav via sidebar.html) */}}
+  {{ partial "sidebar.html" . }}
+
+  {{/* Center + Right: Content and TOC */}}
+  <div class="content-wrapper api-content">
+    <div class="api-main">
+      <article class="article article--content api-reference" role="main">
+        <header class="article--header">
+          <div class="article--header-row">
+            <div class="article--header-text">
+              {{/* For operation pages, show method badge with title */}}
+              {{ with .Params.method }}
+              <div class="api-operation-header">
+                <span class="api-method api-method--{{ lower . }}">{{ upper . }}</span>
+                <h1 class="article--title">{{ $.Title }}</h1>
+              </div>
+              {{ with $.Params.path }}
+              <code class="api-operation-path">{{ . }}</code>
+              {{ end }}
+              {{ else }}
+              <h1 class="article--title">{{ .Title }}</h1>
+              {{ end }}
+
+              {{/* Summary/Description - skip for conceptual pages (shown in content section) */}}
+              {{ if not (.Params.isConceptual | default false) }}
+                {{ with .Params.summary }}
+                <p class="article--summary">{{ . | markdownify }}</p>
+                {{ else }}
+                  {{ with .Description }}
+                  <p class="article--summary">{{ . | markdownify }}</p>
+                  {{ end }}
+                {{ end }}
+              {{ end }}
+            </div>
+
+            {{/* Download OpenAPI spec button */}}
+            {{ with .Params.staticFilePath }}
+            <div class="api-spec-actions">
+              <a href="{{ . }}" class="btn api-spec-download" download>
+                <svg width="16" height="16" viewBox="0 0 16 16" fill="currentColor" aria-hidden="true">
+                  <path d="M8 12L3 7h3V2h4v5h3L8 12z"/>
+                  <path d="M1 14h14v2H1v-2z"/>
+                </svg>
+                Download OpenAPI Spec
+              </a>
+            </div>
+            {{ end }}
+          </div>
+        </header>
+
+        {{ $isConceptual := .Params.isConceptual | default false }}
+
+        {{ if $isConceptual }}
+        {{/* Conceptual Page - Show content directly */}}
+        <section class="api-conceptual-content">
+          {{ with .Content }}
+            {{ . }}
+          {{ else }}
+            {{ with .Params.tagDescription }}
+              {{ . | markdownify }}
+            {{ end }}
+          {{ end }}
+        </section>
+        {{ else }}
+        {{/* Operation Page - RapiDoc with custom slots */}}
+
+        {{/* Hugo page content shown as overview */}}
+        {{ with .Content }}
+        <section class="api-content-overview">
+          {{ . }}
+        </section>
+        {{ end }}
+
+        {{/* RapiDoc renderer with slot-based customization */}}
+        {{ with .Params.staticFilePath }}
+        <section class="api-renderer-section">
+          {{ partial "api/rapidoc.html" $ }}
+        </section>
+        {{ end }}
+
+        {{ end }}
+
+        {{/* Related documentation links */}}
+        {{ partial "article/related.html" . }}
+
+      </article>
+    </div>
+
+    {{/* Right: Page TOC - "ON THIS PAGE" */}}
+    <aside class="api-toc" data-component="api-toc">
+      <h4 class="api-toc-header">ON THIS PAGE</h4>
+      <nav class="api-toc-nav"></nav>
+    </aside>
+  </div>
+</div>
+
+{{ partial "footer.html" . }}
diff --git a/layouts/partials/api/rapidoc-mini.html b/layouts/partials/api/rapidoc-mini.html
new file mode 100644
index 0000000000..2d72510779
--- /dev/null
+++ b/layouts/partials/api/rapidoc-mini.html
@@ -0,0 +1,136 @@
+{{/*
+  RapiDoc Mini - Lightweight Single Operation Renderer
+
+  Renders a single API operation using RapiDoc Mini web component.
+  Uses TypeScript component for initialization and theme management.
+
+  Required page params:
+  - specFile: Path to the OpenAPI specification file
+  - matchPaths: Filter expression (e.g., "post /write" or "get /api/v3/query_sql")
+
+  Optional page params:
+  - operationId: Operation ID for linking/navigation purposes
+*/}}
+
+{{ $specPath := .Params.specFile }}
+{{ $specPathJSON := replace $specPath ".yaml" ".json" | replace ".yml" ".json" }}
+{{ $matchPaths := .Params.matchPaths | default "" }}
+
+{{/* Machine-readable links for AI agent discovery */}}
+{{ if $specPath }}
+<link rel="alternate" type="application/x-yaml" href="{{ $specPath | absURL }}" title="OpenAPI Specification (YAML)" />
+<link rel="alternate" type="application/json" href="{{ $specPathJSON | absURL }}" title="OpenAPI Specification (JSON)" />
+{{ end }}
+
+{{/* Component container - TypeScript handles initialization */}}
+<div class="api-reference-wrapper api-reference-mini"
+     data-component="rapidoc-mini"
+     data-spec-url="{{ $specPath }}"
+     {{ with $matchPaths }}data-match-paths="{{ . }}"{{ end }}>
+  {{/* RapiDoc Mini element created by TypeScript component */}}
+</div>
+
+{{/* Custom slot content if needed */}}
+{{ with .Content }}
+<div class="api-overview-content">
+  {{ . }}
+</div>
+{{ end }}
+
+<style>
+/* Screen reader only - visually hidden but accessible */
+.sr-only {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  padding: 0;
+  margin: -1px;
+  overflow: hidden;
+  clip: rect(0, 0, 0, 0);
+  white-space: nowrap;
+  border: 0;
+}
+
+.api-reference-mini {
+  width: 100%;
+  margin: 1rem 0;
+  position: relative; /* Contains absolutely positioned auth elements */
+}
+
+rapi-doc-mini,
+rapi-doc {
+  width: 100%;
+  min-height: 300px;
+  display: block;
+  border: none;
+  border-radius: 0;
+
+  /* Override RapiDoc internal CSS variables - subtle borders */
+  --light-border-color: rgba(0, 163, 255, 0.25);
+  --border-color: rgba(0, 163, 255, 0.25);
+  /* HTTP method colors - lighter palette for light theme */
+  --blue: #00A3FF;        /* $b-pool - GET */
+  --green: #34BB55;       /* $gr-rainforest - POST */
+  --orange: #FFB94A;      /* $y-pineapple - PUT (distinct from red) */
+  --red: #F95F53;         /* $r-curacao - DELETE */
+  --purple: #9b2aff;      /* $br-new-purple - PATCH */
+}
+
+/* Dark mode overrides */
+[data-theme="dark"] rapi-doc-mini,
+[data-theme="dark"] rapi-doc,
+html:has(link[title="dark-theme"]:not([disabled])) rapi-doc-mini,
+html:has(link[title="dark-theme"]:not([disabled])) rapi-doc {
+  /* HTTP method colors - darker palette for dark theme */
+  --blue: #066FC5;        /* $b-ocean - GET */
+  --green: #009F5F;       /* $gr-viridian - POST */
+  --orange: #FFC800;      /* $y-thunder - PUT (brighter for dark mode) */
+  --red: #DC4E58;         /* $r-fire - DELETE */
+  --purple: #8E1FC3;      /* $p-amethyst - PATCH */
+}
+
+/* Hide tag section on operation pages - only show on tag landing pages */
+rapi-doc::part(section-tag) {
+  display: none;
+}
+
+/* Fix parameter table layout - reduce indentation from empty td cells */
+/* Match site's body font size (16px) for consistency */
+rapi-doc {
+  --font-size-regular: 16px;
+}
+
+/* Fix auth schemes at narrow widths - ensure content is scrollable */
+@media (max-width: 1280px) {
+  .api-reference-mini {
+    overflow-x: auto;
+  }
+
+  rapi-doc-mini, rapi-doc {
+    min-width: 800px; /* Prevent auth elements from collapsing/overlapping */
+  }
+}
+
+
+/* Error state styling */
+.api-operation-error {
+  padding: 2rem;
+  text-align: center;
+  color: #BF3D5E; /* $r-ruby */
+  background: #FFF7F4; /* $r-flan */
+  border: 1px solid #C6CAD3;
+  border-radius: 4px;
+  margin: 1rem 0;
+}
+
+.api-operation-error p {
+  margin: 0.5rem 0;
+}
+
+[data-theme="dark"] .api-operation-error,
+html:has(link[title="dark-theme"]:not([disabled])) .api-operation-error {
+  background: #2F1F29; /* $r-basalt */
+  color: #FFB6A0; /* $r-tungsten */
+  border-color: #333346;
+}
+</style>
diff --git a/layouts/partials/api/rapidoc.html b/layouts/partials/api/rapidoc.html
new file mode 100644
index 0000000000..dedb620ed2
--- /dev/null
+++ b/layouts/partials/api/rapidoc.html
@@ -0,0 +1,179 @@
+{{/*
+  RapiDoc API Documentation Renderer
+
+  Primary API documentation renderer using RapiDoc with "Mix your own HTML" slots.
+  See: https://rapidocweb.com/examples.html
+
+  Required page params:
+  - staticFilePath: Path to the OpenAPI specification file
+
+  Optional page params:
+  - operationId: Specific operation to display (renders only that operation)
+  - tag: Tag to filter operations by
+
+  RapiDoc slots available for custom content:
+  - slot="header" - Custom header
+  - slot="footer" - Custom footer
+  - slot="overview" - Custom overview content
+  - slot="auth" - Custom authentication section
+  - slot="nav-logo" - Custom navigation logo
+*/}}
+
+{{ $specPath := .Params.staticFilePath }}
+{{ $specPathJSON := replace $specPath ".yaml" ".json" | replace ".yml" ".json" }}
+{{ $operationId := .Params.operationId | default "" }}
+{{ $tag := .Params.tag | default "" }}
+
+{{/* Machine-readable links for AI agent discovery */}}
+{{ if $specPath }}
+<link rel="alternate" type="application/x-yaml" href="{{ $specPath | absURL }}" title="OpenAPI Specification (YAML)" />
+<link rel="alternate" type="application/json" href="{{ $specPathJSON | absURL }}" title="OpenAPI Specification (JSON)" />
+{{ end }}
+
+<div class="api-reference-wrapper" data-component="api-rapidoc">
+  {{/* RapiDoc component with slot-based customization */}}
+  <rapi-doc
+    id="api-doc"
+    spec-url="{{ $specPath }}"
+    theme="light"
+    bg-color="#ffffff"
+    text-color="#2b2b2b"
+    header-color="#020a47"
+    primary-color="#00A3FF"
+    nav-bg-color="#f7f8fa"
+    nav-text-color="#2b2b2b"
+    nav-hover-bg-color="#e8e8f0"
+    nav-hover-text-color="#020a47"
+    nav-accent-color="#020a47"
+    regular-font="Proxima Nova, -apple-system, BlinkMacSystemFont, sans-serif"
+    mono-font="IBM Plex Mono, Monaco, Consolas, monospace"
+    font-size="large"
+    render-style="view"
+    layout="column"
+    schema-style="table"
+    default-schema-tab="model"
+    response-area-height="400px"
+    show-header="false"
+    show-info="false"
+    show-side-nav="false"
+    show-components="false"
+    allow-authentication="true"
+    allow-try="false"
+    allow-spec-url-load="false"
+    allow-spec-file-load="false"
+    allow-server-selection="false"
+    allow-search="false"
+    fill-request-fields-with-example="true"
+    persist-auth="false"
+    {{ if $operationId }}goto-path="op/{{ $operationId }}"{{ end }}
+    {{ if $tag }}match-paths="tag/{{ $tag }}"{{ end }}
+  >
+    {{/* Custom overview slot - Hugo page content */}}
+    {{ with .Content }}
+    <div slot="overview">
+      {{ . }}
+    </div>
+    {{ end }}
+
+    {{/* Custom examples from frontmatter */}}
+    {{ with .Params.examples }}
+    <div slot="footer" class="api-custom-examples">
+      <h3>Examples</h3>
+      {{ range . }}
+      <div class="api-example">
+        <h4>{{ .title }}</h4>
+        {{ with .description }}<p>{{ . | markdownify }}</p>{{ end }}
+        <pre><code class="language-{{ .lang | default "bash" }}">{{ .code }}</code></pre>
+      </div>
+      {{ end }}
+    </div>
+    {{ end }}
+  </rapi-doc>
+</div>
+
+{{/* Load RapiDoc from CDN */}}
+<script type="module" src="https://unpkg.com/rapidoc/dist/rapidoc-min.js"></script>
+
+<style>
+.api-reference-wrapper {
+  width: 100%;
+}
+
+rapi-doc {
+  width: 100%;
+  min-height: 600px;
+  display: block;
+  /* Override RapiDoc's internal font sizes to match Hugo docs */
+  --font-size-small: 15px;
+  --font-size-mono: 15px;
+  --font-size-regular: 17px;
+  /* Match Hugo theme backgrounds - light mode default */
+  --bg: #ffffff;
+  --bg2: #f7f8fa;
+  --bg3: #eef0f3;
+  /* Input field border styling - subtle with transparency */
+  --border-color: rgba(0, 163, 255, 0.25);
+  --light-border-color: rgba(0, 163, 255, 0.15);
+  /* HTTP method colors - lighter palette for light theme */
+  --blue: #00A3FF;        /* $b-pool - GET */
+  --green: #34BB55;       /* $gr-rainforest - POST */
+  --orange: #FFB94A;      /* $y-pineapple - PUT (distinct from red) */
+  --red: #F95F53;         /* $r-curacao - DELETE */
+  --purple: #9b2aff;      /* $br-new-purple - PATCH */
+}
+
+/* Dark mode overrides - match Hugo $grey10: #14141F */
+[data-theme="dark"] rapi-doc,
+html:has(link[title="dark-theme"]:not([disabled])) rapi-doc {
+  --bg: #14141F;
+  /* Subtle border colors for dark mode with transparency */
+  --border-color: rgba(0, 163, 255, 0.35);
+  --light-border-color: rgba(0, 163, 255, 0.2);
+  --bg2: #1a1a2a;
+  --bg3: #252535;
+  --fg: #D4D7DD;
+  --fg2: #c8ccd2;
+  --fg3: #b0b4ba;
+  /* HTTP method colors - darker palette for dark theme */
+  --blue: #066FC5;        /* $b-ocean - GET */
+  --green: #009F5F;       /* $gr-viridian - POST */
+  --orange: #FFC800;      /* $y-thunder - PUT (brighter for dark mode) */
+  --red: #DC4E58;         /* $r-fire - DELETE */
+  --purple: #8E1FC3;      /* $p-amethyst - PATCH */
+}
+
+/* Custom examples section styling */
+.api-custom-examples {
+  padding: 1.5rem;
+  background: var(--bg2, #f7f8fa);
+  border-radius: 4px;
+  margin-top: 1rem;
+}
+
+.api-custom-examples h3 {
+  margin-top: 0;
+  margin-bottom: 1rem;
+  font-size: 1.1rem;
+}
+
+.api-example {
+  margin-bottom: 1.5rem;
+}
+
+.api-example:last-child {
+  margin-bottom: 0;
+}
+
+.api-example h4 {
+  margin: 0 0 0.5rem 0;
+  font-size: 1rem;
+}
+
+.api-example pre {
+  margin: 0;
+  padding: 1rem;
+  background: var(--bg3, #eef0f3);
+  border-radius: 4px;
+  overflow-x: auto;
+}
+</style>
diff --git a/layouts/partials/api/renderer.html b/layouts/partials/api/renderer.html
new file mode 100644
index 0000000000..de3dfe9389
--- /dev/null
+++ b/layouts/partials/api/renderer.html
@@ -0,0 +1,10 @@
+{{/*
+  API Renderer
+
+  Renders API documentation using RapiDoc.
+
+  Required page params:
+  - staticFilePath: Path to the OpenAPI specification file
+*/}}
+
+{{ partial "api/rapidoc.html" . }}
diff --git a/layouts/partials/api/section-children.html b/layouts/partials/api/section-children.html
new file mode 100644
index 0000000000..a381e8d091
--- /dev/null
+++ b/layouts/partials/api/section-children.html
@@ -0,0 +1,87 @@
+{{/*
+  API Section Children
+
+  Renders tag pages from article data as a children list.
+  Sort order: conceptual tags (traitTags) first, then other tags alphabetically.
+
+  Uses data from:
+  - data/article_data/influxdb/{product}/articles.yml
+*/}}
+
+{{ $currentPage := . }}
+
+{{/* Extract product and version from URL */}}
+{{ $productPathData := findRE "[^/]+.*?" .RelPermalink }}
+{{ $product := index $productPathData 0 }}
+{{ $version := index $productPathData 1 }}
+
+{{/* Build data key for article data lookup */}}
+{{ $dataKey := "" }}
+{{ if eq $product "influxdb3" }}
+  {{ $dataKey = print "influxdb3_" $version }}
+{{ else if eq $product "influxdb" }}
+  {{ $dataKey = print $version }}
+{{ else }}
+  {{ $dataKey = $product }}
+{{ end }}
+
+{{/* Get article data for this product */}}
+{{ $articles := slice }}
+{{ with site.Data.article_data }}
+  {{ with index . "influxdb" }}
+    {{ with index . $dataKey }}
+      {{ with index . "articles" }}
+        {{ with .articles }}
+          {{ $articles = . }}
+        {{ end }}
+      {{ end }}
+    {{ end }}
+  {{ end }}
+{{ end }}
+
+{{ if gt (len $articles) 0 }}
+  {{/* Separate conceptual (traitTag) and non-conceptual articles */}}
+  {{ $conceptualArticles := slice }}
+  {{ $operationArticles := slice }}
+
+  {{ range $articles }}
+    {{ if and (reflect.IsMap .) (isset . "fields") }}
+      {{ $fields := index . "fields" }}
+      {{ if reflect.IsMap $fields }}
+        {{ $isConceptual := false }}
+        {{ if isset $fields "isConceptual" }}
+          {{ $isConceptual = index $fields "isConceptual" }}
+        {{ end }}
+        {{ if $isConceptual }}
+          {{ $conceptualArticles = $conceptualArticles | append . }}
+        {{ else }}
+          {{ $operationArticles = $operationArticles | append . }}
+        {{ end }}
+      {{ end }}
+    {{ end }}
+  {{ end }}
+
+  {{/* Sort each group alphabetically by tag name */}}
+  {{ $conceptualArticles = sort $conceptualArticles "fields.tag" }}
+  {{ $operationArticles = sort $operationArticles "fields.tag" }}
+
+  {{/* Combine: conceptual first, then operations */}}
+  {{ $sortedArticles := $conceptualArticles | append $operationArticles }}
+
+  <section class="api-children children">
+    {{ range $sortedArticles }}
+      {{ $path := index . "path" }}
+      {{ $fields := index . "fields" }}
+      {{ $tag := index $fields "tag" }}
+      {{ $description := index $fields "description" | default "" }}
+      {{ $tagPageUrl := print "/" $product "/" $version "/" $path "/" | relURL }}
+
+      <div class="child-item">
+        <h3 id="{{ $tag | urlize }}"><a href="{{ $tagPageUrl }}">{{ $tag }}</a></h3>
+        {{ with $description }}
+        <p>{{ . }}</p>
+        {{ end }}
+      </div>
+    {{ end }}
+  </section>
+{{ end }}
diff --git a/layouts/partials/sidebar.html b/layouts/partials/sidebar.html
index 0dd150396b..73da7ad6ff 100644
--- a/layouts/partials/sidebar.html
+++ b/layouts/partials/sidebar.html
@@ -72,12 +72,12 @@
   {{ $platformMenu := .Site.Menus.platform }}
 
   <!-- Product Main Navigation -->
-  {{ partial "sidebar/nested-menu" (dict "page" $currentPage "menu" $mainMenu) . }}
+  {{ partial "sidebar/nested-menu" (dict "page" $currentPage "menu" $mainMenu "siteData" .Site.Data) }}
 
   <!-- Product Reference Navigation -->
   {{ if gt (len $refMenu) 0 }}
     <h4 class="reference">Reference</h4>
-    {{ partial "sidebar/nested-menu" (dict "page" $currentPage "menu" $refMenu) . }}
+    {{ partial "sidebar/nested-menu" (dict "page" $currentPage "menu" $refMenu "siteData" .Site.Data) }}
   {{ end }}
 
   <!-- Flux links for InfluxDB docs -->
@@ -95,7 +95,7 @@ <h4 class="flux">Flux</h4>
   {{ $platformWhitelist := `telegraf|chronograf|kapacitor|enterprise_influxdb|influxdb_1` }}
   {{ if gt (len (findRE $platformWhitelist $menuKey)) 0 }}
     <h4 class="platform">InfluxData Platform</h4>
-    {{ partial "sidebar/nested-menu" (dict "page" $currentPage "menu" $platformMenu) . }}
+    {{ partial "sidebar/nested-menu" (dict "page" $currentPage "menu" $platformMenu "siteData" .Site.Data) }}
   {{ end }}
 
   <!-- Additional resources for all docs -->
diff --git a/layouts/partials/sidebar/api-menu-items.html b/layouts/partials/sidebar/api-menu-items.html
new file mode 100644
index 0000000000..b5c8bade13
--- /dev/null
+++ b/layouts/partials/sidebar/api-menu-items.html
@@ -0,0 +1,203 @@
+{{/*
+  API Reference Menu Items for Hugo Navigation
+
+  Generates <li class="nav-item"> elements matching Hugo's menu structure.
+  Used by nested-menu.html when rendering "InfluxDB HTTP API" menu item.
+
+  Sort order: conceptual tags (traitTags) first, then other tags alphabetically.
+
+  Parameters:
+  - page: Current page context
+  - url: URL of the API parent page (e.g., /influxdb3/core/api/)
+
+  Uses data from:
+  - data/article_data/influxdb/{product}/articles.yml
+*/}}
+
+{{ $currentPage := .page }}
+{{ $apiUrl := .url }}
+
+{{/* Extract product and version from API URL */}}
+{{ $productPathData := findRE "[^/]+.*?" $apiUrl }}
+{{ $product := index $productPathData 0 }}
+{{ $version := index $productPathData 1 }}
+
+{{/* Build data key for article data lookup */}}
+{{ $dataKey := "" }}
+{{ if eq $product "influxdb3" }}
+  {{ $dataKey = print "influxdb3_" $version }}
+{{ else if eq $product "influxdb" }}
+  {{ $dataKey = print $version }}
+{{ else }}
+  {{ $dataKey = $product }}
+{{ end }}
+
+{{/* Get article data for this product */}}
+{{ $siteData := .siteData }}
+{{ $articles := slice }}
+{{ with $siteData.article_data }}
+  {{ with index . "influxdb" }}
+    {{ with index . $dataKey }}
+      {{ with index . "articles" }}
+        {{ with .articles }}
+          {{ $articles = . }}
+        {{ end }}
+      {{ end }}
+    {{ end }}
+  {{ end }}
+{{ end }}
+
+{{/* Check if articles use tag-based structure */}}
+{{ $isTagBased := false }}
+{{ if gt (len $articles) 0 }}
+  {{ $firstArticle := index $articles 0 }}
+  {{ if reflect.IsMap $firstArticle }}
+    {{ with index $firstArticle "fields" }}
+      {{ if reflect.IsMap . }}
+        {{ if isset . "tag" }}
+          {{ $isTagBased = true }}
+        {{ end }}
+      {{ end }}
+    {{ end }}
+  {{ end }}
+{{ end }}
+
+{{ if and (gt (len $articles) 0) $isTagBased }}
+  {{/* Separate conceptual (traitTag) and non-conceptual articles */}}
+  {{ $conceptualArticles := slice }}
+  {{ $operationArticles := slice }}
+
+  {{ range $articles }}
+    {{ if and (reflect.IsMap .) (isset . "fields") }}
+      {{ $fields := index . "fields" }}
+      {{ if reflect.IsMap $fields }}
+        {{ $isConceptual := false }}
+        {{ if isset $fields "isConceptual" }}
+          {{ $isConceptual = index $fields "isConceptual" }}
+        {{ end }}
+        {{ if $isConceptual }}
+          {{ $conceptualArticles = $conceptualArticles | append . }}
+        {{ else }}
+          {{ $operationArticles = $operationArticles | append . }}
+        {{ end }}
+      {{ end }}
+    {{ end }}
+  {{ end }}
+
+  {{/* Sort each group alphabetically by tag name */}}
+  {{ $conceptualArticles = sort $conceptualArticles "fields.tag" }}
+  {{ $operationArticles = sort $operationArticles "fields.tag" }}
+
+  {{/* Combine: conceptual first, then operations */}}
+  {{ $sortedArticles := $conceptualArticles | append $operationArticles }}
+
+  {{/* Render each tag as a nav item */}}
+  {{ range $sortedArticles }}
+    {{ $path := index . "path" }}
+    {{ $fields := index . "fields" }}
+    {{ $tag := index $fields "tag" }}
+    {{ $tagPageUrl := print "/" $product "/" $version "/" $path "/" | relURL }}
+    {{ $isActive := eq $currentPage.RelPermalink (print "/" $product "/" $version "/" $path "/") }}
+
+    {{/* Get operations */}}
+    {{ $operations := slice }}
+    {{ if isset $fields "operations" }}
+      {{ $operations = index $fields "operations" }}
+    {{ end }}
+
+    {{/* Don't show operations for conceptual/traitTag pages */}}
+    {{ $isConceptual := false }}
+    {{ if isset $fields "isConceptual" }}
+      {{ $isConceptual = index $fields "isConceptual" }}
+    {{ end }}
+    {{ $hasOperations := and (gt (len $operations) 0) (not $isConceptual) }}
+
+    {{/* Check if any operation in this tag is active */}}
+    {{ $tagHasActiveOp := false }}
+    {{ range $operations }}
+      {{ $opPathSlug := .path | replaceRE "^/" "" }}
+      {{ $opUrl := printf "/%s/%s/api/%s/%s/" $product $version $opPathSlug (lower .method) }}
+      {{ if eq $currentPage.RelPermalink $opUrl }}
+        {{ $tagHasActiveOp = true }}
+      {{ end }}
+    {{ end }}
+
+    <li class="nav-item{{ if $isActive }} active{{ end }}">
+      {{ if $hasOperations }}<a href="#" class="children-toggle{{ if or $isActive $tagHasActiveOp }} open{{ end }}"></a>{{ end }}
+      <a href="{{ $tagPageUrl }}">{{ $tag }}</a>
+      {{ if $hasOperations }}
+      <ul class="children{{ if or $isActive $tagHasActiveOp }} open{{ end }}">
+        {{ range $operations }}
+          {{ $apiPath := .path }}
+          {{ $opPathSlug := $apiPath | replaceRE "^/" "" }}
+          {{ $operationUrl := printf "/%s/%s/api/%s/%s/" $product $version $opPathSlug (lower .method) | relURL }}
+          {{ $opIsActive := eq $currentPage.RelPermalink (printf "/%s/%s/api/%s/%s/" $product $version $opPathSlug (lower .method)) }}
+        <li class="nav-item api-operation{{ if $opIsActive }} active{{ end }}">
+          <a href="{{ $operationUrl | safeURL }}">
+            <span class="api-method api-method--{{ lower .method }}">{{ upper .method }}</span>
+            {{- $summary := .summary -}}
+            {{- with .compatVersion -}}
+              {{- $summary = replaceRE `\s*\(v[12]-compatible\)` "" $summary -}}
+            {{- end -}}
+            {{ with $summary }}{{ . }}{{ else }}<code>{{ $apiPath }}</code>{{ end }}
+            {{ with .compatVersion }}<span class="api-compat-badge api-compat-badge--{{ . }}" title="InfluxDB {{ . }}-compatible endpoint">{{ . }}</span>{{ end }}
+          </a>
+        </li>
+        {{ end }}
+      </ul>
+      {{ end }}
+    </li>
+  {{ end }}
+
+  {{/* ALL ENDPOINTS - Collect all operations and sort by method+path */}}
+  {{ $allOperations := slice }}
+  {{ range $operationArticles }}
+    {{ $fields := index . "fields" }}
+    {{ if isset $fields "operations" }}
+      {{ range index $fields "operations" }}
+        {{ $allOperations = $allOperations | append . }}
+      {{ end }}
+    {{ end }}
+  {{ end }}
+
+  {{ if gt (len $allOperations) 0 }}
+    {{/* Sort operations alphabetically by path, then method */}}
+    {{ $sortedOps := slice }}
+    {{ range $allOperations }}
+      {{ $sortKey := printf "%s %s" .path (upper .method) }}
+      {{ $sortedOps = $sortedOps | append (dict "sortKey" $sortKey "op" .) }}
+    {{ end }}
+    {{ $sortedOps = sort $sortedOps "sortKey" }}
+
+    {{/* Check if any operation is active */}}
+    {{ $anyOpActive := false }}
+    {{ range $sortedOps }}
+      {{ $op := .op }}
+      {{ $opPathSlug := $op.path | replaceRE "^/" "" }}
+      {{ $opUrl := printf "/%s/%s/api/%s/%s/" $product $version $opPathSlug (lower $op.method) }}
+      {{ if eq $currentPage.RelPermalink $opUrl }}
+        {{ $anyOpActive = true }}
+      {{ end }}
+    {{ end }}
+
+    <li class="nav-item">
+      <a href="#" class="children-toggle{{ if $anyOpActive }} open{{ end }}"></a>
+      <span class="nav-group-label">All endpoints</span>
+      <ul class="children{{ if $anyOpActive }} open{{ end }}">
+        {{ range $sortedOps }}
+          {{ $op := .op }}
+          {{ $apiPath := $op.path }}
+          {{ $opPathSlug := $apiPath | replaceRE "^/" "" }}
+          {{ $operationUrl := printf "/%s/%s/api/%s/%s/" $product $version $opPathSlug (lower $op.method) | relURL }}
+          {{ $opIsActive := eq $currentPage.RelPermalink (printf "/%s/%s/api/%s/%s/" $product $version $opPathSlug (lower $op.method)) }}
+        <li class="nav-item api-operation api-operation--path{{ if $opIsActive }} active{{ end }}">
+          <a href="{{ $operationUrl | safeURL }}">
+            <span class="api-method api-method--{{ lower $op.method }}">{{ upper $op.method }}</span>
+            <span class="api-path">{{ $apiPath }}</span>
+          </a>
+        </li>
+        {{ end }}
+      </ul>
+    </li>
+  {{ end }}
+{{ end }}
diff --git a/layouts/partials/sidebar/nested-menu.html b/layouts/partials/sidebar/nested-menu.html
index 67cf9a1e00..12dd9eec14 100644
--- a/layouts/partials/sidebar/nested-menu.html
+++ b/layouts/partials/sidebar/nested-menu.html
@@ -1,22 +1,39 @@
 {{ $page := .page }}
 {{ $menu := .menu }}
+{{ $siteData := .siteData }}
 
 {{ define "recursiveMenu" }}
   {{ $menuContext := .menu }}
   {{ $currentPage := .currentPage }}
+  {{ $site := .site }}
+  {{ $siteData := .siteData }}
   {{ $depth := add .depth 1 }}
   {{ $navClass := cond (gt $depth 1) "item" "category" }}
   {{ range $menuContext }}
+    {{/* Check if this is the InfluxDB HTTP API menu item for InfluxDB 3 products */}}
+    {{ $isApiParent := and (eq .Name "InfluxDB HTTP API") (or (hasPrefix .URL "/influxdb3/") (hasPrefix .URL "/influxdb/")) }}
+
     <li class="nav-{{ $navClass }} {{ if eq $currentPage.RelPermalink .URL }}active{{end}}">
-      {{ if .HasChildren }}<a href="#" class="children-toggle {{ if or ($currentPage.IsMenuCurrent .Menu .) ($currentPage.HasMenuCurrent .Menu .) }}open{{end}}"></a>{{ end }}
-      <a href='{{ default .URL .Params.url }}'>{{ .Name }}</a>
-      {{ if .HasChildren }}
-        <ul class="children {{ if or ($currentPage.IsMenuCurrent .Menu .) ($currentPage.HasMenuCurrent .Menu .) }}open{{end}}">
-        {{ template "recursiveMenu" (dict "menu" .Children "currentPage" $currentPage "depth" $depth) }}
+      {{ if $isApiParent }}
+        {{/* API Reference: render custom API nav children instead of standard menu children */}}
+        {{ $hasApiContent := or ($currentPage.IsMenuCurrent .Menu .) ($currentPage.HasMenuCurrent .Menu .) (hasPrefix $currentPage.RelPermalink .URL) }}
+        <a href="#" class="children-toggle {{ if $hasApiContent }}open{{end}}"></a>
+        <a href='{{ default .URL .Params.url }}'>{{ .Name }}</a>
+        <ul class="children {{ if $hasApiContent }}open{{end}}">
+          {{ partial "sidebar/api-menu-items" (dict "page" $currentPage "url" .URL "siteData" $siteData) }}
         </ul>
+      {{ else }}
+        {{/* Standard menu rendering */}}
+        {{ if .HasChildren }}<a href="#" class="children-toggle {{ if or ($currentPage.IsMenuCurrent .Menu .) ($currentPage.HasMenuCurrent .Menu .) }}open{{end}}"></a>{{ end }}
+        <a href='{{ default .URL .Params.url }}'>{{ .Name }}</a>
+        {{ if .HasChildren }}
+          <ul class="children {{ if or ($currentPage.IsMenuCurrent .Menu .) ($currentPage.HasMenuCurrent .Menu .) }}open{{end}}">
+          {{ template "recursiveMenu" (dict "menu" .Children "currentPage" $currentPage "site" $site "siteData" $siteData "depth" $depth) }}
+          </ul>
+        {{ end }}
       {{ end }}
     </li>
   {{ end }}
 {{ end }}
 
-{{ template "recursiveMenu" (dict "menu" .menu "currentPage" .page "depth" 0) }}
+{{ template "recursiveMenu" (dict "menu" .menu "currentPage" .page "site" $page.Site "siteData" $siteData "depth" 0) }}
diff --git a/layouts/shortcodes/api-endpoint.html b/layouts/shortcodes/api-endpoint.html
index 1203a87a4a..bd75b59455 100644
--- a/layouts/shortcodes/api-endpoint.html
+++ b/layouts/shortcodes/api-endpoint.html
@@ -5,9 +5,12 @@
 {{- $parsedProductKey := cond $isOSS "oss" $currentVersion -}}
 {{- $productKey := .Get "influxdb_host" | default $parsedProductKey -}}
 {{- $productAliases := dict "oss" "influxdb" "cloud" "influxdb_cloud" "cloud-tsm" "influxdb_cloud" "core" "influxdb3_core" "enterprise" "influxdb3_enterprise" "cloud-serverless" "influxdb3_cloud_serverless" "serverless" "influxdb3_cloud_serverless" "cloud-dedicated" "influxdb3_cloud_dedicated" "dedicated" "influxdb3_cloud_dedicated" "clustered" "influxdb3_clustered" -}}
-{{- $productRef := index $productAliases $productKey -}}
+{{- $productRef := index $productAliases $productKey | default "influxdb" -}}
 {{- $productData := index .Site.Data.products $productRef -}}
-{{- $placeholderHost := $productData.placeholder_host }}
+{{- $placeholderHost := "" -}}
+{{- with $productData -}}
+  {{- $placeholderHost = .placeholder_host -}}
+{{- end -}}
 {{- $method := .Get "method" | upper -}}
 {{- $methodStyle := .Get "method" | lower -}}
 {{- $apiRef := .Get "api-ref" | default "" -}}
diff --git a/layouts/shortcodes/latest-patch.html b/layouts/shortcodes/latest-patch.html
index df03397a7b..484d606ca3 100644
--- a/layouts/shortcodes/latest-patch.html
+++ b/layouts/shortcodes/latest-patch.html
@@ -10,19 +10,20 @@
 {{- $patchVersions := index (index .Site.Data.products $product) "latest_patches" -}}
 {{- $cliVersions := index .Site.Data.products.influxdb "latest_cli" -}}
 {{- $isInfluxDB3 := eq $product "influxdb3" -}}
+{{- $patchVersion := "" -}}
 {{- if $cli }}
   {{- if eq $version "cloud" -}}
-    {{- .Store.Set "patchVersion" (index $cliVersions $latestVersion) -}}
+    {{- $patchVersion = index $cliVersions $latestVersion -}}
   {{- else -}}
-    {{- .Store.Set "patchVersion" (index $cliVersions $version) -}}
+    {{- $patchVersion = index $cliVersions $version -}}
   {{- end -}}
 {{- else -}}
   {{- if eq $version "cloud" -}}
-    {{- .Store.Set "patchVersion" (index $patchVersions $latestVersion) -}}
+    {{- $patchVersion = index $patchVersions $latestVersion -}}
   {{- else if $isInfluxDB3 -}}
-    {{- .Store.Set "patchVersion" (index .Site.Data.products (print $product "_" $version)).latest_patch -}}
+    {{- $patchVersion = (index .Site.Data.products (print $product "_" $version)).latest_patch -}}
   {{- else -}}
-    {{- .Store.Set "patchVersion" (index $patchVersions $version) -}}
+    {{- $patchVersion = index $patchVersions $version -}}
   {{- end -}}
 {{- end -}}
-{{- .Store.Get "patchVersion" -}}
\ No newline at end of file
+{{- $patchVersion -}}
\ No newline at end of file
diff --git a/package.json b/package.json
index 22dc9e6864..a34022b030 100644
--- a/package.json
+++ b/package.json
@@ -36,7 +36,7 @@
     "remark-frontmatter": "^5.0.0",
     "remark-gfm": "^4.0.1",
     "remark-parse": "^11.0.0",
-    "typescript": "^5.8.3",
+    "typescript": "^5.9.3",
     "typescript-eslint": "^8.32.1",
     "unified": "^11.0.5",
     "winston": "^3.16.0"
@@ -58,11 +58,13 @@
     "vanillajs-datepicker": "^1.3.4"
   },
   "scripts": {
+    "build": "yarn build:api-docs && npx hugo --quiet && yarn build:md",
     "postinstall": "node scripts/setup-local-bin.js",
     "docs:create": "node scripts/docs-create.js",
     "docs:edit": "node scripts/docs-edit.js",
     "docs:add-placeholders": "node scripts/add-placeholders.js",
-    "build:api-docs": "cd api-docs && sh generate-api-docs.sh",
+    "build:api-docs": "node api-docs/scripts/dist/generate-openapi-articles.js",
+    "build:api-docs:compile": "tsc --project api-docs/scripts/tsconfig.json",
     "build:pytest:image": "docker build -t influxdata/docs-pytest:latest -f Dockerfile.pytest .",
     "build:agent:instructions": "node ./helper-scripts/build-agent-instructions.js",
     "build:ts": "tsc --project tsconfig.json --outDir dist",
diff --git a/static/css/rapidoc-custom.css b/static/css/rapidoc-custom.css
new file mode 100644
index 0000000000..f1d9979f6a
--- /dev/null
+++ b/static/css/rapidoc-custom.css
@@ -0,0 +1,18 @@
+/* Custom RapiDoc overrides */
+
+/* Reduce parameter table indentation - target the expand column */
+.m-table tr > td:first-child {
+  width: 0 !important;
+  min-width: 0 !important;
+  padding: 0 !important;
+}
+
+/* Reduce param-name cell indentation */
+.param-name {
+  text-align: left !important;
+}
+
+/* Make auth section scrollable on narrow viewports */
+.security-info-button {
+  flex-wrap: wrap;
+}
diff --git a/yarn.lock b/yarn.lock
index 9761223ff4..ae7323bb1a 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -6033,7 +6033,7 @@ typescript-eslint@^8.32.1:
     "@typescript-eslint/typescript-estree" "8.47.0"
     "@typescript-eslint/utils" "8.47.0"
 
-typescript@^5.8.3:
+typescript@^5.9.3:
   version "5.9.3"
   resolved "https://registry.yarnpkg.com/typescript/-/typescript-5.9.3.tgz#5b4f59e15310ab17a216f5d6cf53ee476ede670f"
   integrity sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==