Theneo Quickstart Guide
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
For API docs, the steps are very simple
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. For detailed instructions on workspaces, check out our guides
What made this section unhelpful for you?
API Import & Specs
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
In the following sections, we'll delve into each of these formats and collections, providing detailed insights and instructions.
API Testing
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 Changelog
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
Whenever a new API spec is imported and the "Publish" button is clicked, Theneo detects and summarizes all the changes, such as:
- New endpoints added
- Existing sections updated
- Descriptions modified
- Sections or endpoints removed
These updates are meticulously logged on a dedicated changelog page, providing a detailed version history with timestamps.
Real-Time Email Notifications
How to Subscribe
- Enter Your Email: On the Changelog page, there’s a field to enter your email.
- 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
Can I turn off the changelog?
Yes, the changelog feature in Theneo is optional. You can disable it at any time by going to your project settings, navigating to the 'Features' section, and toggling off the changelog feature.
Can I edit the changelog?
Currently, direct editing of changelog entries is not available. However, if you need to remove a specific entry from the public changelog, you can delete it. To do this, go to your project configuration, select 'Public Changelog,' and use the delete button next to the entry you wish to remove.
Can I edit versions?
The ability to edit version details is a feature that is in the pipeline and will be available soon. This upcoming feature will provide more control over how you document and present version changes in the changelog.
Will this create a new API version if there are breaking changes?
Theneo is designed to track changes meticulously. The functionality to automatically create a new API version upon detecting breaking changes is being developed. When released, it will allow users to manage versions more effectively and ensure that versioning reflects significant changes or updates.
What made this section unhelpful for you?
API Versioning
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.
How to Access API Versioning
As this is a beta feature, Theneo invites users to activate API versioning by reaching out to us:
- Contact for Access: Send an email to hello@theneo.io expressing your interest in enabling API versioning for your account.
Utilizing the Versioning Feature
Once API versioning is enabled for your account, you can:
- 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.
- Import Specs: Use the intuitive interface to upload file, link, import from Postman, or input raw text for your API specs.
- Manage Versions: Navigate to the settings menu to manage features, access permissions, SEO optimization, and analytics for each API version.
- Set Version Status: Define the lifecycle stage of each API version with appropriate status labels directly from the project versions screen.
Quick Video Guide
Contact Us
For more information on API versioning and to request access to this beta feature, please contact us at hello@theneo.io. We are committed to supporting you in leveraging this feature to its full potential, ensuring effective management of your API's lifecycle.
Theneo Documentation
A project in Theneo is a robust toolset that allows you to create and manage a wide array of technical content. This can range from API references, SDK documentation, product guides, and much more. Theneo provides an easy and streamlined way to generate API documentation from API collections, allowing you to focus on delivering high-quality, accurate, and up-to-date content.
To create your first project with Theneo:
- Navigate to your dashboard and click on the "Create Project" button.
- Fill in your desired project name in the prompt that appears.
- If you have an API collection at hand, upload it. Theneo accommodates various API types, including REST, GraphQL, AsyncAPI, SOAP, and more.
- Two options await you: "Quickstart" for an instant project creation or "Customize" for a more tailored approach. If you choose the latter, you'll be seamlessly redirected to our AI writer tool.
- The AI writer tool empowers you to fully automate or enhance your project descriptions based on the content of your uploaded API spec. You can opt for complete AI assistance, enhancing only the missing descriptions while retaining your existing content, or skipping AI assistance altogether.
- The final leg of the project creation journey leads you to access control settings. Here, you can fine-tune project access management, invite members as viewers or editors, and put the finishing touches on your project setup.
Editing the generated content or adding new content is a breeze, thanks to Theneo’s intuitive, Notion-like editor. You can easily tweak API requests, methods, properties, descriptions, responses, and much more.
Publishing your First Project
Once you're satisfied with your API reference, the next step is to publish your project. However, it's always a good practice to preview your changes before hitting the publish button.
Here's how you can preview, publish, and share your project:
- Previewing Your Project: From the editor, click on the "Preview" button to see a live view of your changes. Review the content and layout to ensure it matches your expectations. If you need to make further changes, simply click "Back to Editor."
- Publishing Your Project: If you're happy with the preview, click the "Publish" button. Your project is now live and can be viewed by others, depending on the permissions you've set.
Web Editor Widgets
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:
FAQ
What made this section unhelpful for you?
Card
Encapsulate content within a styled container for emphasis or organization.

Card Title
This is how the card widget appears, with an icon, title and link. Clicking on this card will take you to the Image & Video section.
How to Add the Card Widget:
Content Addition
- Users can add brief description to the card.
- The content support all styling options, such as text formatting (bold, italics, bullet points, etc.).
Add Link
- The entire card widget is clickable.
- Users can add a URL to the card, making the whole card act as a hyperlink. The insert link option is available in the three-dot menu.
Icons
- Users can add icons to the card to enhance visual appeal.
- Three options are available:
- Emojis
- Suggested icons
- Option to upload custom icons
Duplicate Card
- Users have the option to duplicate the entire card along with its content via the three-dot menu.
- The duplicated card will maintain all the properties of the original card.
Delete Card
- Users can delete the card through the three-dot menu.
What made this section unhelpful for you?
Card groups
We offer various card groups
Card group 2 columns
Card Title
Add description here
Card Title
Add description here
Card group 3 columns
Card Title
Add description here
Card Title
Add description here
Card Title
Add description here
Card group 4 columns
Card Title
Add description here
Card Title
Add description here
Card Title
Add description here
Card Title
Add description here
What made this section unhelpful for you?
Steps
The Steps widget allows users to create a structured sequence of steps, making it easier to outline processes or instructions in a clear, step-by-step format.
Benefits of Using the Steps Widget
- Clarity and Structure: The Steps widget organizes information in a way that is easy to follow, helping users understand complex processes or instructions.
- Multimedia Support: Each step can include various types of content, such as images, videos, and tables.
- Flexibility: Users can add, delete, and duplicate steps as needed, allowing for easy adjustments to content.
- Highlight Important Information: The option to add callouts and dividers helps emphasize critical points, ensuring that essential details are not overlooked.
How to Add a Steps Widget
Default State
When the Steps widget is first added, only the first step appears by default. A "+" icon will be visible, allowing you to add additional steps easily.
Step Management
The Steps widget offers flexible management options, allowing users to customize each step with titles, multimedia content, and easy-to-use tools for organizing and editing steps efficiently.
Add Title
- Each step has the option to add a title, providing a brief description or heading for that step.
Content Addition
Users can add various types of content to each step, including:
- Basic Text Content: Support for basic text formatting (bold, italics, bullet points, etc.).
- Callout: Add a callout box to highlight important information within a step.
- Table: Insert a table for structured data.
- Image: Upload or insert images to illustrate the step.
- Video: Embed video content relevant to the step.
- Code Block: Add code blocks with syntax highlighting for technical instructions.
- Card: Encapsulate content within a styled container for emphasis or organization.
- Divider: Insert a horizontal divider to visually separate content within the step.
Step Navigation and Editing
- Add Step: Click the "+" icon to add a new step below the existing steps.
- Delete Step:
- An option to delete an individual step will be displayed as a trash icon on hover above each step's number.
- You can also delete a step using the keyboard: select the entire step you want to delete and press the Delete key.
- Delete Widget: Users can delete the entire Steps widget, which will remove all steps and their content from the document.
- Duplicate Widget: Easily duplicate the entire Steps widget to reuse content or create a similar sequence of steps.
What made this section unhelpful for you?
Divider
The Divider widget in Theneo's web editor is a straightforward yet powerful tool for organizing your documentation. By inserting a visual line break, the Divider creates clear separation between sections, making your content easier to navigate and digest for the reader. It's an essential element for maintaining a clean and structured look in your documents.
To add a Divider in Theneo's web editor:
- Navigate to the point in your text where you want to insert a break.
- Type
/divider
on a new line. - Select the Divider option that appears.
The result is a horizontal line, as shown in your example, that neatly segments your content. This can be particularly useful for distinguishing between different topics, API endpoints, or logical sections within your documentation, ensuring that readers can easily follow along and find the information they need.
What made this section unhelpful for you?
Callout
The Callout widget in Theneo's web editor serves as a great way to draw attention to specific pieces of information within your documentation. By providing visual cues, callouts can indicate important details, success messages, warnings, or errors, making them stand out from the rest of the text.
Here's how to use the Callout widget:
- Click into the editor at the point where you want to insert a callout.
- Type
/callout
to bring up the widget selection. - Choose from one of the callout options: Info, Success, Warning, or Error.
Each callout type is color-coded and comes with an icon to quickly convey the message's nature:
All of the Callout elements can be branded in our branding configuration
What made this section unhelpful for you?
Table
The Table widget in Theneo's web editor is a straightforward and effective way to organize and present data in a tabular format. Tables are essential for displaying structured data, comparison charts, specifications, and more, making complex information easy to digest.
Here's how to insert a table into your documentation:
- Position your cursor in the editor where you want the table to be.
- Type
/table
on a new line to bring up the widget menu. - Select the Table widget.
Once you've inserted a table, you can:
- Add or remove columns and rows to suit your data.
- Click into any cell to start typing your content.
- Use the toolbar options to format text within the table, align content, or add/remove additional rows and columns.
Authentication | Secure user login with OAuth2.0 | Yes |
Rate Limiting | Limits the number of requests per hour | Yes |
Data Export | Ability to export data in various formats | No |
Real-time Updates | Provides live updates without refreshing | Yes |
Multi-Language Support | Documentation available in multiple languages | Coming Soon |
The simplicity of the Table widget ensures that your data is presented cleanly and clearly, with no distractions, allowing readers to focus on the content itself. Whether you're summarizing endpoint parameters, listing error codes, or comparing different API versions, the table is an invaluable tool for your documentation needs.
What made this section unhelpful for you?
Image & Video
The Image & Video widgets in Theneo's web editor allow you to seamlessly integrate multimedia elements into your API documentation.
Image Widget
To add an image:
- Place your cursor in the editor where you want the image to appear.
- Type
/image
to activate the widget menu. - Choose to upload your image file directly or insert it via URL.

Video Widget
To add a video:
- Place your cursor in the editor where you want the video to appear.
- Type
/video
to activate the widget menu. - Paste the URL of the video you wish to embed. The editor typically supports video content from major hosting platforms such as YouTube and Vimeo.
What made this section unhelpful for you?
Code Blocks
The Theneo web editor's Code Block widget allows you to easily insert code snippets into your documentation. Syntax highlighting is supported for a wide range of programming languages, making your code snippets clear and easy to understand.
To insert a code snippet:
- Navigate to a new line in the Theneo web editor where you want the code block to appear.
- Type
/code
to trigger the widget selection menu. - Choose 'Code Block' from the list of widgets.
- Select the programming language from the drop-down menu to apply syntax highlighting.
- Paste or type your code into the code block.
Here's an example of a formatted code snippet in JavaScript:
// Theneo API Magic Elixir Mixerfunction createElixir(elixirName, ingredients) {
console.log(Creating ${elixirName} Elixir with the following ingredients:);
ingredients.forEach((ingredient, index) => {
console.log(${index + 1}. ${ingredient});
});
console.log(${elixirName} Elixir is ready to empower your API!);
}// Mix a 'Restful Rejuvenation' elixir for your API
createElixir('Restful Rejuvenation', ['REST', 'JSON', 'OAuth 2.0', 'CORS']);
What made this section unhelpful for you?
Object example
The Object Example widget in Theneo's web editor is a versatile tool that enhances the documentation of API objects. It provides a structured and interactive way to present and explain the different components of an API object. Here's how you can use this widget effectively:
Adding an Object Example
- Position your cursor where you want to insert the object example in your documentation.
- Type
/object example
to bring up the widget menu and select the Object Example widget. - A new tab will be created where you can define your object example.
Working with Object Examples
- Code View: This view allows you to input raw JSON or other supported formats directly. The editor will parse and display the data in an organized and readable format.
- Form View: Here, you can add more detailed information about each field of your object, such as whether the field is required, provide descriptions, and set additional properties like minimum or maximum values.
Managing Multiple Object Examples
- You can create multiple tabs for different object examples as needed, allowing you to document various objects within the same context.
- Switch between tabs to manage or view different examples.
Supported Languages
The Object Example widget supports the same languages as the code block highlight feature, providing consistency in how code and objects are presented throughout your documentation.
Extended Use Case
This widget is just another way Theneo empowers you to create comprehensive and user-friendly documentation, making complex API objects understandable at a glance.
Customer Object Demo
Unique identifier for the object.
String representing the object’s type. Objects of the same type share the same value.
The customer’s address.
The current balance, if any, that’s stored on the customer. If negative, the customer has credit to apply to their next invoice. If positive, the customer has an amount owed that’s added to their next invoice. The balance only considers amounts that Stripe hasn’t successfully applied to any invoice. It doesn’t reflect unpaid invoices. This balance is only taken into account after invoices finalize.
Time at which the object was created. Measured in seconds since the Unix epoch.
Three-letter ISO code for the currency the customer can be charged in for recurring billing purposes.
ID of the default payment source for the customer.
Tracks the most recent state change on any invoice belonging to the customer. Paying an invoice or marking it uncollectible via the API will set this field to false. An automatic payment failure or passing the invoice.due_date will set this field to true.
Describes the current discount active on the customer, if there is one.
The customer’s email address.
Show child attributes
What made this section unhelpful for you?
Error codes
The Error Codes widget in Theneo's web editor is a specialized tool for documenting the different types of errors that can occur while using an API. This widget helps to organize and present error information clearly, so developers and users can quickly understand and troubleshoot issues when they arise. Here's how you can effectively use this widget:
Utilizing the Error Codes Widget
- Insert the Widget: Go to the desired section in your document, start a new line, type
/error codes
, and select the Error Codes widget from the dropdown. - Add Error Details: For each error, click on the
Add
button to create a new entry. Fill in the details such as:- The type of error (e.g.,
authentication_error
,rate_limit_error
, etc.) - A concise yet comprehensive description that explains when this error might be encountered.
- Reorder Errors: If you want to prioritize certain errors or arrange them in a particular order, use the up and down arrows to move them within the list.
- Edit or Delete Errors: Should you need to update an error's details or remove it from your documentation, click on the edit icon to modify the information or the trash can icon to delete the entry.
- Clarity and Actionability: Ensure that each error type has a clear name and description. Where applicable, provide actionable steps users can take to resolve the error.
Remember, the Error Codes widget is designed to help users understand specific errors related to your API's functionality, separate from the general HTTP status codes which are managed with the Status Codes widget. Using this widget enhances the usability of your API documentation by making error handling clearer and more accessible.
What made this section unhelpful for you?
Error Codes
api_connection_error
Failure to connect to API.
api_error
API errors cover any other type of problem (e.g., a temporary problem with servers), and are extremely uncommon.
authentication_error
Failure to properly authenticate yourself in the request.
card_error
Card errors are the most common type of error you should expect to handle. They result when the user enters a card that can't be charged for some reason.
idempotency_error
Idempotency errors occur when an Idempotency-Key is re-used on a request that does not match the first request's API endpoint and parameters.
invalid_request_error
Invalid request errors arise when your request has invalid parameters.
rate_limit_error
Too many requests hit the API too quickly.
validation_error
Errors triggered by our client-side libraries when failing to validate fields (e.g., when a card number or expiration date is invalid or incomplete).
Status codes
The Status Codes widget in Theneo's web editor is a feature that allows you to document the HTTP status codes that your API might return. This helps users understand the responses they receive from your API. Here's a guide to using this widget effectively:
- Insert the Widget: Navigate to the section in your documentation where you want to list the status codes. Start a new line, type
/status codes
, and select the Status Codes widget from the dropdown menu. - Add Status Codes: Use the
Add
button to insert new entries for each status code your API uses. For each status code, provide:- The status code number (e.g.,
200
,400
,404
, etc.). - A brief title for the status code (e.g.,
OK
,Bad Request
,Not Found
). - A clear description explaining when this status code is returned and what it signifies.
- Utilize the Library: As you type the status code, you'll notice that Theneo's library suggests existing status codes as a reference. This helps maintain consistency and accuracy in your documentation.
- Organize and Edit: You can reorder the status codes using the up and down arrows to match the flow of your documentation or delete any unnecessary status code entries using the trash icon.
- Completeness: Ensure you document all status codes that your API might return, including success and error responses, to provide comprehensive documentation.
What made this section unhelpful for you?
Status Codes
200
Everything worked as expected.
300
Multiple choice
400
The request was unacceptable, often due to missing a required parameter.
401
The request was unacceptable, often due to missing a required parameter.
402
The parameters were valid but the request failed.
403
The API key doesnt have permissions to perform the request.
404
The requested resource does not exist.
500
Internal Server error
Base URL
The Base URL widget is a crucial element in Theneo's web editor, enabling you to clearly specify the root URL(s) for API requests. Here's how to use it:
- Insert the Widget: In your documentation, navigate to the place where you want to mention the base URL. On a new line, type
/base url
and select the Base URL widget from the dropdown. - Edit Base URL: To edit the base URL, click the edit icon in the base URL widget or open the More Actions menu in the API Management widget and select the Base URL configuration option. A dialog box will appear, allowing you to add or modify URLs for different environments, such as Production and Sandbox.
- Save Environment URLs: Enter the title for each environment and the corresponding URL. For example, you could have "Production" with the URL
http://api.example.com
and "Sandbox" with the URLhttp://sandbox.api.example.com
. - Automatic Updates: Once you save your base URLs, they will be dynamically updated across all sections of your documentation. If you adjust the base URL, the changes will reflect throughout the documentation without the need for manual updates in each section.
- API Explorer Synchronization: The base URL also synchronizes with the API explorer, allowing users to switch between environments like Sandbox and Production effortlessly while trying out API calls.
Managing Base URLs
Default Setup
By default, your documentation includes a Production environment with a sample base URL:
http://example.io
.
Adding Multiple Base URLs
You can enhance your documentation by configuring multiple base URLs within the same environment. For instance, under the Production environment, you can define two distinct base URLs such as http://example.io
and http://example.prod.io
. Follow these steps to add and customize base URLs:
Managing Environments
Adding New Environments
You can create unlimited environments tailored to your API needs, such as “Sandbox,” “Testing,” or “Staging.” Here’s how to define multiple environments:
Customizing Environment Settings
Each environment can have its own set of base URLs and configurations, allowing you to align them with your development, staging, or production workflows.
Benefits of Configuring Base URLs and Environments
- Flexibility to manage multiple base URLs under a single environment.
- Seamless switching between environments for different stages of API development.
- Centralized configuration improves collaboration and consistency across your documentation.
- Updates are instantly reflected in both the editor and published documentation, ensuring accuracy.
FAQ:
- Can I edit the name of the environment? Yes, you can. By default, sample environment names are provided, but you have the flexibility to update and customize them to suit your preferences.
- Will I need to update the base URL in every section if it changes? No, once you update the base URL in the widget, it will automatically reflect across all sections of your documentation, saving you time and ensuring consistency.
What made this section unhelpful for you?
Base URL
Production:
http://example.io
Sandbox:
http://example-sandbox.io
Language box
The Language Box widget in Theneo's web editor serves as a quick reference for users to identify which client libraries and programming languages are supported by your API. It enhances user experience by allowing them to switch between different languages and view the corresponding API requests.
How to Use the Language Box Widget
- Insert the Widget: Place the Language Box widget in your documentation wherever you want to display the supported languages. Typically, it's positioned at the top of your API reference.
- Showcase Client Libraries: The widget displays icons for each supported language like cURL, Ruby, Python, PHP, Java, Node.js, Go, and .NET.
- Interactive Language Switching: Users can click on any language icon, and the API requests throughout the documentation will automatically update to show code snippets in the selected language.
- Custom Placement: While the Language Box is automatically included in the API reference, you can choose to add or remove it from other sections as needed.
FAQ
- Can I remove any of the default languages from the Language Box? Currently, you cannot remove the default languages provided in the Language Box. However, we plan to offer more customization options in the future.
- Can I add my own SDK to the Language Box? Yes, with our business package, you have the capability to import and showcase your own SDK in the Language Box. For detailed instructions and more information on how to do this, please contact our support team at hello@theneo.io
What made this section unhelpful for you?
Reuse content
The Reuse Content feature in the Theneo editor empowers users to efficiently duplicate sections and their content across multiple projects within a workspace. This streamlined approach eliminates the need for repetitive manual effort, ensuring consistency and saving valuable time.
Where to Find the Reuse Content Option
In the section menu of the Theneo editor, navigate to the section's More Actions menu. You will find the Reuse Content option listed among the available actions.
How to Use the Reuse Content Feature
Key Benefits
- Efficiency: Eliminate the need for manual duplication of content.
- Consistency: Ensure the same content is available across multiple projects without discrepancies.
- Flexibility: Duplicate content to one or several projects with ease.
Best Practices
- Verify Access: Ensure you have editor access to all the projects you want to duplicate content to.
- Plan Ahead: Use the feature for sections that are commonly reused, such as standard terms, shared API documentation, or branding guidelines.
- Review Before Saving: Double-check the selected projects before saving to avoid unintentional duplication.
The Reuse Content feature is designed to help teams collaborate more effectively and maintain consistency across projects. Whether you’re managing multiple documentation projects or working with distributed teams, this feature simplifies content reuse in a seamless and intuitive way.
What made this section unhelpful for you?
API Management
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
- 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. - 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
- 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.
- Add Response Codes: By default, a 200 OK response is included. Add other response codes by clicking the + icon.
- Detail the Response:
- Form View: Add descriptions and structure the returned data.
- Code View: Paste in JSON or other formatted responses, and the widget will parse them for easy reading.
- 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.
For a demo purposes you can see how we auto populate fields (below) and API request and response (on the right side)
Header Parameters
The authorization token required for accessing the API endpoint.
Body Parameters
The name of the project being created or updated.
The type of project being created, such as 'web development', 'app development', or 'design'.
The name of the project owner who is responsible for the project.
Responses
Response Attributes
Show child attributes
Response Attributes
Show child attributes
Response Attributes
What made this section unhelpful for you?
Response
{
"id": "cus_NffrFeUfNV2Hib",
"created": 1680893993,
"description": null,
"email": "jennyrosen@example.com",
"invoice_prefix": "0759376C",
"invoice_settings": {
"custom_fields": null,
"default_payment_method": null,
"footer": null,
"rendering_options": null
},
"next_invoice_sequence": 1,
"phone": null
}
Live Collaboration
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
- 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.
- 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.
- 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.
- 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.
What made this section unhelpful for you?
Preview Changes
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
- 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.
- 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.
- 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.
What made this section unhelpful for you?
Github Actions
Step 1: Create Theneo Documentation
Begin by creating a documentation project within Theneo to house your API details.
Step 2: 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:
name: Update Documentationon: pull_request: branches: - mainjobs: 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
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 isgithub-demo
.
Use this project slug for the PROJECT_SLUG
variable in your GitHub workflow.
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 includeoverwrite
,merge
, andendpoints
.AUTO_PUBLISH
: If set totrue
, Theneo will automatically publish the changes. Iffalse
, 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.
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.
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.
What made this section unhelpful for you?
Visual Studio Code Extension
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 the Theneo VS Code Extension
Configure the Extension:
- After installation, sign in to your Theneo account at app.theneo.io
- Once signed in, navigate to your profile settings.
- Within your profile settings, locate and select the "Tools & Integrations" section.
- In the "Tools & Integrations" section, find and copy your Theneo API key.
- In VS Code Extension open the command palette by pressing
Ctrl+Shift+P
(orCmd+Shift+P
on Mac). - Type 'Preferences: Open Settings (UI)' and select it.
- Search for Theneo Markdown in the “Extensions” section
- 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
- Open the command palette by pressing Ctrl+Shift+P (or Cmd+Shift+P on Mac).
- Search for “Theneo: Export Project from Theneo”.
- Select the project from your list of published projects created in Theneo.
- Enter a parent directory to export the project and press enter.
Import Project to Theneo
- Open the command palette by pressing Ctrl+Shift+P (or Cmd+Shift+P on Mac).
- Search for “Theneo: Import Project To Theneo”.
- Enter project name after “/”. example
/project
- Choose if you want to publish the document.
Merge Project to Theneo
- Open the command palette by pressing Ctrl+Shift+P (or Cmd+Shift+P on Mac).
- Search for "Theneo: Merge Project To Theneo".
- Copy the relative path to the section that you want to merge.
- Pick the project you are merging with (usually the same project as you exported).
- Go over the changes and press commit merge button.
Open Preview
- Open the command palette by pressing Ctrl+Shift+P (or Cmd+Shift+P on Mac).
- Search for “Theneo: Open Current Project Preview”.
- 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.
What made this section unhelpful for you?
Theneo CLI
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
1. Logging In
Standard Login:
theneo login
Login with an API Key:
theneo login --token <theneo-api-key>
You can also set the THENEO_API_KEY
environment variable.
2. Creating a New Project
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
Standard Project Creation:
theneo project create
Creating a Project with an API Spec File:
theneo project create --name api-documentation --generate-description overwrite --publish --public --file ./examples/openapi-spec.json
Creating a Project Using a Link to API Documentation:
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
Creating a Project from Postman Collections:
theneo project create --name api-documentation --postman-api-key <key> --postman-collection <id-1> --postman-collection <id-2>
3. Updating API Documentation from an API Spec File
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
Updating a Project:
theneo project import --file <file> --project <project-slug> --publish
Import with merge option
theneo project import --project <project-slug> \
--workspace <workspace-slug> \
--projectVersion <version-slug> \
--publish \
--file ./api-spec.json \
--import-type merge \
--keepOldParameterDescription \
--keepOldSectionDescription
4. Publishing Documentation
theneo project publish --project <project-slug>
5. Deleting a Project
theneo project delete --project <project-slug>
6. Project Version
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
7. Create Version
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
8. Add ChangeLog subscriber
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
Use the main branch changes
Clone the repository
git clone git@github.com:Theneo-Inc/theneo-tools.git
Install packages
nvm use npm install
Install the CLI
npm run cli
Run the CLI
theneo help
Change theneo API endpoint
- Using environment variable
THENEO_API_KEY=<theneo-api-key> THENEO_API_URL=https://api.theneo.io THENEO_APP_URL=https://app.theneo.io \theneo <command>
- Using theneo config file and profile
theneo login --profile <profile-name> --token <theneo-api-key> --api-url https://api.theneo.io --app-url https://app.theneo.io
check the config file at .config/theneo/config
9. Export project data in Markdown format - Beta
Usage: theneo export [options]
Options:
--project <project-slug> project slug
--projectVersion <version-slug> Version slug
--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.
--dir <directory> directory location where the project will be exported (default: "docs")
--publishedView By default it will export data from editor, pass this flag to get published project data (default: false)
-h, --help display help for command
10. 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 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
11. Exporting 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
You can use the same exporting options as in the regular export command.
12. 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
theneo create --dir <directory> --name <project-name>
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.
What made this section unhelpful for you?
Theneo SDK
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 optionsconst options: TheneoOptions = { apiKey: "YOUR_API_KEY"};// Create a Theneo instanceconst theneo = new Theneo(options);// Example usageasync 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 projectasync 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 neededlistWorkspaces();createProject();
Import api document
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 optionsconst options: TheneoOptions = { apiKey: "YOUR_API_KEY"};// Create a Theneo instanceconst theneo = new Theneo(options);// Define the import optionsconst 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 projectasync 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 functionimportApiDocumentation();
In this example:
- We first create an instance of the
Theneo
class and provide the necessary API key in theoptions
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 ofimportOptions
, you can specify the source of the API documentation to be imported. You can choose one of the four options:- Import from a file (specify the file path).
- Import from a URL (specify the URL).
- Import from a text string (specify the content as a string).
- Import from a Postman collection (specify the Postman API key and collection IDs).
- The
publish
option is set totrue
to indicate that the imported data should be published. - The
importApiDocumentation
function uses theimportProjectDocument
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.
TheneoOptions (Interface)
Options for initializing the Theneo SDK.
apiKey?: string
: API key for the Theneo application.apiClientName?: string
: Name of the client making the API call (default istheneo-sdk:${SDK_VERSION}
).baseApiUrl?: string
: Theneo API URL.baseAppUrl?: string
: Theneo APP URL.
Theneo (Class)
The main class for interacting with the Theneo API.
Methods
listWorkspaces(role?: UserRole): Promise<Result<Workspace[]>>
: Lists workspaces available for a user.listProjects(): Promise<Result<ProjectSchema[]>>
: Lists user projects.deleteProjectById(projectId: string): Promise<Result<void>>
: Deletes a project by ID.publishProject(projectId: string): Promise<Result<PublishProjectResponse>>
: Publishes API documentation for a project.getPreviewProjectLink(projectId: string): string
returns preview link for a project.importProjectDocument(options: ImportProjectOptions): Promise<Result<ImportResponse>>
: Imports API documentation to an existing project.createProject(options: CreateProjectOptions): Promise<Result<CreateProjectResponse>>
: Creates a new project on the Theneo platform.getDescriptionGenerationStatus(projectId: string): Promise<Result<ProjectCreationStatusResponse, Error>>
: Gets the description generation status for a project.waitForDescriptionGeneration(projectId: string, progressUpdateHandler?: DescriptionGenerationProgressHandler, retryTime?: number, maxWaitTime?: number): Promise<Result<never>>
: Waits for description generation to finish.static listPostmanCollections(postmanApiKey: string): Promise<Result<PostmanCollection[]>>
: Returns list of Postman Collections using the api key
DescriptionGenerationType (Enum)
An enum representing different types of description generation options.
FILL
: Generate descriptions for parameters that do not have descriptions already.OVERWRITE
: Overwrite descriptions for parameters that do not have descriptions already.NO_GENERATION
: Do not generate descriptions for parameters that do not have descriptions already.
DescriptionGenerationProgressHandler (Type)
A callback function type that receives the progress percentage of description generation.
PostmanImportOptions (Interface)
Options for importing Postman collections.
apiKey: string
: Postman API key.collectionId: string[]
: Postman collection IDs to be imported.
WorkspaceOption (Interface)
Workspace options for creating a project.
key?: string
: Workspace key.id?: string
: Workspace ID.
ApiDataInputOption (Interface)
Data input options for creating a project. Specify only one of the following attributes.
file?: fs.PathLike
: Path to a file containing API documentation.link?: URL
: URL to a file containing API documentation.text?: string
: API documentation as a string.postman?: PostmanImportOptions
: Postman collection to create the project from.
CreateProjectOptions (Interface)
Options for creating a project.
name: string
: Project name.workspace?: WorkspaceOption
: Workspace where to create the project (default is the user's default workspace).publish?: boolean
: Indicates if the project should be published after creation (default isfalse
).isPublic?: boolean
: Indicates if the project is public (default isfalse
).data?: ApiDataInputOption
: API documentation data for creating the project.sampleData?: boolean
: Indicates if the project should be created with sample data.descriptionGenerationType?: DescriptionGenerationType
: Description generation type.progressUpdateHandler?: DescriptionGenerationProgressHandler
: Callback for description generation progress.
ImportOption (Enum)
An enum representing different options for importing API specifications.
ENDPOINTS_ONLY
: Import only the endpoints.OVERWRITE
: Overwrite existing data.MERGE
: Merge with existing data.
ImportProjectOptions (Interface)
Options for importing API documentation to an existing project.
projectId: string
: Project ID.publish: boolean
: Indicates if the imported data should be published.data: ApiDataInputOption
: API documentation data for importing.importOption?: ImportOption
: Import option.
PublishProjectResponse (Interface)
A response object after publishing a project.
projectKey: string
: Project key.baseUrlRequired: boolean
: Indicates if a base URL is required.companySlug: string
: Company slug.publishedPageUrl: string
: URL of the published page.
CompanySchema (Interface)
A schema representing company information.
id: string
: Company ID.name: string
: Company name.slug: string
: Company slug.corporateId: string
: Corporate ID.createdAt: Date
: Creation date.updatedAt: Date
: Last updated date.createdBy: string
: Created by user.
ProjectSchema (Interface)
A schema representing project information.
id: string
: Project ID.name: string
: Project name.key: string
: Project key.isPublic: boolean
: Indicates if the project is public.companyId: string
: Company ID.createdAt: Date
: Creation date.company: CompanySchema
: Company information.
CreateOtherTypeOfDocOptions (Interface)
Options for creating other types of documentation.
docType: string
: The type of documentation.gettingStartedSections?: { introduction: boolean; prerequisites: boolean; quickStart: boolean; resources: boolean; }
: Sections for getting started documentation.sdk?: { overview: boolean; supportedLibraries: boolean; sampleCode: boolean; troubleshooting: boolean; }
: SDK documentation sections.faq?: { generalInfo: boolean; authentication: boolean; usage: boolean; billing: boolean; }
: FAQ sections.
CreatedProjectStatusEnum (Enum)
An enum representing different statuses for a created project.
CREATED
: Project creation completed successfully.STARTED
: Project creation is in progress.FINISHED
: Project creation finished successfully.ERROR
: Project creation encountered an error.CREATED_WITHOUT_AI_GENERATION
: Project created without AI generation.
CreateProjectResponse (Interface)
A response object after creating a project.
projectId: string
: Project ID.publishData?: PublishProjectResponse
: Information about the published project.
ProjectCreationStatusResponse (Interface)
A response object containing information about the status of project creation.
name: string
: Project name.key: string
: Project key.creationStatus: CreatedProjectStatusEnum
: Creation status.descriptionGenerationProgress: number
: Progress of description generation in percentage.updatedAt: string
: Last updated date.
ImportResponse (Interface)
A response object after importing a project.
collectionId: string
: Collection ID.publishData?: PublishProjectResponse
: Information about the published project.
UserRole (Enum)
An enum representing different user roles.
ADMIN
: Administrator.EDITOR
: Editor.
Workspace (Interface)
Workspace information.
workspaceId: string
: Workspace ID.name: string
: Workspace name.slug: string
: Workspace slug/key.role: UserRole
: Workspace role.isDefault: boolean
: Indicates if the workspace is the default workspace.isCorporate: boolean
: Indicates if the workspace is corporate.isSubscribed: boolean
: Indicates if the workspace is subscribed.
ResultImp (Abstract Class)
An abstract class representing the result of an operation that can either succeed with a value of type T
or fail with an error of type E
.
Methods
unwrap(): T
: Unwraps the successful result value. If the result is an error, this method will throw an exception.unwrap<U>(ok: (value: T) => U): U
: Unwraps the successful result value and applies a function to it.unwrap<U, V>(ok: (value: T) => U, err: (error: E) => V): U | V
: Unwraps the result value and applies functions based on whether it's a success or an error.unwrap<U>(ok: (value: T) => U, err: (error: E) => U): U
: Unwraps the result value and applies a function based on whether it's a success or an error.map<U>(ok: (value: T) => U): Result<U, E>
: Transforms a successful result into a new result with a different value type.map<U, F extends Error>(ok: (value: T) => U, err: (error: E) => F): Result<U, F>
: Transforms a result into a new result with different value and error types.chain<X>(ok: (value: T) => Result<X, E>): Result<X, E>
: Chains a function that produces a new result based on the success value.chain<X>(ok: (value: T) => Result<X, E>, err: (error: E) => Result<X, E>): Result<X, E>
: Chains functions for both success and error cases.chain<X, U extends Error>(ok: (value: T) => Result<X, U>, err: (error: E) => Result<X, U>): Result<X, U>
: Chains functions with different error types.
OkResult (Class)
A class representing a successful result.
Properties
value: T
: The successful value.
ErrResult (Class)
A class representing an error result.
Properties
error: E
: The error object.
Ok(value: T): Result(Function)
A function for creating a successful result.
value: T
: The value to wrap in the result.
Err(error?: E): Result (Function)
A function for creating an error result.
error?: E
: An optional error object.
ResponseSchema (Interface)
An interface representing the schema of a response object.
data: T
: The data payload of the response.message: string
: A message associated with the response.
What made this section unhelpful for you?
Bitbucket
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.
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.
codescript: - pipe: theneo1/theneo-pipeline:0.2.1 variables: API_DOCUMENT_PATH: "path/to/api/spec.yaml" THENEO_PROJECT_KEY: "your-project-slug" THENEO_API_KEY: "your-api-key"
Variables for Bitbucket Pipeline:
API_DOCUMENT_PATH
: The path to your API spec within your repository.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 ishttps://app.theneo.io/theneo/bitbucket-demo
, thebitbucket-demo
is your project slug.THENEO_API_KEY
: Your Theneo API key, which you can generate from the Theneo website.
Prerequisites for Bitbucket Integration
- An established API documentation project on Theneo.
- A generated API key from your Theneo account.
- 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.
AI Co-pilot & Chat
Theneo's AI CoPilot revolutionizes the way API documentation is created by automating the generation and enhancement of content. With options for full AI assistance, enhancing existing content, or opting out, it provides a flexible approach to building comprehensive documentation. The AI CoPilot functions as an expert technical writer, offering precise descriptions for parameters, ensuring consistency and reducing manual effort.
The integration of ChatGPT brings interactive, conversational AI to Theneo's documentation, allowing users to ask questions directly within the docs. This feature, powered by the sophisticated GPT-4 turbo, is easily enabled in settings and offers users instant, contextual answers to both technical and business inquiries, elevating the documentation's utility and user engagement.
Together, Theneo's AI CoPilot and ChatGPT integration deliver a dynamic duo of content generation and user interaction, simplifying the documentation process and enhancing the end-user experience.
Branding & Styling
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 include:
- 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.
Developer Portal
A Developer Portal, also known as a Developer Hub, is a centralized platform designed to facilitate and manage the interaction between an organization and its developer community. It serves as a comprehensive resource for all things related to an organization's APIs or development tools, providing necessary documentation, API keys, resources, support, and community discussions.

Key features of Theneo's Developer Portal include:
- Customization: Users can select from professional templates or import their own designs, ensuring the portal aligns with the brand's visual identity.
- API Showcasing: The platform allows for a prominent display of API references, enabling users to easily discover and comprehend the available APIs.
- SDKs and Guides Documentation: Beyond APIs, Theneo supports documentation for SDKs and guides, creating a holistic resource for developers.
- Interactive AI Chat & API Explorer: Theneo integrates a GPT-4 powered AI Chat for instant smart responses and an interactive API Explorer for an immersive user experience.
- Content-Rich Portals: Users can augment their developer portal with additional resources like guides, blog posts, and linked content, providing a richer experience.
- Flexibility and Control: Import your own code and designs with complete freedom to customize your portal to your specifications.
Workspaces & Project Management
What are Workspaces?
Workspaces in Theneo are distinct areas within the platform designed to manage different projects or teams under one umbrella organization. They serve as separate containers that allow for distinct management of APIs, documentation, and team access. Each workspace can have its own branding, permissions, and configurations, making it an ideal solution for companies with multiple products or teams.
Benefits of Using Workspaces:
- Team Management:
- Allocate specific workspaces to different teams within the organization.
- Set permissions and roles to control access and maintain security.
- Brand Consistency:
- Customize branding for each workspace to align with the product or team identity.
- Manage multiple branding configurations without affecting other workspaces.
- Organized Documentation:
- Keep documentation for different products or APIs separate and organized.
- Provide tailored information relevant to the users of each workspace.
- Targeted Landing Pages:
- Design and use different landing pages for each workspace to cater to the specific audience or user base.
- Enhance user experience by directing them to the relevant workspace right from the start.
When are Multiple Workspaces Relevant?
- Multiple Products: If your company offers a range of products, each with its own set of APIs and documentation, separate workspaces allow for tailored content management without overlap.
- Distinct Branding: Companies that operate different brands under one corporation can use workspaces to manage and present APIs in line with each brand’s guidelines.
- Team-Specific Access: For organizations with several engineering teams, each responsible for different APIs, workspaces provide a way to segment API ownership and control who has access to what.
- Project Phases: During different stages of development, such as testing and production, workspaces can be used to segregate and manage these environments effectively.
Implementing Workspaces:
- Setup: Administrators can create and configure workspaces from the Theneo dashboard.
- Customization: Each workspace can be customized with its own branding and landing pages.
- Access Control: Assign team members to workspaces and define their roles and permissions.
- Content Management: Develop and maintain API documentation that's specific to the needs of each workspace.
In summary, workspaces in Theneo provide a powerful means to segment and manage your API documentation and teams. They offer the flexibility to support multiple products, brands, and teams within a single platform, ensuring that each can operate with its required level of autonomy and specificity
Product & User Guides / Docs
Theneo's flexible documentation platform supports not only API documentation but also a wide variety of content types, including comprehensive user and product guides. This flexibility enables you to create rich, informative content tailored to your audience's needs, whether they are developers, product managers, or end-users.

Getting Started with Guides
- Initiate a New Project:
- Navigate to the "Create New Project" area.
- Select "Other documentation" to branch out beyond API docs.
- Choose a Template:
- Pick from a range of predefined templates like "Getting started guide", "SDK documentation", or "FAQ" for a quick start.
- Opt for a "Blank" template for full creative control from scratch.
- Customize Your Content:
- Use Theneo’s editor to add various content elements and structure your guide.
- Include text, images, videos, and more to make your guide engaging and helpful.
What made this section unhelpful for you?
FAQ
How do I delete parameter?
To delete a parameter, follow these steps:
- Switch to the code view mode in the widget.
- Select the parameter you wish to delete.
- Proceed with the deletion.
How can I delete my Theneo account?
To permanently remove your account and all associated data, please contact our support team directly at hello@theneo.io. A support representative will guide you through the secure account deletion process.
How can I create a workspace?
You can create a workspace in Theneo using one of the following methods:
If the corporate workspace toggle is enabled during sign-up, you can:
- Join an existing corporate workspace associated with your corporate domain.
- Create your own corporate workspace.
If the corporate workspace toggle is disabled during sign-up, you will automatically be added to your personal workspace upon account creation.
If you already have an account with a personal workspace, you can convert it to a corporate workspace:
- Go to user settings -> admin tab.
- Select "Convert as corporate" option.
- Name your workspace and confirm the conversion.
How can I link sections within my Theneo documentation?
Here's how to achieve this:
- Navigate to your published documentation and locate the section you want to link to.
- Copy the URL displayed in your web browser's address bar for that specific section.
Switch to the editor view within your Theneo project.
- Select the text you wish to convert into a hyperlink. This text will act as the clickable anchor point for your readers.
- Locate the "link" option within the Theneo editor's formatting tools.
- Paste the previously copied URL from step 1 into the designated field within the link creation menu.
- Confirm the link creation by clicking "Enter".
By following these steps, you've successfully established a hyperlink within your Theneo documentation, allowing readers to navigate seamlessly between different sections.
Can I update the auto-generated URL slug?
Here's how to update the URL slugs:
Project Slug:
- Access your project settings.
- Navigate to the "General" tab.
- Locate the project slug setting and click on the edit icon.
- Make your desired changes to the slug text.
- Save your adjustments.
Section Slug:
- Go to the "SEO management" section within your Theneo project.
- Identify the specific section you want to modify the slug for.
- Locate the edit option for the section's slug.
- Update the slug text according to your preference.
- Save your changes.
How do I restore my last published project?
Here's how to achieve this:
- Access Project History: Locate the top-right menu within the Theneo editor.
- Select Desired Version: Click on the "History" option within the menu. This will display a list of previous versions associated with your project.
- Identify and Restore: Find the version corresponding to your last published project. This can be identified by a timestamp. Once you've located it, click to restore.
How to download published document?
Downloading published document is currently available in our growth package, please contact our customer support directly at hello@theneo.io for an access.