Get started with Theneo and publish your first API docs in minutes.

Creating intuitive, detailed, and easy-to-navigate API documentation has never been easier. Theneo streamlines every step of the process, ensuring that your documentation is not only comprehensive but also interactive and user-friendly. Here's how you can quickly set up your project in Theneo.

Getting Started

To create and publish documentation in Theneo, you first need to create a Theneo account. If you don’t have an account yet, you can sign up for free here.

Create Your First Doc

When you log into Theneo, start by adding a new project from the homepage. Your project could be an API reference, a developer guide, or any type of documentation you need. Give your project a title, select the appropriate workspace, and you're on your way.

Uploading Your API Specification

Theneo accommodates a wide array of API specifications, making it easy to get started regardless of whether you have an existing spec or not. If you're equipped with Swagger, OpenAPI, GraphQL, or another format, the upload process is designed to be straightforward and efficient.

In case you don't have a spec ready, Theneo offers tools to help you create one from scratch. Use our intuitive interface to define your API endpoints directly within the platform. For additional guidance on creating or importing your spec and ensuring format compatibility, check out our guide.

If you do not have a spec, do not worry you can define that in Theneo as well, for more info click here.

Selecting Your AI Co-Pilot

Once your API specification is uploaded, you can harness the power of Theneo's AI Co-pilot to enrich your content. Decide whether you want the AI to fully generate the content, enhance what you've already created, or if you prefer to proceed without AI assistance. If you're looking to streamline the setup, simply click on "Quick Start" to bypass the customization and move directly to publishing.

Setting Permissions and Fine-Tuning Your Project

Set your project’s visibility and invite collaborators according to your workflow needs. With Theneo, you can start with a private project and go public when you're ready, seamlessly inviting others to contribute. Manage these settings at any time to fit your project’s development lifecycle.

You can change project level permission and even set up advanced access management later in the project settings.

Publish

Utilize Theneo's editing suite for final adjustments before publishing. Preview to ensure everything is perfect and publish to make your documentation available to users. It’s documentation made simple, yet powerful and comprehensive

Optional steps

Edit the project

Easily update and refine your project content in real-time.

Preview changes

See how your project will look before going live.

Automate the flow

Streamline your workflow with powerful automation tools.

AI search

Find answers instantly with intelligent AI-powered search.

Theneo provides a robust and versatile solution for managing your API documentation. Whether you're starting from scratch or updating existing documentation, our platform supports a wide range of API formats and import methods to streamline your workflow.

Supported API Formats & Collections

Theneo supports the following API formats and specification types:

• REST
• SOAP
• GraphQL
• Async APIs

We also support various API specification collections, ensuring smooth migration and integration with your existing tooling.

Importing Your API Documentation

1. Getting Started with Importing

If you do not have existing documentation in Theneo, you can begin by importing your API spec:

• From the Theneo Dashboard
• Using Theneo CLI (for local environment or automation)

You can easily migrate and unify your API documentation into Theneo using either method.

2. Updating Existing Projects in the Editor

If you already have a project in Theneo and want to update the API spec, you can do this directly from the Theneo Editor:

Steps:

1. Open the Editor and navigate to the Endpoints tab (above the left-side menu).
2. Click "Import Collection".
3. Choose your preferred import method.

Import Options Explained:

You can upload your spec via:

• File
• Link
• Postman Collection
• Raw Text

Once confirmed, the changes will be reflected directly in the Editor.

Automating Imports: CLI & GitHub Actions

For developers preferring automation and CI/CD workflows, Theneo supports imports via:

A. GitHub Actions Integration

Automate documentation updates with GitHub:

Setup:

1. Create a workflow file named Theneo.yml in your repository under .github/workflows/.

Example: Theneo.yml

 
name: Update Documentation
on:
  pull_request:
    branches:
      - main
jobs:
  update-doc:
    name: Update Theneo Documentation
    runs-on: ubuntu-latest
    steps:
      - run: echo "🎉 The job was automatically triggered by a ${{ github.event_name }} event."
      - name: Checkout
        uses: actions/checkout@v4
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: "18"
      - name: Update Documentation on Theneo
        uses: Theneo-Inc/api-documentation@1.8.0
        with:
          FILE_PATH: doc/api.yml

          PROJECT_SLUG: <project_slug>
          VERSION_SLUG: <version_slug>
          WORKSPACE_SLUG: <workspace_slug>

          SECRET: ${{secrets.SECRET}}

          AUTO_PUBLISH: true

          IMPORT_OPTION: merge
          PARAMETER_DESCRIPTION_MERGE_STRATEGY: keep_new
          SECTION_DESCRIPTION_MERGE_STRATEGY: keep_old

          INCLUDE_GITHUB_METADATA: true

B. Theneo CLI Integration

Use Theneo CLI for advanced import control.

Basic Command

theneo project import [options]

Options:

Example Command

 
Usage: theneo project import [options]

Import updated documentation into Theneo using file, link or postman collection

Note: Published document link has this pattern: https://app.theneo.io/<workspace-slug>/<project-slug>/<version-slug>

Options:
  --project <project-slug>                   Specify the project slug to import updated documentation in
  -f, --file <file>                          API file path to import (eg: docs/openapi.yml)
  --link <link>                              API file URL to create project using it
  --postman-api-key <postman-api-key>        Postman API Key (env: THENEO_POSTMAN_API_KEY)
  --postman-collection <postman-collection>  Postman collection id, you can use multiple times
  --import-type <import-type>                Indicates how should the new api spec be imported (choices: "endpoints", "overwrite", "append", "merge")
  --publish                                  Automatically publish the project (default: false)
  --workspace <workspace-slug>               Workspace slug, where the project is located
  --projectVersion <version-slug>            Project version slug to import to, if not provided then default version will be used
  --keepOldParameterDescription              Additional flag during merging import option, it will keep old parameter descriptions
  --keepOldSectionDescription                Additional flag during merging import option, it will keep old section descriptions
  --profile <string>                         Use a specific profile from your config file.
  -h, --help                                 display help for command

Theneo offers flexible import options for all types of users—from product managers updating documentation manually to developers automating the process with GitHub or CLI. Whether you're starting from scratch or maintaining existing documentation, Theneo makes it easy to import, manage, and publish your API specs with confidence.

Theneo isn't just for API documentation—it also empowers teams to create non-API documents, such as technical guides, onboarding docs, tutorials, help centers, product manuals, and more.

Getting Started from the Theneo Dashboard

1. Login to Theneo Dashboard Go to Theneo Dashboard and sign in with your workspace credentials.
2. Create a New Project Click on "Create Project" from the dashboard.
3. Select “Other Docs” On the project creation page, choose the "Other Docs" option instead of an API format.
4. Pick Your Sections You’ll be prompted to choose section templates like:

• Introduction/Overview
• Prerequisites & Installation
• Sample Code & Tutorials
• Supported Libraries
• Usage & Integration
• Troubleshooting & Support

Editing Your Docs in Theneo

Once the project is created, you have two ways to start working on your documentation:

A. Use the Theneo Editor

Enjoy a Notion- and Figma-like editing experience with:

• Rich text formatting
• Drag & drop content blocks
• Real-time editing and live preview
• Easy collaboration with teammates

Everything you need to build modern documentation without writing a single line of code.

B. Import Markdown Using Theneo CLI

Prefer to write in Markdown and keep content locally? You can import Markdown files into Theneo using the CLI.

CLI Usage

theneo import [options]

Options

Example

 
Usage: theneo import [options]

Update theneo project from generated markdown directory

Options:
  --project <project-slug>         project slug
  --workspace <workspace-slug>     Enter workspace slug where the project should be created in, if not present uses default workspace
  --dir <directory>                Generated theneo project directory
  --publish                        Automatically publish the project (default: false)
  --projectVersion <version-slug>  Version slug
  --profile <string>               Use a specific profile from your config file.
  -h, --help                       display help for command

Recommended Layout: Single Page Template

For guides and other non-API docs, such as:

• Tutorials
• Onboarding walkthroughs
• Step-by-step how-tos

We highly recommend using the Single Page Template.

Why Choose the Single Page Template?

In Theneo, you can fully customize the appearance of your docs to align with your company’s branding—no coding required.

To make styling easy and consistent, Theneo provides a set of predefined themes you can apply instantly. These themes control elements like:

• Fonts & typography
• Colors (text, background, buttons)
• Header and sidebar styles
• Accent colors and UI highlights

Branding Customization Options

You can further tailor your documentation by adjusting:

• Primary & secondary colors
• Logo & favicon
• Font styles
• Code block styling
• Custom CSS/JS (Advanced)

Choosing a Documentation Template

Theneo supports two layout templates for structuring your documentation: Single Page Template and Continuous Scrolling. You can choose the one that best fits your content and user experience goals.

Single Page Template (Recommended for Guides & Tutorials)

This layout breaks your documentation into modular sections.

Best for:

• Step-by-step guides
• Tutorials
• Onboarding walkthroughs
• Help center-style docs

Benefits:

• Cleaner navigation
• Improved performance (loads one section at a time)
• Unique URLs for deep linking
• Better readability and user focus

Footer Configuration

To customize the footer in the Single Page Template, follow these steps:

1. Navigate to Branding Settings from your Theneo dashboard.
2. Go to the General Settings tab.
3. Open the Footer Links section.
4. Add, edit, or remove footer content — including:

• Social links
• Corporate URLs
• Custom web links relevant to your documentation

This allows you to align your doc’s footer with your brand and link out to key resources for your users.

Continuous Scrolling Template

This is the traditional doc style where all content flows on one long page.

Best for:

• Reference documentation
• Technical specs
• API overviews and lists

Benefits:

• Seamless vertical reading
• Great for quick searching via browser
• Simpler document flow for smaller projects

Switching Templates

You can change the template at any time in your Project Settings:

1. Go to Project Settings > Features
2. Turn the Single Page Template toggle on or off

There are a variety of themes and templates to choose from — giving you full control over how your docs look and feel.

Solid

Roboto

Bloom

Single Page Template

Continues Scrolling

Migrating to Theneo is fast, simple, and fully supported.

Whether you're coming from platforms like Swagger, Postman, ReadMe, Docusaurus, or any other API/documentation tool — Theneo makes it easy to bring your content over and elevate it with our powerful features.

Easy Migration Process From

Swagger

Postman

Readme

Docusaurus

You can migrate:

• API specs (OpenAPI, Swagger, Postman Collections, etc.)
• Markdown content (guides, tutorials, onboarding flows)
• Full documentation projects from other platforms

Migration Assistance & Best Practices

As part of our Annual Growth Package, the Theneo team offers:

• End-to-end migration assistance
• Personalized suggestions to improve your docs using Theneo’s smart tools
• Optimization support for readability, structure, and performance

Need Help Migrating?

For custom migration cases or platform-specific needs, contact us at hello@theneo.io — we’ll evaluate your current setup and provide tailored migration assistance.

Theneo provides robust markdown support both within the editor and through CLI-based markdown imports, enabling flexible documentation creation and management workflows.

In-Editor Markdown Support

Standard Markdown Formatting

Theneo's editor supports all standard markdown formatting including:

• Headers (H1-H6)
• Bold and italic text
• Inline code and code blocks with syntax highlighting
• Lists (ordered and unordered)
• Links and images
• Tables
• Blockquotes
• Horizontal rules

Theneo Custom Widgets

Beyond standard markdown, Theneo provides custom widgets that enhance API documentation with interactive elements. These widgets enable rich content presentation directly within your markdown files.

Code Blocks with Enhanced Features

 
<CodeBlock attributes='{"isFitToPage":true,"style":{},"lang":"bash","label":"Bash"}'>
  <CodeLine>npm install -g @theneo/cli@latest</CodeLine>
</CodeBlock>

Interactive Accordions

 
<Accordion attributes='{"style":{"width":"100%"}}'>
<AccordionItem title="Authentication" iconUrl="">
  <p>Your authentication content here</p>
</AccordionItem>
</Accordion>

Callout Blocks

 
<Callout attributes='{"isFitToPage":true,"dataType":"info","style":{"width":"100%"}}'>
  Important information for your users
</Callout>

These widgets can be combined with standard markdown to create comprehensive, interactive API documentation that enhances developer experience.

Importing Markdown Folders

Theneo CLI provides powerful capabilities for managing documentation through markdown files, enabling version control and collaborative workflows.

Installation

 
npm install -g @theneo/cli@latest

Project Structure Requirements

To import markdown folders into Theneo, your project must follow a specific structure:

your-documentation/
├── theneo.json
├── introduction/
│   ├── index.md
│   └── section.json
├── getting-started/
│   ├── index.md
│   └── section.json
├── api-reference/
│   ├── index.md
│   ├── section.json
│   └── endpoints/
│       ├── create-customer/
│       │   ├── index.md
│       │   └── section.json
│       └── get-customer/
│           ├── index.md
│           └── section.json 

Configuration Files

theneo.json - Project Structure Definition

The theneo.json file defines the overall structure and hierarchy of your documentation:

 
{
  "name": "Your API Documentation",
  "baseUrl": "https://api.yourdomain.com",
  "sections": [
    {
      "name": "Introduction",
      "slug": "introduction",
      "icon": "6",
      "isHeader": false
    },
    {
      "name": "Getting Started",
      "slug": "getting-started",
      "isHeader": true,
      "children": [
        {
          "name": "Authentication",
          "slug": "getting-started/authentication",
          "icon": "5"
        }
      ]
    },
    {
      "name": "API Reference",
      "slug": "api-reference",
      "isHeader": true,
      "children": [
        {
          "name": "Customer Management",
          "slug": "api-reference/customer-management",
          "children": [
            {
              "name": "Create Customer",
              "slug": "api-reference/customer-management/create-customer"
            }
          ]
        }
      ]
    }
  ]
}

section.json - API Endpoint Definition

For sections containing API endpoints, the section.json file defines request and response specifications:

 
{
  "endpoints": {
    "method": "POST",
    "path": "/customers"
  },
  "request": {
    "contentType": "application/json",
    "body": [
      {
        "name": "given_name",
        "description": "The first name of the customer",
        "isRequired": true,
        "valueType": "string",
        "value": "John"
      },
      {
        "name": "email_address",
        "description": "The email address of the customer",
        "isRequired": true,
        "valueType": "string",
        "value": "john@example.com"
      }
    ],
    "header": [
      {
        "name": "Authorization",
        "description": "Bearer token for authentication",
        "isRequired": true,
        "valueType": "string",
        "value": "Bearer <access_token>"
      }
    ]
  },
  "responses": [
    {
      "statusCode": 200,
      "description": "Successful response",
      "contentType": "application/json",
      "body": [
        {
          "name": "customer",
          "description": "The created customer object",
          "valueType": "object"
        }
      ]
    }
  ]
}

For sections without API endpoints (like introductory content), section.json can be an empty object {}.

CLI Commands for Markdown Management

Creating a New Project from Markdown

 
theneo create --dir ./your-documentation --name "API Documentation" --workspace your-workspace

Importing/Updating Existing Project

 
theneo import --dir ./your-documentation --project your-project-slug --workspace your-workspace

Exporting Project as Markdown

 
theneo export --project your-project-slug --dir ./exported-docs

Best Practices

1. Version Control: Keep your markdown documentation in Git for version tracking and collaboration
2. Consistent Structure: Maintain the required folder structure for seamless imports
3. Modular Organization: Organize endpoints logically within nested folders
4. Descriptive Names: Use clear, kebab-case slugs for sections and endpoints
5. Complete Metadata: Ensure all section.json files contain complete API specifications
6. Regular Sync: Use CI/CD pipelines to automatically sync documentation updates

Example Workflow

1. mkdir api-docs && cd api-docstouch theneo.json
2. mkdir -p api-reference/customersecho "# Customer Management API" > api-reference/customers/index.mdecho '{}' > api-reference/customers/section.json
3. theneo login --token your-api-keytheneo create --dir . --name "My API Docs" --publish
4. # Make changes to your markdown filestheneo import --dir . --project your-project-slug --publish

Advanced Features

AI-Powered Description Generation

When importing documentation, leverage AI to automatically generate or enhance descriptions:

 
theneo project create --file ./openapi.json --generate-description fill

Options:

• fill: Add descriptions where missing
• overwrite: Replace all existing descriptions
• no_generation: Skip AI generation (default)

Multi-Environment Support - Only for Enterprise accounts

Use profiles for different environments:

 
theneo login --profile production --token prod-api-key
theneo import --dir . --project api-docs --profile production

Working with Complex API Structures

For complex APIs with nested resources, organize your folder structure to mirror your API architecture:

api-reference/
├── customers/
│   ├── index.md
│   ├── section.json
│   ├── create/
│   │   ├── index.md
│   │   └── section.json
│   ├── retrieve/
│   │   ├── index.md
│   │   └── section.json
│   └── orders/
│       ├── index.md
│       ├── section.json
│       └── list/
│           ├── index.md
│           └── section.json 

This structure translates to:

• /customers - Create Customer
• /customers/{id} - Retrieve Customer
• /customers/{id}/orders - List Customer Orders

Troubleshooting

Common Issues and Solutions

1. Import fails with structure error:
   1. Verify theneo.json exists in root directory
   2. Ensure all section slugs match folder names exactly
   3. Check that each section folder contains index.md and section.json
2. API endpoints not appearing:
   1. Confirm section.json contains valid endpoint configuration
   2. Validate JSON syntax in all configuration files
   3. Ensure method and path are correctly specified
3. Markdown rendering issues:
   1. Use proper escaping for special characters
   2. Verify custom widget syntax matches documentation
   3. Test widgets individually before combining
4. Authentication errors:
   1. Confirm API key is valid: theneo login --token your-api-key
   2. Check workspace permissions
   3. Verify profile configuration if using multiple environments

Migration Guide

From Static Markdown to Theneo

If you have existing markdown documentation, follow these steps to migrate:

1. Analyze current structure: Map your existing documentation to Theneo's section hierarchy
2. Create theneo.json: Define your documentation structure
3. Reorganize files: Move markdown files into the required folder structure
4. Add section.json files: Define API endpoints where applicable
5. Test import locally: Use theneo create --dir . --name "Test Import"
6. Iterate and refine: Adjust structure based on import results

From Other Documentation Platforms

When migrating from platforms like Swagger UI, Redoc, or Postman:

1. Export OpenAPI/Swagger spec if available
2. Use Theneo's import feature: theneo project create --file openapi.json
3. Export as markdown: theneo export --project your-project --dir ./markdown
4. Customize markdown files with additional content
5. Re-import with enhancements: theneo import --dir ./markdown --project your-project

Integration with CI/CD

GitHub Actions Example

 
name: Deploy Documentation
on:
  push:
    branches: [main]
    paths:
      - 'docs/**'
jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      
      - name: Setup Node.js
        uses: actions/setup-node@v2
        with:
          node-version: '16'
      
      - name: Install Theneo CLI
        run: npm install -g @theneo/cli@latest
      
      - name: Deploy to Theneo
        env:
          THENEO_API_KEY: ${{ secrets.THENEO_API_KEY }}
        run: |
          theneo import \
            --dir ./docs \
            --project ${{ vars.THENEO_PROJECT }} \
            --workspace ${{ vars.THENEO_WORKSPACE }} \
            --publish

GitLab CI Example

 
deploy-docs:
  stage: deploy
  image: node:16
  script:
    - npm install -g @theneo/cli@latest
    - theneo login --token $THENEO_API_KEY
    - theneo import --dir ./docs --project $THENEO_PROJECT --publish
  only:
    - main
  when: manual

Conclusion

Theneo's markdown support provides a flexible, developer-friendly approach to API documentation. Whether you prefer working directly in the editor with custom widgets or managing documentation as code through the CLI, Theneo adapts to your workflow while maintaining professional, interactive documentation.

For more information and updates, visit:

• Theneo CLI GitHub Repository
• NPM Package

Theneo provides a robust and versatile range of API formats and collection types to cater to a wide array of integration and development needs. Our platform supports various API formats, including REST, SOAP, GraphQL, and Async APIs, each tailored to different use cases and requirements. Additionally, we offer compatibility with multiple API specification collections, ensuring seamless integration and a streamlined development process. Below is an overview of the supported formats and collections.

REST API

REST (Representational State Transfer) APIs are widely used due to their simplicity and statelessness.

SOAP API

SOAP (Simple Object Access Protocol) APIs are a protocol standard for web services that enable the exchange of structured information.

GraphQL

GraphQL is a powerful data query and manipulation language for APIs, and a runtime for fulfilling queries with existing data.

Postman Collection

Theneo offers seamless integration with Postman, making it possible to import your Postman collections into Theneo.

Custom SDK

The Custom SDK Import feature in Theneo allows users to integrate their own SDKs for use within the platform.

Theneo Custom Metadata

Theneo allows you to import extra configurations from OpenAPI using the `x-theneo-metadata` attribute.

Theneo’s API Explorer is an interactive tool that significantly simplifies the API testing process. It allows users to engage with their APIs in real-time, providing an immersive experience that bridges the gap between technical understanding and practical application. Whether you're a developer or a non-technical user, the API Explorer is designed to offer a seamless and intuitive way to explore and validate API functionality.

Key Features of API Explorer

Real-Time Testing

• Try in API Explorer Button: Every API request in our documentation includes a “Try in API Explorer” button, allowing instant, live interaction with your APIs.

Environment Selection

• Sandbox and Production Toggle: Test your APIs in a safe sandbox environment or in a live production setting with a simple switch.

User-Friendly Interface

• Form and Code View: Choose your comfort zone—use the Form View for a guided input experience or the Code View to enter your custom code snippets.

Seamless Navigation

• Effortless Section Switching: Navigate between different API sections directly in the Explorer without needing to refer back to the documentation.

Informative Fields

• Field Descriptions: Understand each parameter with clear descriptions and details provided within the Explorer.

Advantages of Using API Explorer

No Setup Required

• Automatic Synchronization: Changes made in the editor or updates from your API spec are automatically reflected in the API Explorer, eliminating the need for manual setup.

Accessible to All User Levels

• Designed for Everyone: The API Explorer is crafted to be accessible to users of all skill levels, breaking down barriers to API testing.

Enhanced Learning and Debugging

• Interactive Learning: By experimenting with live API calls, users can learn more effectively and pinpoint issues on the fly.

API versioning in Theneo is designed to be both intuitive and comprehensive, accommodating the natural evolution of your APIs. With Theneo, you can manage and track incremental changes within the same version using the API changelog, as well as create and oversee major version transitions such as moving from v1 to v2 or v3.

Theneo now offers a feature for comprehensive API version management. This feature enables users to meticulously handle different versions of their API, such as v2, v3, and beyond, each with unique statuses and configurations.

Key Features of API Versioning

• Multiple Versions: Create and manage multiple versions of your API, whether it’s incremental updates or major releases.
• Status Labels: Assign statuses like active, beta, or deprecated to each version, along with any custom attributes you may need.
• Project Configuration: Tailor each API version’s project settings, including access management, SEO settings, and analytics.
• Version-Level Changelogs: Track changes within specific versions, enabling clear communication of updates from 1.1.2 to 1.1.3, etc.

Utilizing the Versioning Feature

1. Add New Versions: Easily add a new version through your project dashboard by importing a new API spec or using an existing one as a base.
2. Import Specs: Use the intuitive interface to upload file, link, import from Postman, or input raw text for your API specs.
3. Manage Versions: Navigate to the settings menu to manage features, access permissions, SEO optimization, and analytics for each API version.
4. Set Version Status: Define the lifecycle stage of each API version with appropriate status labels directly from the project versions screen.

Managing API Versions in Theneo

Theneo allows you to create and manage multiple API versions seamlessly. Follow the steps below to create new versions, set defaults, and control visibility for better version management.

Creating a New API Version

1. Access the API Versioning Tab
   1. Navigate to the Project Dashboard and open the API Versioning tab.
2. Manage Versions
   1. Click on the Manage Versions button to open the version management modal.
3. Add a New Version
   1. Enter a name for the new version.
   2. Choose how you want to create the version:
      1. Import an updated OpenAPI specification to reflect the latest API changes.
      2. Use an existing version as a starting point and make modifications directly in the editor.
4. Save and Apply Changes
   1. Once the version is created, you can modify its content, update configurations, and ensure it aligns with your API changes.

Managing Version Tags and Default Versions

• After creating multiple API versions, you can organize them using version tags.
• You can also select a default version from the list. The default version will be the one automatically loaded when users access the documentation, ensuring they always see the most relevant version.

Hiding API Versions from Published Documentation

If you want to hide a specific API version from the published documentation:

1. Open the three-dot menu next to the version you want to hide.
2. Click the Hide option.
3. The version will be removed from the public-facing documentation but will remain accessible from the Theneo Dashboard for internal use. You can still view and edit hidden versions, but external users will not be able to see them.

Managing API Versions with CLI Automation

If you prefer to automate the creation and management of API versions, you can use the Theneo CLI. This approach is ideal for integrating version control into your CI/CD workflows or for teams that manage large-scale API updates programmatically.

For detailed instructions on how to create and manage API versions using the CLI, visit our CLI Guide.

Theneo’s Changelog is an essential tool for developers and stakeholders to track changes and updates to your API specifications. This powerful feature not only documents all modifications automatically but also provides an option for users to subscribe and receive email notifications for each update.

Automated Changelog Documentation

When a new API specification is imported and the "Publish" button is clicked, Theneo automatically detects and summarizes all changes, including:

• Breaking changes in the API
• Newly added endpoints
• Updates to existing sections
• Modified descriptions
• Removed sections or endpoints

These updates are meticulously logged on a dedicated changelog page, providing a detailed version history with timestamps.

Changelog Release Notes

Theneo allows users to include concise release notes or summaries for updates made to their API documentation. These notes help highlight changes clearly for both internal teams and external users, and are automatically displayed on the dashboard and the public changelog page.

Feature Purpose

The Changelog Release Note feature provides a quick and efficient way to communicate important updates. Whether written manually or generated by AI, these notes help keep everyone informed of what’s new, changed, or removed in each API release.

Configuration Details

Release notes can be added from the Public Changelog section on your dashboard.

How to Add a Release Note

1. Navigate to the Public Changelog section on your dashboard.
2. Click the “Add Release Note” button.
3. A new input field will appear where you can either:

• Manually enter a brief summary of the changes
• Or click “Ask AI” to automatically create a professional summary

AI Summary for Release Notes

In addition to manual input, Theneo offers AI-generated summaries. With a single click, our AI detects all changes in the newly published API specification and provides a professionally written release note.

• Acts as a technical writer, summarizing key changes
• Highlights new endpoints, updated descriptions, removed sections, and breaking changes
• Saves time and ensures consistency in release communications

Saving Release Notes

After writing or generating your release note:

1. Click Save to associate the note with the current API update
2. The note will be automatically displayed:

• On the dashboard, within the changelog section
• On the public changelog page

Deleting a Release Note

1. Hover over an existing release note
2. Click the trash icon that appears
3. The note will be permanently removed from both views

Real-Time Email Notifications

How to Subscribe

1. Enter Your Email: On the Changelog page, there’s a field to enter your email.
2. Hit Subscribe: Click the “Subscribe” button to start receiving updates on the documentation changes.

Benefits of Subscription

• Immediate Awareness: Get notified as soon as changes are published, allowing for prompt action or adaptation in your workflow.
• Convenient Overviews: Email notifications provide a summary of the changes, making it easier to stay informed without needing to check the changelog manually.
• Version Tracking: Keep a close eye on version progression and ensure that all team members and API consumers are aligned with the latest API developments.

FAQ

Theneo's web editor is a rich and intuitive platform, equipped with a variety of widgets that enrich the documentation experience. These widgets add depth and clarity to your API documentation, making it more engaging and informative. You can easily access these widgets by simply going to a new line in the editor and typing /, which brings up the widget options. Let's take a look at the widgets available:

Card

Card groups

Steps

Accordion

Divider

Callout

Table

Image & Video

Code Blocks

Object Example

Error Codes

Status Codes

Base URL

Language Box

Reuse Content

Iframe

API Management

FAQ

The API Management widget allows users to efficiently define, configure, and manage API endpoints within their projects. It offers a structured way to input and manage essential information for request and response parameters, ensuring comprehensive API setup.

How to Add and Configure the API Management Widget

1

Insert the widget

Insert the Widget: To insert the API Management Widget, navigate to the desired section in your documentation. Type / to bring up the widget menu and select API Management.

2

Confgiure API

Configure the HTTP Method: Click on the method dropdown in the widget’s header to select an HTTP method (e.g., POST, PUT, PATCH, DELETE). Define the Endpoint Path: Enter the endpoint path next to the HTTP method, which will be appended to the base URL. Press the Save Changes button or hit Enter to save.

Detail Request Specifications:

• Headers: Add headers such as content type or authorization tokens.
• Parameters: Input query parameters or path variables required by the endpoint.
• Body: For methods like POST or PUT, specify the request body structure.

Form and Code Views: Switch between:

• Form View: A user-friendly interface for entering request details.
• Code View: For scripting or pasting raw data.

Configuring the Response

1. Add the Response Widget: Navigate to the Response tab within the API Management widget. Click the "Add Response" button, which will trigger the response widget to appear.
2. Add Response Codes: By default, a 200 OK response is included. Add other response codes by clicking the + icon.
3. Detail the Response:
   1. Form View: Add descriptions and structure the returned data.
   2. Code View: Paste in JSON or other formatted responses, and the widget will parse them for easy reading.
4. Multiple Responses: Document responses for various status codes (e.g., 200 OK, 400 Bad Request, 500 Internal Server Error) to cover different API outcomes.

Additional Configuration Options

• Parameter Properties: Click the icon in the right corner of each parameter to trigger a modal for adding extra properties.
• Required Parameters: Mark parameters as required using a asterisk icon.
• Parameter Actions: Use the three-dot menu to delete or duplicate parameters.
• Ask AI: Use AI to suggest descriptions for each parameter by clicking the "Ask AI" button in the description field.
• Code Beautify: Use the beautify button to format code in code view.
• Full Screen Mode: Use the full-screen option in the header to manage endpoints more easily.
• More Actions Menu: The three-dot menu includes options to delete the entire API management section or hide descriptions for request and response parameters in the published view.

Video Guide on how API Management widget works

We know, great collaboration leads to great results, and the Live Collaboration feature in our editor ensures that your team can work together in real-time to achieve just that. Whether you're working on documentation or complex projects, this feature allows multiple users to make updates simultaneously, ensuring everyone is on the same page and contributing effectively. With real-time visibility into who’s editing what, collaboration becomes smooth, organized, and more productive.

Key Features of Live Collaboration

1. See Who’s Currently Editing a Section: At any point during the editing process, users can see which collaborators are actively editing a particular section. This visibility helps avoid confusion or duplication of work and ensures smooth collaboration among team members.
2. View Where Others Are Editing: Within a section, users can see exactly where their collaborators are making changes in real-time. The editor highlights the text being edited by another user, giving you immediate feedback on what is being updated.
3. Cursor Visibility: For greater clarity, the cursor of the collaborator is visible within the section description. This allows users to pinpoint the exact location where edits are happening, ensuring that changes are made in the correct area.
4. See Who’s Editing Which Section in the Menu:The menu provides an overview of who is editing which section. Each section that is being actively worked on by a user is marked with their name, making it easy to track where collaborators are focused. This feature enhances coordination, especially in larger documents with multiple sections.

How to Use Live Collaboration

• Start Editing Together: Once users are invited to collaborate on a project or document, they can begin editing simultaneously. As soon as one user starts editing a section, others will see their presence and activity in real-time.
• Communicate with Collaborators: Although the collaboration feature does not include a built-in chat, the real-time presence indicators allow for smooth coordination. Teams can also supplement this feature with external communication tools to enhance collaboration further.
• Conflict Avoidance: Since all users can see who is editing a section, this minimizes the risk of conflicting edits. It helps maintain organized teamwork and ensures that changes are consolidated without accidental overwrites.

In Theneo, users can switch to Preview Mode at any time while editing to review the latest changes before publishing. This feature offers several key benefits:

• Accurate Rendering: Preview Mode allows you to see exactly how your content will appear in the final published documentation. This helps ensure that all formatting, layout, and design elements are rendering as intended.
• Section-Specific Previews: You can preview changes for individual sections, ensuring that every detail is correct before publishing. This is especially useful when working on larger documents with multiple sections.

How to Use Preview Mode

1. Locate the Switcher Button: In the editor’s header, you’ll find the Editor/Preview switcher button. This is your key to moving between edit mode and preview mode effortlessly.
2. Switch to Preview Mode: When you're ready to preview your content, click on the switcher to enter Preview Mode. This will display the most recent version of your documentation as it will appear to end users.
3. Preview Specific Sections: You can preview any section of your document to see how changes to that section look.

If the preview meets your expectations, you can move forward by selecting the Publish option. Once confirmed, your documentation will go live with all the updates and enhancements you've applied.

Once you’ve finished editing your documentation and are ready to publish, you can do so from the Editor, Dashboard, or via CLI automation. After publishing, your documentation will be accessible to the selected audience.

Private Publishing

By default, project access settings are set to private, meaning that after publishing, the documentation will not be accessible to external users.

• You can invite users as editors or viewers through Project Access Management settings.
• Alternatively, set up password-based access for your documentation under a custom domain.
• For more details on managing access, visit here.

Public Publishing

If you want your documentation to be accessible to a public audience, you can:

1. Publish the documentation.
2. Change the access settings from private to public under Project Access Management.

Publishing Without Search Engine Indexing

By default, your documentation is indexed by search engines. However, you can choose to disable indexing so that while your docs remain accessible on the web, they won’t appear in search results.

How to Disable Indexing:

1. Navigate to Project SEO Management.
2. Enable the No-Indexing toggle.

Even with indexing disabled, your documentation remains accessible to anyone with the direct link. This feature is useful for publishing beta versions or conducting large-scale user testing without impacting SEO due to potential duplicate content.

Unpublishing the Documentation

To unpublish your documentation:

1. Go to Project Access Management settings.
2. Select the Draft option from the access dropdown.

Craft a distinctive look and feel for your Theneo documentation with extensive branding and styling customization options. From choosing the right color palette to setting a custom domain, Theneo empowers you to align your documentation with your brand identity.

Key customization features

• Light and Dark Mode Customization: Tailor your documentation's appearance for both light and dark mode preferences with dedicated logos and color schemes, ensuring a consistent user experience in any setting.
• Color Customization: Fine-tune the color of text, buttons, backgrounds, and more with an easy-to-use color picker. Double-click to access HEX codes for precise matching to your brand colors.
• Custom CSS and JavaScript: For advanced customization, inject custom CSS and JavaScript to take full control over the look and functionality of your documentation.
• Custom Domains: Strengthen your brand's online presence by hosting your documentation on a custom domain, creating a seamless transition from your main website to your Theneo-hosted content.

With Theneo's customization tools, you can create documentation that not only serves its purpose but also resonates with your brand's aesthetic and ethos, making every interaction with your API an extension of your brand experience.

General Settings

• Logos: Upload separate logos for light and dark modes, ensuring clear visibility regardless of theme. Ideal dimensions are provided for optimal display.
• Favicon: Customize the small icon that appears in browser tabs and bookmarks to make your site easily identifiable.
• Logo Hyperlink: Direct users to your desired URL through the logo in your documentation.
• Attribution: Toggle the "Powered by Theneo" attribution on or off to match your branding preferences.
• Document Font: Select from a variety of fonts to maintain consistency across your documentation.

Color Customization of the published view projects:

Each of these elements can be adjusted for both light and dark modes, maintaining consistency or providing contrast as per your branding guidelines.

Custom CSS & Javascript

Custom CSS and JavaScript are powerful tools for personalizing and enhancing the functionality of your Theneo documentation. This guide will walk you through the process of implementing custom CSS and JS to tailor the look and feel of your project.

Custom Font

Customizing fonts in your documentation is an excellent way to enhance branding and readability. This guide will walk you through the steps to add a custom font to your documentation using the Custom CSS feature.

 
@import url('https://fonts.googleapis.com/css2?family=Roboto:ital,wght@0,100;0,300;0,400;0,500;0,700;0,900;1,100;1,300;1,400;1,500;1,700;1,900&family=Sofia&display=swap');
 * {
     font-family: "Sofia", serif;
     font-weight: 400;
     font-style: normal;
 }

A custom domain is a unique branded label that identifies your presence on the Internet. It's essential for establishing brand identity and ensuring a professional appearance for your Theneo projects and Developer Portal. Here's a step-by-step guide to setting up a custom domain for your Theneo-hosted content.

Custom Domain for Projects

1. Access Project Settings:
   • Log in to your Theneo account.
   • Navigate to the settings of the project you want to assign a custom domain to.
   • Select the "Custom Domain" section.
2. Enter Your Domain:
   • Specify the custom domain you wish to use, such as docs.yourdomain.com.
3. Configure DNS Settings:
   • Log into your domain provider’s control panel.
   • Add a CNAME record pointing your custom domain to Theneo’s hosting environment, typically custom.theneo.io.
   • For example, the DNS entry would look like this: developers.example.com. 3600 IN CNAME custom.theneo.io.
4. Finalize Setup in Theneo:
   • After updating DNS settings, go back to Theneo and save your custom domain configuration.
   • It may take some time for DNS changes to propagate. Once done, your project will be accessible via the custom domain.

Custom Domain for Developer Portal

1. Access Developer Portal Settings:
   • Go to the Developer Portal settings within Theneo by visiting https://app.theneo.io/developers-hub/settings.
2. Specify Custom Domain:
   • Enter the custom domain for your Developer Portal, ensuring it aligns with your brand, such as developers.yourdomain.com.
3. DNS Configuration:
   • Similar to project settings, establish a CNAME record in your DNS configuration, pointing to Theneo’s specified domain.
4. Activate Your Domain:
   • Finalize your domain settings in Theneo's Developer Portal settings page.
   • Check for successful DNS propagation before the domain goes live.

Important Tips:

• DNS Propagation: Changes to DNS records can take up to 48 hours to propagate fully across the Internet.
• SSL Certificates: Theneo automatically generates SSL certificates for custom domains, ensuring secure connections.

Theneo's Documentation Analytics provides in-depth insights into the content you have published and user activity on your documentation. This feature helps you track engagement, identify areas for improvement, and optimize your content based on user interactions.

The analytics data is divided into three key sections:

• Traffic: Displays overall visitor statistics, including the number of users, page views, and session counts.
• Pages & Feedback: Shows detailed feedback from users on specific pages and sections.
• AI Search History: Logs user search queries to help you understand their needs and improve documentation accordingly.

By default, Documentation Analytics is enabled once your documentation is published. The analytics data, including visitor numbers, documentation views, and sessions, can be accessed from the Theneo Dashboard or your Project’s Analytics Page.

If needed, you can disable this feature anytime from the Project Settings page under the Features tab.

Filtering Analytics Data

To gain better insights, you can filter analytics data by selecting a specific date range using the Date Filter. This allows you to track trends over time and analyze how documentation performance changes based on updates or user engagement.

Documentation Views Tracking

Theneo tracks documentation views to help you measure the popularity and reach of your content. Every time a user visits a page on your documentation site, it is recorded as a documentation view.

AI Search History

The AI Search History section logs the queries users search for within your documentation. This feature helps you:

• Identify common topics and questions users are interested in
• Understand gaps in your documentation where users struggle to find information
• Improve your content by adding missing or unclear information

You can search through AI Search History to analyze specific queries and take action accordingly.

Section Feedback

The Section Feedback feature allows users to provide direct feedback on individual sections of your documentation. Users can:

• Rate sections as helpful or not
• Leave comments about their experience
• Suggest improvements for clarity or accuracy
• Ask questions if they need further clarification

Viewing and Managing Feedback

Feedback left by users is an essential tool for continuous documentation improvement. You can:

• View a list of comments submitted by visitors
• Identify patterns in user concerns or suggestions
• Make data-driven updates to your documentation

By addressing feedback and updating your content accordingly, you can enhance the overall user experience and ensure that your documentation remains accurate, clear, and useful.

Best Practices for Using Documentation Analytics

To make the most of Theneo’s analytics features, consider the following best practices:

1. Regularly monitor analytics data – Track visitor trends and feedback to stay informed about how your documentation is performing.
2. Identify weak spots – Use AI Search History and low-performing pages as indicators of where improvements are needed.
3. Act on feedback – Respond to user comments, update unclear sections, and make necessary changes based on insights from Section Feedback.
4. Compare trends over time – Use date filtering to observe how documentation changes impact user engagement.

Custom Analytics

Integrating Google Analytics (GA) or Google Tag Manager (GTM) with your Theneo platform allows you to track user interactions and gain insights into how your application is being used. Follow the steps below to add your unique GA tag or GTM ID:

Step 1: Navigate to Branding Settings

1. Log in to your Theneo account.
2. On the dashboard, locate and click on the “Branding” option in the main navigation menu.

Step 2: Access Analytics Configuration

1. Within the Branding section, you will see a submenu. Click on the “Analytics” tab to open the analytics configuration options.

Step 3: Adding Your Google Analytics Tag ID

1. To add a Google Analytics tag:
   • Find the field labeled "Google tag ID."
   • Click on the pencil icon (edit button) next to the field.
   • Enter your Google Analytics ID, which usually starts with “G-” followed by a series of numbers.

Step 4: Adding Your Google Tag Manager ID

1. To add a Google Tag Manager ID:
   • Locate the field marked "Google tag manager."
   • Click on the pencil icon (edit button) next to this field.
   • Input your GTM ID, which typically begins with “GTM-” or “UA-” followed by a series of numbers.

Step 5: Save Your Changes

1. After entering your IDs, ensure to save the changes by clicking the save icon or button typically located at the bottom or top-right of the page.

Step 6: Using Custom JavaScript for Other Analytics Services

If you use an analytics service other than Google Analytics or Google Tag Manager:

1. Go back to the submenu under “Branding.”
2. Select “Custom CSS & JS” to access the custom scripting functionality.
3. Here, you can add your own JavaScript tracking codes as needed for other analytics services.

Important Notes

• Verification: After adding your GA or GTM IDs, it is crucial to verify that they are working correctly. You can do this by checking your GA or GTM dashboard to see if it is receiving data from your Theneo platform.
• Custom JavaScript: If you are not familiar with JavaScript and need to implement custom tracking scripts, consider consulting with a developer or your analytics provider for assistance

Theneo's published view is crafted to enhance user experience, offering a seamless and intuitive interface for navigating and reading API documentation. This section aims to elucidate the key features of Theneo's published view, providing you with detailed insights and instructions to fully leverage the capabilities of our documentation system. By understanding and utilizing these features, you can streamline your workflow, improve accessibility, and ensure an efficient documentation experience.

Side Menu

The side menu is an integral part of Theneo's published view, providing an organized and accessible way to navigate through the documentation.

Features:

• Sections and Subsections: The side menu displays all sections and subsections of the documentation, allowing for quick and easy access to different parts of the content.
• Custom Headers and Icons: Users can create custom headers and add icons for a more visually appealing and easily navigable menu.

Continuous Scrolling

Theneo's continuous scrolling enhances navigation by allowing you to scroll through the documentation without needing to click to navigate to other pages.

Benefits:

• Seamless Navigation: No need to click through multiple pages; just scroll down to continue reading.
• Improved User Experience: Continuous scrolling ensures a smooth and uninterrupted reading experience.

Search and AI Search

Finding specific information within the documentation is made easy with our search functionalities.

Features:

• Standard Search: Quickly locate content by typing keywords into the search bar.
• ChatGPT Search: Utilize the power of ChatGPT to search for documentation content with more natural language queries.

Custom Menu

The custom menu feature allows you to add any item or group of items in a dropdown for shortcut access.

Customization Options:

• Add Items: Include any documentation pages, links, or tools you frequently use.
• Group Items: Organize related items into groups within the dropdown for easier access.

Custom Menu Main Button Highlighting

To make navigation even more intuitive, the Main Button feature allows users to mark one item (excluding subitems) as the main button in the custom menu. This visually distinct button serves as a primary point of focus in the menu.

Main Button Design in Published View:

• The Main Button will have a distinct design with a highlighted background to make it stand out from other menu items.
• This ensures that users can easily identify the most important or relevant section of the documentation at a glance.

Anchor Tags for Headers

Anchor links enhances the ability to share and reference specific parts of the documentation.

How it Works:

• Anchor Tags: Each header in a section is equipped with an anchor tag, allowing you to link directly to that header.
• Easy Referencing: Share the URL with the specific anchor tag to direct others to the exact part of the documentation you are referencing.

HTTP Method Display in the Side Menu

In your API documentation, you can choose to display HTTP methods (GET, POST, PUT, DELETE, etc.) for each endpoint directly in the side menu. This feature makes it easier for users to quickly identify the type of request each endpoint supports.

Configuring the HTTP Method Display Option

To enable this feature, follow the steps below:

1. Navigate to Project Settings:
2. Go to your project's dashboard and open the Project Settings.
3. Locate the Features Tab:
4. Inside Project Settings, click on the Features tab to access additional project configuration options.
5. Enable the HTTP Method Display:
6. In the Features tab, find the toggle option labeled HTTP Method Display.
7. By default, this option is turned off. Switch the toggle to on to enable it.
8. Republish the Project:
9. After enabling the HTTP Method Display, republish your project to apply the changes.

Once republished, the HTTP methods will be automatically displayed next to each endpoint in the side menu, making the documentation more intuitive for developers.

FAQ

1

Create Theneo Documentation

Begin by creating a documentation project within Theneo to house your API details.

2

Set Up GitHub Workflow

Set Up GitHub Workflow

Configure a workflow in your GitHub repository that will interact with Theneo:

• Create a Workflow File: Add a file named Theneo.yml to the .github/workflows/ directory in your GitHub repository. This file will define the actions to be taken.

Example Theneo.yml Workflow:

YAML

 
name: Update Documentation
on:
  pull_request:
    branches:
      - main
jobs:
  update-doc:
    name: Update Theneo Documentation
    runs-on: ubuntu-latest
    steps:
      - run: echo "🎉 The job was automatically triggered by a ${{ github.event_name }} event."
      - name: Checkout
        uses: actions/checkout@v4
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: "18"
      - name: Update Documentation on Theneo
        uses: Theneo-Inc/api-documentation@1.8.0
        with:
          FILE_PATH: doc/api.yml
          PROJECT_SLUG: <project_slug>
          VERSION_SLUG: <version_slug>
          WORKSPACE_SLUG: <workspace_slug>
          SECRET: ${{secrets.SECRET}}
          AUTO_PUBLISH: true
          IMPORT_OPTION: merge
          PARAMETER_DESCRIPTION_MERGE_STRATEGY: keep_new
          SECTION_DESCRIPTION_MERGE_STRATEGY: keep_old
          INCLUDE_GITHUB_METADATA: true

3

Locating Your Theneo Project Slug

To configure GitHub Actions, you'll need your Theneo project slug:

• Go to your project dashboard in Theneo.
• Open the desired project.
• The project slug is part of the URL: https://app.theneo.io/<workspace-name>/<project-slug>/[version-slug].
• For example, if the URL is https://app.theneo.io/theneo/github-demo, your project slug is github-demo.

Use this project slug for the PROJECT_SLUG variable in your GitHub workflow.

4

Inputs

Define the following inputs in your workflow file to configure the GitHub Action:

• FILE_PATH: The path to your API documentation file within the repository.
• PROJECT_SLUG: Your project's unique identifier in Theneo, accessible under project settings.
• VERSION_SLUG: Project version slug to import documentation under a specific version, otherwise default version will be used.
• WORKSPACE_SLUG: Project workspace slug to import documentation under specific workspace.
• SECRET: Your Theneo API token for authentication, which can be found in your Theneo profile.
• IMPORT_OPTION: Determines how to handle the imported documentation. Options include overwrite, merge, and endpoints.
• AUTO_PUBLISH: If set to true, Theneo will automatically publish the changes. If false, you can review changes in the editor before manual publication.
• INCLUDE_GITHUB_METADATA: Includes metadata like the GitHub actor in the documentation, visible only in Theneo's editor.
• SECTION_DESCRIPTION_MERGE_STRATEGY : Merging strategy for section descriptions to keep old descriptions from theneo editor if needed, valid values are keep_new or keep_old.
• PARAMETER_DESCRIPTION_MERGE_STRATEGY: Merging strategy for parameter descriptions to keep old descriptions from theneo editor if needed, valid values are keep_new or keep_old.

5

Import Options

Choose how Theneo handles incoming changes:

• overwrite: Replaces the current documentation with the new spec entirely.
• merge: Attempts to merge changes; this is experimental and may append changes in some cases.
• endpoints: Adds new spec endpoints into a dedicated section for manual arrangement.

6

Auto-Publish Option

Control the publication of your documentation:

• true: Automatically updates the published documentation with the latest changes.
• false: Allows for a review in Theneo's editor before you decide to publish.

Using Theneo's GitHub Actions integration, the process of maintaining accurate and current API documentation becomes automated, seamless, and efficient. Your team and users gain immediate access to the latest documentation, ensuring everyone is on the same page with API updates and changes.

Visual Studio Code (VS Code) is a preferred editor for many developers due to its versatility and extensive extension ecosystem. To enhance the experience further, Theneo offers a dedicated VS Code extension that simplifies the creation and previewing of API references directly within the editor.

Installation and Configuration

Install Theneo VS Code Extenstion

Configure the Extension:

1. After installation, sign in to your Theneo account at app.theneo.io
2. Once signed in, navigate to your profile settings.
3. Within your profile settings, locate and select the "Tools & Integrations" section.
4. In the "Tools & Integrations" section, find and copy your Theneo API key.
5. In VS Code Extension open the command palette by pressing Ctrl+Shift+P (or Cmd+Shift+P on Mac).
6. Type 'Preferences: Open Settings (UI)' and select it.
7. Search for Theneo Markdown in the “Extensions” section
8. Paste your Theneo API key

New Features

• Ability to export projects from Theneo as markdown and json.
• Ability to Import markdown into theneo directly.
• Ability to merge json to an existing project in Theneo.

Usage

Export Project from Theneo

1. Open the command palette by pressing Ctrl+Shift+P (or Cmd+Shift+P on Mac).
2. Search for “Theneo: Export Project from Theneo”.
3. Select the project from your list of published projects created in Theneo.
4. Enter a parent directory to export the project and press enter.

Import Project to Theneo

1. Open the command palette by pressing Ctrl+Shift+P (or Cmd+Shift+P on Mac).
2. Search for “Theneo: Import Project To Theneo”.
3. Enter project name after “/”. example /project
4. Choose if you want to publish the document.

Merge Project to Theneo

1. Open the command palette by pressing Ctrl+Shift+P (or Cmd+Shift+P on Mac).
2. Search for "Theneo: Merge Project To Theneo".
3. Copy the relative path to the section that you want to merge.
4. Pick the project you are merging with (usually the same project as you exported).
5. Go over the changes and press commit merge button.

Open Preview

1. Open the command palette by pressing Ctrl+Shift+P (or Cmd+Shift+P on Mac).
2. Search for “Theneo: Open Current Project Preview”.
3. Type the project name and press enter.

The Theneo VS Code extension streamlines the API documentation process by integrating it into your development environment. It saves time and enhances efficiency by eliminating the need to switch between tools for documentation tasks.

With just a few clicks, you can generate a live preview of your API documentation, making it easier to develop and review your API descriptions and endpoints without ever leaving VS Code.

The Theneo CLI (Command Line Interface) is s a command-line tool for effortless management of the Theneo platform from your terminal. Create, manage, and publish API documentation with ease, all without leaving your command line.

You can find Github repo here or the npm package here → https://www.npmjs.com/package/@theneo/cli

To install the Theneo CLI, use the following command:

 
npm install -g @theneo/cli@latest

This command installs the Theneo CLI globally on your machine, allowing it to be run from any directory.

Basic Usage

To get started with Theneo CLI, you can use the help command:

 
theneo help

This command provides a list of available options and commands:

General Options:

• -V, --version: Outputs the version number of the Theneo CLI.
• -h, --help: Displays help for a specific command.

Primary Commands:

• login: Logs into the Theneo CLI.
• project <action>:Executes project related commands.
• workspace <action>: Executes workspace related commands.
• version <action>: Executes project version related commands.
• help [command]: Provides help for a specific command.

Common Use Cases

 
theneo login

 
theneo login --token <theneo-api-key>

 
theneo project create --help
Usage: theneo project create [options]

Create new project

Options:
  --name <name>                                  Project name
  --workspace <workspace>                        Enter workspace slug where the project should be created in, if not present uses default
                                                 workspace
  -f, --file <file>                              API file path to import (eg: docs/openapi.yml)
  --link <link>                                  API file URL to create project using it
  --postman-api-key <postman-api-key>            Postman API Key (env: THENEO_POSTMAN_API_KEY)
  --postman-collection <postman-collection>      Postman collection id, you can use multiple times
  --empty                                        Creates empty project (default: false)
  --sample                                       Creates project with sample template (default: false)
  --publish                                      Publish the project after creation (default: false)
  --public                                       Make published documentation to be publicly accessible. Private by default (default:
                                                 false)
  --generate-description <generate-description>  Indicates if AI should be used for description generation (choices: "fill", "overwrite",
                                                 "no_generation", default: "no_generation")
  --profile <string>                             Use a specific profile from your config file.
  -h, --help                                     display help for command

 
theneo project create

 
theneo project create --name api-documentation --generate-description overwrite --publish --public --file ./examples/openapi-spec.json

 
theneo project create --name api-documentation --generate-description fill --publish --public --link https://raw.githubusercontent.com/OAI/OpenAPI-Specification/main/examples/v3.0/uspto.json

 
theneo project create --name api-documentation --postman-api-key <key> --postman-collection <id-1> --postman-collection <id-2>

 
Usage: theneo project import [options]

Import updated documentation into Theneo using file, link or postman collection

Note: Published document link has this pattern: https://app.theneo.io/<workspace-slug>/<project-slug>/<version-slug>

Options:
  --project <project-slug>                   Specify the project slug to import updated documentation in
  -f, --file <file>                          API file path to import (eg: docs/openapi.yml)
  --link <link>                              API file URL to create project using it
  --postman-api-key <postman-api-key>        Postman API Key (env: THENEO_POSTMAN_API_KEY)
  --postman-collection <postman-collection>  Postman collection id, you can use multiple times
  --import-type <import-type>                Indicates how should the new api spec be imported (choices: "endpoints", "overwrite", "append", "merge")
  --publish                                  Automatically publish the project (default: false)
  --workspace <workspace-slug>               Workspace slug, where the project is located
  --projectVersion <version-slug>            Project version slug to import to, if not provided then default version will be used
  --keepOldParameterDescription              Additional flag during merging import option, it will keep old parameter descriptions
  --keepOldSectionDescription                Additional flag during merging import option, it will keep old section descriptions
  --profile <string>                         Use a specific profile from your config file.
  -h, --help                                 display help for command

 
theneo project import --file <file> --project <project-slug> --publish

 
theneo project import --project <project-slug> \
--workspace <workspace-slug> \
--projectVersion <version-slug> \
--publish \
--file ./api-spec.json \
--import-type merge \
--keepOldParameterDescription \
--keepOldSectionDescription

 
theneo project publish --project <project-slug>

 
theneo project delete --project <project-slug>

 
theneo version --help
Usage: theneo version [options] [command] <action>

Project version related commands

Options:
  -h, --help        display help for command

Commands:
  list [options]    List project versions
  create [options]
  delete [options]
  help [command]    display help for command

 
Usage: theneo version create [options]

Options:
  --name <name>                              Name of the version
  --project <project-slug>                   Project slug to create version for
  --workspace <workspace-slug>               Workspace slug where the project is
  --previousVersion <previous-version-slug>  Previous version slug to duplicate the content from
  --profile <string>                         Use a specific profile from your config file.
  -h, --help                                 display help for command

 
Usage: theneo version add-subscriber [options]

Add a subscriber for project changelog

Options:
  --project <project-slug>                  Project slug
  --workspace <workspace-slug>              Workspace slug
  --projectVersion <previous-version-slug>  Project version slug
  --email <email>                           Email of the new subscriber to change log
  --profile <string>                        Use a specific profile from your config file.
  -h, --help                                display help for command

 
git clone git@github.com:Theneo-Inc/theneo-tools.git

 
nvm use 
npm install

 
npm run cli

 
theneo help

 
THENEO_API_KEY=<theneo-api-key> THENEO_API_URL=https://api.theneo.io THENEO_APP_URL=https://app.theneo.io \theneo <command>

 
theneo login --profile <profile-name> --token <theneo-api-key> --api-url https://api.theneo.io --app-url https://app.theneo.io

CLI Export

Export Project Data in Markdown Format - Beta Feature

 
Usage: theneo export [options] Options: --project
project slug --projectVersion
Version slug --workspace
Enter workspace slug where the project should be created in, if not present uses default workspace --profile
Use a specific profile from your config file. --dir

Export an OpenAPI Spec - Beta Feature

You can export your Theneo docs into an openAPI spec, by running the following command

 
theneo export --openapi --format json

Managing Projects Using Markdown Files via CLI

Create a New Project from Markdown Files

 
Usage: theneo create [options]

Options:
  --dir <directory>             directory location where the project will be exported
  --name <project-name>         project name 
  --workspace <workspace-slug>  Enter workspace slug where the project should be created in, if not present uses default workspace
  --profile <string>            Use a specific profile from your config file.
  -h, --help                    display help for command

Import Project Data from Markdown Files

 
Usage: theneo import [options]

Update theneo project from generated markdown directory

Options:
  --project <project-slug>         project slug
  --workspace <workspace-slug>     Enter workspace slug where the project

Best Practices and Tips

• Always check the version of the Theneo CLI installed with theneo -V to ensure compatibility with your project.
• Utilize the --help option regularly to understand the specific requirements of each command.
• Regularly update your Theneo CLI to access the latest features and bug fixes.
• When importing or updating projects, ensure your API specifications are correctly formatted to avoid errors.

The Theneo SDK is a comprehensive package designed to simplify API requests to the Theneo API, enabling easy integration of Theneo's features into various applications. This SDK abstracts the complexities of API requests and error handling, providing a more streamlined experience for developers.

This documentation provides an overview of the Theneo SDK package. The SDK package includes classes and interfaces for working with the Theneo API. Theneo is a platform for managing API documentation projects.

You can find the Github repository here

Install

Install the Theneo SDK Package: Use npm to install the Theneo SDK package:

 
  npm install @theneo/sdk

Usage

To use the Theneo SDK package, import the necessary classes and interfaces, and create an instance of the Theneo class with the required options. Then, you can use the methods provided by the SDK to interact with the Theneo API.

 
import { Theneo, TheneoOptions, Result, Workspace, ProjectSchema, CreateProjectOptions } from "@theneo/sdk";
// Define Theneo options
const options: TheneoOptions = {
  apiKey: "YOUR_API_KEY"
};
// Create a Theneo instance
const theneo = new Theneo(options);
// Example usage
async function listWorkspaces() {
  const result: Result<Workspace[]> = await theneo.listWorkspaces();
  if (result.ok) {
    const workspaces: Workspace[] = result.unwrap();
    console.log("Workspaces:", workspaces);
  } else {
    console.error("Error:", result.unwrap());
  }
}
// Create a new project
async function createProject() {
  const projectOptions: CreateProjectOptions = {
    name: "My Project",
    workspace: { key: "workspace-key" },
    publish: true,
    isPublic: true,
    data: {
      // Specify the data source using one of the following attributes:
      // 1. Import from a file
      // file: '/path/to/api-documentation.json',
      // 2. Import from a URL
      // link: 'https://example.com/api-documentation.json',
      // 3. Import from a text string
      // text: 'API documentation content as a string',
      // 4. Import from a Postman collection
      // postman: {
      //   apiKey: 'YOUR_POSTMAN_API_KEY',
      //   collectionIds: ['collection-id-1', 'collection-id-2'],
      // },
    } as ApiDataInputOption
  };
  const result: Result<CreateProjectResponse> = await theneo.createProject(projectOptions);
  if (result.ok) {
    const createdProject: CreateProjectResponse = result.unwrap();
    console.log("Created Project:", createdProject);
  } else {
    console.error("Error:", result.unwrap());
  }
}
// Use the SDK methods as needed
listWorkspaces();
createProject();

Import API documentation

An example demonstrating how to use the importProjectDocument method to import API documentation to an existing project using the Theneo SDK in TypeScript:

 
import { Theneo, TheneoOptions, Result, ImportProjectOptions, ImportResponse, ApiDataInputOption } from "@theneo/sdk";
// Define Theneo options
const options: TheneoOptions = {
  apiKey: "YOUR_API_KEY"
};
// Create a Theneo instance
const theneo = new Theneo(options);
// Define the import options
const importOptions: ImportProjectOptions = {
  projectId: "project-id", // Replace with the actual project ID
  publish: true, // Set to true if you want to publish the imported data
  data: {
    // Specify the data source using one of the following attributes:
    // 1. Import from a file
    // file: '/path/to/api-documentation.json',
    // 2. Import from a URL
    // link: 'https://example.com/api-documentation.json',
    // 3. Import from a text string
    // text: 'API documentation content as a string',
    // 4. Import from a Postman collection
    // postman: {
    //   apiKey: 'YOUR_POSTMAN_API_KEY',
    //   collectionIds: ['collection-id-1', 'collection-id-2'],
    // },
  } as ApiDataInputOption
};
// Import API documentation to the project
async function importApiDocumentation() {
  const result: Result<ImportResponse> = await theneo.importProjectDocument(importOptions);
  if (result.ok) {
    const importResponse: ImportResponse = result.unwrap();
    console.log("Imported API Documentation:", importResponse);
  } else {
    console.error("Error:", result.unwrap());
  }
}
// Run the import function
importApiDocumentation();

In this example:

• We first create an instance of the Theneo class and provide the necessary API key in the options object.
• We define the import options in the importOptions object. You should replace 'project-id' with the actual ID of the project where you want to import the API documentation.
• Inside the data attribute of importOptions, you can specify the source of the API documentation to be imported. You can choose one of the four options:
  1. Import from a file (specify the file path).
  2. Import from a URL (specify the URL).
  3. Import from a text string (specify the content as a string).
  4. Import from a Postman collection (specify the Postman API key and collection IDs).
• The publish option is set to true to indicate that the imported data should be published.
• The importApiDocumentation function uses the importProjectDocument method to perform the import operation.

Make sure to replace the placeholder values ('YOUR_API_KEY', 'project-id', and any others) with your actual API key and project details before running the code.

Theneo supports automatic synchronization with Postman collections via GitHub. This powerful integration ensures that any changes you make to your Postman API collections are seamlessly updated in your Theneo documentation—without manual effort.

By setting up a GitHub integration in Postman and configuring a Theneo GitHub Action workflow, you can keep your API documentation fully aligned with your latest API definitions.

Benefits of Postman Sync

• Real-time Updates: Every change you make in Postman is reflected in Theneo.
• No Manual Uploads: Eliminate the need to manually export and upload collections.
• Version Control: Changes are tracked through GitHub, enabling better collaboration and rollback capability.
• Streamlined Workflow: Developers can focus on building APIs while keeping docs always up-to-date.
• Automated Publishing: With auto-publish enabled, your docs stay fresh without extra steps.

How to Set Up Postman to GitHub Sync

After completing this setup, all updates made in Postman will be automatically pushed to your GitHub repository.

Syncing GitHub Updates with Theneo

To ensure updates also sync to Theneo automatically, you'll need to configure Theneo GitHub Actions in your repository.

Create a Workflow File

Add a file named Theneo.yml in the .github/workflows/ directory of your GitHub repo.

Here’s an example workflow file:

 
name: Update Documentation
on:
  pull_request:
    branches:
      - main
jobs:
  update-doc:
    name: Update Theneo Documentation
    runs-on: ubuntu-latest
    steps:
      - run: echo "🎉 The job was automatically triggered by a ${{ github.event_name }} event."
      - name: Checkout
        uses: actions/checkout@v4
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: "18"
      - name: Update Documentation on Theneo
        uses: Theneo-Inc/api-documentation@1.8.0
        with:
          FILE_PATH: doc/api.yml

          PROJECT_SLUG: <project_slug>
          VERSION_SLUG: <version_slug>
          WORKSPACE_SLUG: <workspace_slug>

          SECRET: ${{secrets.SECRET}}

          AUTO_PUBLISH: true

          IMPORT_OPTION: merge
          PARAMETER_DESCRIPTION_MERGE_STRATEGY: keep_new
          SECTION_DESCRIPTION_MERGE_STRATEGY: keep_old

          INCLUDE_GITHUB_METADATA: true

Need help setting this up visually?

👉 Here is the video guide for more guidance:

More Resources

For complete details on how to configure Theneo GitHub Actions, visit our setup guide here.

Once you've successfully configured GitHub sync in Postman and set up the Theneo GitHub Action workflow, your API documentation in Theneo will stay automatically in sync with your latest Postman updates.

Theneo offers seamless synchronization with GitLab repositories, enabling automatic pushing of your API specifications or entire documentation folders to your Theneo workspace. This guide walks you through the steps to configure GitLab CI/CD for Theneo sync.

Before starting, make sure you have:

• A GitLab repository where you manage your API specs or documentation.
• Your Theneo API Key.
• The following Theneo configuration variables set in your GitLab CI/CD settings:
• THENEO_API_KEY: Your Theneo API token, used for authentication, can be found in your Theneo profile settings.
• THENEO_PROJECT_SLUG: Your project's unique identifier in Theneo, accessible under project settings.
• THENEO_WORKSPACE_SLUG: Project workspace slug to import documentation under specific workspace, accessible under project settings.
• THENEO_VERSION_SLUG: Project version slug to import documentation under a specific version, otherwise default version will be used.
• THENEO_FILE_PATH : The path to your API documentation file within the repository (for API spec import).
• Folder_PATH : The path to your documentation folder within the repository (for folder import).

Setup Instructions

You can configure the sync by either editing your existing .gitlab-ci.yml file or creating a new one in your repository.

Import API Specs Only

To push a single OpenAPI spec file to Theneo, use the following .gitlab-ci.yml script:

 
image: node:22

stages:
  - push-to-theneo

push-openapi-to-theneo:
  stage: push-to-theneo
  script:
    - npm install -g @theneo/cli@latest
    - echo "Logging in to Theneo..."
    - theneo login --token $THENEO_API_KEY
    - echo "Listing Theneo projects..."
    - theneo project list
    - echo "Importing OpenAPI spec to Theneo..."
    - |
      theneo project import \
        --project $THENEO_PROJECT_SLUG \
        --workspace $THENEO_WORKSPACE_SLUG \
        --projectVersion $THENEO_VERSION_SLUG \
        --publish \
        --file $THENEO_FILE_PATH \
        --import-type overwrite

You can also specify how Theneo handles incoming changes using the --import-type option:

• overwrite – Replaces the existing documentation with the new specification entirely.
• merge (beta) – Attempts to combine new content with existing documentation. May append or blend content based on:
• PARAMETER_DESCRIPTION_MERGE_STRATEGY: keep_new
• SECTION_DESCRIPTION_MERGE_STRATEGY: keep_old
• endpoints – Adds new spec endpoints into a separate section for manual arrangement later in the editor.

Import an Entire Folder

To push an entire folder to Theneo, use this alternative script:

 
image: node:22

stages:
  - push-to-theneo

push-openapi-to-theneo:
  stage: push-to-theneo
  script:
    - npm install -g @theneo/cli@latest
    - echo "Logging in to Theneo..."
    - theneo login --token $THENEO_API_KEY
    - echo "Listing Theneo projects..."
    - theneo project list
    - echo "Importing OpenAPI spec to Theneo..."
    - |
      theneo import \
        --project $THENEO_PROJECT_SLUG \
        --workspace $THENEO_WORKSPACE_SLUG \
        --projectVersion $THENEO_VERSION_SLUG \
        --publish \
        --dir $Folder_PATH \

Bitbucket’s collaborative environment is ideal for teams to manage their codebase. Integrating Bitbucket with Theneo ensures your API documentation stays in sync with your repository changes. Here’s how to set up Bitbucket integration:

Usage

Step 1: Create Theneo Documentation

Initiate your API documentation by creating a project on the Theneo platform.

Prerequisites for Bitbucket Integration

• An established API documentation project on Theneo.
• A generated API key from your account → https://app.theneo.io/account-settings/toolsandintegrations
• Your API documentation file located within your Bitbucket repository.

After setting up the Bitbucket pipeline with the appropriate Theneo variables, your API documentation will automatically reflect changes pushed to your repository. This seamless integration facilitates an up-to-date and accurate representation of your API for developers and stakeholders.

Step 2: Configure Bitbucket Pipeline

Incorporate Theneo's automation into your Bitbucket repository:

• Add a Pipeline: Integrate Theneo's pipeline into your bitbucket-pipelines.yml file to update your Theneo documentation with each repository update.
• Configure the Pipeline: Use the snippet below in your bitbucket-pipelines.yml file to set up the pipeline.

For Importing a single API Spec

 
# bitbucket-pipelines.yml
image: node:22

pipelines:
  default:
    - step:
        name: Import OpenAPI spec to Theneo
        caches:
          - node
        script:
          # Install CLI + login
          - npm install -g @theneo/cli@latest
          - echo "Logging in to Theneo..."
          - theneo login --token "THENEO_API_KEY"

          # Import the spec file
          - |
            theneo project import \
              --project "THENEO_PROJECT_KEY" \
              --workspace "$THENEO_WORKSPACE_SLUG" \
              --publish \
              --file "API_DOCUMENT_PATH" \
              --import-type merge

Variables for Bitbucket Pipeline:

• API_DOCUMENT_PATH: The path to your API spec within your repository. e.g docs
• THENEO_PROJECT_KEY: The unique slug of your Theneo project. Find this in your Theneo project URL: https://app.theneo.io/[workspace-name]/[project-slug]. For example, if your Theneo project URL is https://app.theneo.io/theneo/bitbucket-demo, the bitbucket-demo is your project slug.
• THENEO_API_KEY: Your Theneo API key, which you can generate from the Theneo website.

Sample script

# bitbucket-pipelines.yml
image: node:22

pipelines:
  default:
    - step:
        name: Import OpenAPI spec to Theneo
        caches:
          - node
        script:
          # Install CLI + login
          - npm install -g @theneo/cli@latest
          - echo "Logging in to Theneo..."
          - theneo login --token "8dd818-f628-40fd-9ff2-b84f7d42da6d"

          # Import the spec file
          - |
            theneo project import \
              --project "demo" \
              --workspace "demo" \
              --publish \
              --file "docs/petstore.yaml" \
              --import-type merge 

In here, this is my sample token --token "8dd81-f628-40fd-9ff2-b84f7d42da6d", testdoc is the project slug --project "testdoc" , and my api spec is located here docs/petstore.yaml

Import Options

Choose how Theneo handles incoming changes:

• overwrite: Replaces the current documentation with the new spec entirely.
• merge: Attempts to merge changes; this is experimental and may append changes in some cases.
• endpoints: Adds new spec endpoints into a dedicated section for manual arrangement.

For Importing an entire folder (markdowns + API)

If you would like to import exported markdown content + API configuration, then you can use the following script

 
# bitbucket-pipelines.yml
image: node:22

pipelines:
  default:
    - step:
        name: Push OpenAPI to Theneo
        caches:
          - node
        script:
          - npm install -g @theneo/cli@latest
          - echo "Logging in to Theneo..."
          - theneo login --token "THENEO_API_KEY"
          - echo "Listing Theneo projects..."
          - theneo project list
          - echo "Importing OpenAPI spec to Theneo..."
          - echo "Updating a Project in Theneo..."
          - theneo import --project "THENEO_PROJECT_KEY" --workspace "Workspace_name" --dir path_to_yourfolder

Theneo AI Co-Pilot revolutionizes the way you create API documentation by automating the generation of descriptive content. This powerful feature saves you significant time and effort, particularly when your API undergoes frequent updates. Here’s how you can leverage the AI Co-Pilot in Theneo:

1. Opting for AI Assistance During Project Creation:

• Full AI Assistance: Choose this to allow the AI to craft new content for each part of your documentation, replacing existing descriptions for consistency and engagement.
• Enhance Existing Content: Select this for the AI to smartly fill in missing pieces without modifying what you’ve already crafted, preserving the originality of your content.
• No AI Assistance: If you prefer manual control over your content, opt for this to keep the existing documentation untouched by AI.

2. Using AI Assistant Within the Editor:

• Click on "AI Assistant" in the editor when working on an API spec.
• The AI Assistant proactively suggests detailed descriptions for each component of your API request, such as headers, body, parameters, and responses.

Example Workflow:

• Imagine you're documenting an order creation endpoint with a body parameter like idempotency_key. The AI Co-Pilot might suggest a description such as "Provide a unique key to prevent duplicate orders on network failure," clarifying its use for your consumers.

Advantages of Theneo AI Co-Pilot:

• Time Efficiency: It dramatically reduces the time required to write and update documentation.
• Consistency: Ensures uniformity in language and style across all documentation segments.
• Accuracy: AI-generated content is designed to be precise, reducing potential errors and misunderstandings.
• Focus on Core Tasks: Frees up your time to concentrate on API design and development rather than documentation.

Integrating Theneo AI Co-Pilot:

The Theneo AI Co-Pilot is an invaluable resource, akin to having a dedicated technical writer on your team. It enhances your documentation process, ensuring that your API is documented thoroughly, accurately, and in a way that’s easy to understand for users, all while you remain focused on the more strategic aspects of API design and functionality.

Theneo's ChatGPT integration allows users to interact with your documentation in a conversational manner. They can ask any questions related to the documentation content, ranging from technical queries to business-related inquiries, directly within the docs.

Enabling ChatGPT Integration:

1. Navigate to the Settings area of your Theneo dashboard.
2. Locate the Features section.
3. Find the AI search option and toggle the switch to enable it.
4. Republish your documentation to make the AI search feature live.

Using AI Search in Theneo:

Once enabled, users can ask questions directly within the documentation interface. The system is designed to comprehend the context of the documentation and provide relevant answers, leveraging the powerful capabilities of GPT-4 turbo.

FAQ:

By integrating ChatGPT, Theneo enhances the user experience by providing an interactive, AI-driven approach to navigating and understanding API documentation. This feature not only adds a layer of user engagement but also aids in quickly resolving queries, making the documentation more accessible and user-friendly.

The AI Chatbot feature is designed to streamline the process of finding information about Theneo, helping users quickly receive accurate answers without having to sift through extensive documentation. Located on Theneo's dashboard, this intelligent assistant is trained on Theneo's documentation, knowledge base, and other relevant content to ensure users get the information they need with ease.

But there’s more! You can harness the same power for your documentation by creating and embedding your own AI chatbot. Let’s explore how this feature can enhance your support experience and why it’s a game-changer for you and your users.

Why Use the AI Chatbot?

For Theneo Users

• Quick Problem Solving: Have a specific question about Theneo? Just ask the chatbot! It provides fast, accurate answers without requiring you to navigate through extensive guides.
• Ease of Use: The intuitive interface ensures that even first-time users can interact seamlessly with the chatbot and find what they need in seconds.
• Comprehensive Knowledge: With access to Theneo’s entire knowledge base and documentation, the chatbot covers all aspects of the platform, from simple FAQs to in-depth technical details.

For Your Own Documentation

The AI Chatbot is not just for Theneo users. You can also:

• Train the Chatbot on Your Content: Input your own documentation, FAQs, and support materials, creating a tailored chatbot for your platform.
• Provide 24/7 Support: Offer uninterrupted assistance to your users without increasing support team resources.
• Enhance Productivity: Free up your support team to focus on complex queries while the chatbot handles routine questions efficiently.

Features That Make the AI Chatbot Stand Out

1. Smart, Context-Aware Assistance The chatbot understands context and nuances, ensuring it provides the most relevant responses to user queries.
2. Customizable for Your Brand Configure the chatbot to align with your brand’s tone, style, and voice, creating a consistent experience across your platforms.
3. Seamless Integration Embed the chatbot into your documentation or platform effortlessly. Whether it’s your developer portal, website, or product interface, the chatbot fits right in.
4. Search Export Capability Export the chatbot’s functionality to external platforms like websites, apps, or customer portals. This feature extends its utility beyond the documentation, offering users a unified experience wherever they interact with your content.

Benefits of Exporting and Embedding the Chatbot

• Wider Reach: Bring your chatbot to where your users are—on your platform, website, or mobile app.
• Streamlined User Journeys: Offer users quick answers and guidance directly within the interface they’re using, eliminating the need to switch between platforms.
• Improved User Satisfaction: By providing instant support, you make your users feel valued and supported, fostering loyalty and trust.

How to Get Started

Click here to learn how you can integrate your own intelligent help bot and elevate your user support experience.