# Tray Documentation

> Tray.ai is a low-code automation and integration platform with built-in AI orchestration. This index links to clean-markdown versions of every documentation page so LLM clients can fetch them directly without HTML chrome.

## API reference

- [Tray Platform OpenAPI spec](https://tray.ai/documentation/files/openapi/trayapi.yaml)
- [Tray Embedded OpenAPI spec](https://tray.ai/documentation/files/openapi/embeddedapi.yaml)

## URL patterns

- Per-page markdown: `https://tray.ai/documentation/{section}/{...slug}.md`
- Per-section bundle: `https://tray.ai/documentation/{section}/llms-full.txt` (concatenation of all pages in a section)
- Connector overviews: `https://tray.ai/documentation/connectors/{category}/{name}.md` (categories: `service`, `core`, `helper`, `artificial-intelligence`, `trigger`)
- Connector operations (runtime, dynamic): `https://tray.ai/documentation/connectors/{category}/{name}/operations.md`
- Full connector listing: [https://tray.ai/documentation/connectors/llms.txt](https://tray.ai/documentation/connectors/llms.txt)
- Release notes feed (current year + last year): `https://tray.ai/documentation/releases.md`
- Release notes archives (per year): `https://tray.ai/documentation/releases-{YYYY}.md`

## Section bundles

Whole-section concatenations for sessions that want all pages in context at once. Per-page `.md` URLs are also linked below for narrower fetches.

- [Platform bundle](https://tray.ai/documentation/platform/llms-full.txt) — 185 pages
- [Developer bundle](https://tray.ai/documentation/developer/llms-full.txt) — 61 pages
- [Help center bundle](https://tray.ai/documentation/help/llms-full.txt) — 10 pages

## Platform

- [Introduction](https://tray.ai/documentation/platform/introduction/getting-started/introduction.md): Welcome to the documentation for the Tray Universal Automation Cloud
- [Key concepts](https://tray.ai/documentation/platform/introduction/getting-started/key-concepts.md): Key concepts in building Tray automations
- [Quickstart](https://tray.ai/documentation/platform/introduction/getting-started/quickstart.md): Get started with a walkthrough of key Tray building principles
- [Basic data concepts](https://tray.ai/documentation/platform/automation-integration/building-workflows/mapping-data/basic-data-concepts.md): The main feature of Tray.io is that it allows you to access individual data items from service A, and insert them into service B.
- [Mapping data between steps](https://tray.ai/documentation/platform/automation-integration/building-workflows/mapping-data/mapping-data-between-steps.md): Tray has a set of tools that allow you to 'map' data from one service to another - i.e. 'pull' data from one service in order to 'push' it into another
- [Project config data (reusable variables)](https://tray.ai/documentation/platform/automation-integration/building-workflows/mapping-data/config-variables.md): Project config is data that can be re-used throughout your workflows e.g. notification email addresses, service IDs, base URLs etc.
- [Environment variables](https://tray.ai/documentation/platform/automation-integration/building-workflows/mapping-data/environment-variables.md): There is a list of $.env variables that - at any point in your workflow - can be used to access basic info about the workflow/solution environment
- [Fallback values](https://tray.ai/documentation/platform/automation-integration/building-workflows/mapping-data/fallback-values.md): Fallback values can be used for occasions when you know that data being returned will be inconsistent in some way.
- [Converting between data types](https://tray.ai/documentation/platform/automation-integration/building-workflows/mapping-data/converting-between-data-types.md): When passing data from one step to another, sometimes you will need to convert the data type of certain values.
- [Data transformation guide](https://tray.ai/documentation/platform/automation-integration/building-workflows/mapping-data/data-transformation-guide.md): When working with data in Tray, you will often find that you need to carry out certain transformations.
- [Satisfying input schema](https://tray.ai/documentation/platform/automation-integration/building-workflows/mapping-data/input-schema.md): When sending data in batch format to a service or database, you may find that there are particular 'input schema' requirements in terms of how the data is structured
- [Inline functions](https://tray.ai/documentation/platform/automation-integration/building-workflows/mapping-data/inline-functions.md): Inline functions
- [JSONata functions](https://tray.ai/documentation/platform/automation-integration/building-workflows/mapping-data/jsonata-functions.md): Use JSONata expressions directly in step input fields to transform data without adding a workflow step
- [Storing & Retrieving Data](https://tray.ai/documentation/platform/automation-integration/building-workflows/storing-retrieving-data.md): The Data Storage connector is one of the key connectors that you will need to use in Tray
- [Input schema issues](https://tray.ai/documentation/platform/automation-integration/building-workflows/configuring-steps/dynamic-input-schemas.md): If you are having trouble getting the input schema exactly right for a particular operation, we recommend making use of our Form builder demo app to run live…
- [Connector Versions](https://tray.ai/documentation/platform/automation-integration/building-workflows/configuring-steps/connector-versions.md): Connectors have different "versions" in Tray. Every time an update is made to a connector (i.e. every time we add new operations and functionality to a service or helper connector), a new version is created.
- [Error handling (3rd party)](https://tray.ai/documentation/platform/automation-integration/building-workflows/configuring-steps/error-handling.md): When calling operations using the Call connector endpoint, even though your payload may have passed Tray's input schema validation, you may encounter errors…
- [Conditional logic](https://tray.ai/documentation/platform/automation-integration/building-workflows/branching-looping/conditional-logic.md): Conditional logic is a powerful feature of the Tray.io workflow editor. It can be used to ask key questions whose answers will then determine what path your workflow will take
- [Calling Other Workflows](https://tray.ai/documentation/platform/automation-integration/building-workflows/composable-workflows/calling-other-workflows.md): Setting up parallel processing and modular functions in Tray
- [Copy & Paste Steps](https://tray.ai/documentation/platform/automation-integration/building-workflows/shortcuts/copy-paste.md): It is possible to copy and paste workflow steps either by selecting the [...] options button or by right clicking the step
- [Undo / Redo](https://tray.ai/documentation/platform/automation-integration/building-workflows/shortcuts/undo-redo.md): It is possible to revert or repeat your changes using the Undo / Redo buttons found in the top of the workflow editor. You can also "rollback" your workflow to a specific point in time during its build history.
- [Searching Steps](https://tray.ai/documentation/platform/automation-integration/building-workflows/shortcuts/searching-steps.md): Due to the potential size of workflows, it can be difficult to locate a particular workflow step. This is where the Step Search bar can help you locate particular connector steps (and triggers) within your workflows.
- [Workflow step dependencies](https://tray.ai/documentation/platform/automation-integration/building-workflows/shortcuts/step-dependencies.md): A visual aid that provides a quick overview of the relationships between your workflow steps.
- [Keyboard Shortcuts](https://tray.ai/documentation/platform/automation-integration/building-workflows/shortcuts/keyboard-shortcuts.md): A list of Builder specific keyboard shortcuts. Knowing these will speed up your build process and help you on your journey to becoming a Tray.io Power User
- [Snippets](https://tray.ai/documentation/platform/automation-integration/building-workflows/shortcuts/snippets.md): To enable you to get started quickly, Tray.io has a library of Templates and Snippets.
- [Development tips](https://tray.ai/documentation/platform/automation-integration/building-workflows/development-tips.md): When building workflows, there are certain tools and strategies you will need to adopt in order to make sure that you have each 'section' of your workflow operating as expected, before moving on to the next.
- [What is an error?](https://tray.ai/documentation/platform/automation-integration/building-workflows/error-handling/what-is-an-error.md): Identifying Tray vs 3rd party errors in the Tray builder
- [Manual error handling (connector-level)](https://tray.ai/documentation/platform/automation-integration/building-workflows/error-handling/manual-error-handling.md): For any service connector step, you can override the default error alerting setup by going to the 'If a step error occurs' setting in the properties panel
- [Fulfilling your use case](https://tray.ai/documentation/platform/automation-integration/building-workflows/fulfilling-your-use-case.md): Tray offers a powerful and infinitely flexible way to automate workflows and integrate various software applications.
- [Logs and debugging](https://tray.ai/documentation/platform/automation-integration/testing-debugging/debug-logs.md): When a workflow is run, it will produce a workflow log which can be used for debugging
- [Working with test data](https://tray.ai/documentation/platform/automation-integration/testing-debugging/working-with-test-data.md): You will need to run test data through your workflows in order to confirm that they are working 100% as intended. Exactly how you will do this depends on the type of workflow you are building and how data comes in.
- [Execution Kill Switch](https://tray.ai/documentation/platform/automation-integration/testing-debugging/execution-kill-switch.md): There may be occasions when the running execution(s) of a workflow has become dangerous. If you need to immediately stop all executions of a workflow you can do this with the 'Stop all executions' button:
- [ETL Overview](https://tray.ai/documentation/platform/automation-integration/advanced-use-cases/etl/overview.md): Extract Transform Load (ETL) generally involves the transferral of data from one (or more) sources to another, including a certain amount of 'transformation' of the data so that it adheres to the required protocols of the destination system
- [ETL (small scale)](https://tray.ai/documentation/platform/automation-integration/advanced-use-cases/etl/basic-etl.md): ETL using Tray core and helper connectors
- [ETL (large scale)](https://tray.ai/documentation/platform/automation-integration/advanced-use-cases/etl/etl-at-scale.md): ETL using the tray script connector
- [Data Synchronisation](https://tray.ai/documentation/platform/automation-integration/advanced-use-cases/data-synchronisation.md): Data synchronization is the process of maintaining data consistency between two or more services.
- [SQL Transformer](https://tray.ai/documentation/platform/automation-integration/advanced-use-cases/sql-transformer.md): Run SQL queries on files within your Tray workflows.
- [Queueing data](https://tray.ai/documentation/platform/automation-integration/advanced-use-cases/batching-queueing/queueing.md): A potential scenario to be aware of is that the throughput of data in your workflow might be at a rate that is too high for the API limits of the destination service.
- [Handling rate limits when sending data (chunking / batching)](https://tray.ai/documentation/platform/automation-integration/advanced-use-cases/batching-queueing/chunking-batching.md): When sending batches of data to create or update records, it is important to note that services will often have a limit on the number of records that can be updated in one call.
- [Handling rate limits when fetching data (pagination)](https://tray.ai/documentation/platform/automation-integration/advanced-use-cases/batching-queueing/pagination.md): Pagination comes into play when you are using connector operations (typically 'list' operations such as 'list customers', 'list contracts' etc.) which might return long lists of results which you then want to process in some way.
- [Basic polling](https://tray.ai/documentation/platform/automation-integration/advanced-use-cases/polling-for-new-data/basic-polling.md): When the Tray.io connector for a service you are using has no built-in trigger, and the service itself has no Webhook to subscribe to, you can use a technique we call 'polling' to manually check for updates with the Scheduled Trigger.
- [Polling with last runtime](https://tray.ai/documentation/platform/automation-integration/advanced-use-cases/polling-for-new-data/polling-with-last-runtime.md): How to check for new records since the last time the workflow was run
- [Folder Migration](https://tray.ai/documentation/platform/automation-integration/advanced-use-cases/folder-migration.md): very common problem faced by businesses is the mass migration of an entire company's folder structure (as well as the files themselves) into a new management system.
- [Managing CSV files](https://tray.ai/documentation/platform/automation-integration/advanced-use-cases/managing-csv-files.md): Common ways of getting a CSV file into a workflow
- [Working with lists / arrays](https://tray.ai/documentation/platform/automation-integration/advanced-use-cases/lists-arrays.md): There are several ways in which you can interact with and create lists in Tray
- [Building schema from JSON](https://tray.ai/documentation/platform/automation-integration/advanced-use-cases/building-schema-from-json.md): You can easily build complex schema structures using our Build from JSON tool.
- [Workflow threads](https://tray.ai/documentation/platform/automation-integration/advanced-use-cases/workflow-threads.md): When dealing with large amounts of data, workflow threading is a technique which can greatly help manage the efficiency and reliability of your workflows.
- [Efficient execution and minimized task consumption](https://tray.ai/documentation/platform/automation-integration/advanced-use-cases/optimizing-workflows.md): When putting workflows into production, it is important to make sure that they are built as efficiently as possible.
- [Optimizing vector tables](https://tray.ai/documentation/platform/automation-integration/advanced-use-cases/optimizing-vector-tables.md): Making optimal use of Tray's built-in vector tables
- [Data Tables](https://tray.ai/documentation/platform/automation-integration/advanced-capabilities/data-tables.md): Data tables can be used to store data in a table format in order to enable such functionality as lookup tables
- [Vector Tables](https://tray.ai/documentation/platform/automation-integration/advanced-capabilities/vector-tables.md): Tray’s vector tables is a key feature in terms of making your organization AI-ready. Post-ingestion, it allows you to store your data in ‘vector embedding’ format, which means it is primed to work with AI systems.
- [File Storage System](https://tray.ai/documentation/platform/automation-integration/advanced-capabilities/file-system.md): Store and interact files directly within a Tray project
- [Documenting workflows](https://tray.ai/documentation/platform/automation-integration/workflow-settings/documentation.md): You can annotate your workflow, add TODOs, instructions, links or images by filling out the Workflow description field
- [Alerting](https://tray.ai/documentation/platform/automation-integration/workflow-settings/alerting.md): Using the Alerting Trigger you can set up workflows to process errors from your workflows. This enables you to monitor and take appropriate action to help you quickly rectify any problems which occur in your projects.
- [How to use markdown](https://tray.ai/documentation/platform/automation-integration/workflow-settings/using-markdown.md): Markdown is a versatile markup language that can be used to format text, create lists, insert links and images, add horizontal rules, and format code.
- [Merlin Agent Builder](https://tray.ai/documentation/platform/artificial-intelligence/agent-builder/overview.md): Build AI Agents on Tray with Merlin Agent Builder. Native functionality to build and manage agents that can take actions using Tray workflows.
- [Getting started](https://tray.ai/documentation/platform/artificial-intelligence/agent-builder/getting-started.md)
- [Agent Configuration](https://tray.ai/documentation/platform/artificial-intelligence/agent-builder/configuration.md)
- [Data sources](https://tray.ai/documentation/platform/artificial-intelligence/agent-builder/data-sources.md)
- [Agent Tools](https://tray.ai/documentation/platform/artificial-intelligence/agent-builder/tools.md)
- [Interaction channels](https://tray.ai/documentation/platform/artificial-intelligence/agent-builder/interaction-channels.md): Connect your Tray AI Agents to the platforms where your users interact
- [Slack Interaction Channels](https://tray.ai/documentation/platform/artificial-intelligence/agent-builder/interaction-channels/slack-interactions-getting-started.md): Enable natural conversation with your Tray AI Agents directly in Slack
- [Microsoft Teams Interaction Channels](https://tray.ai/documentation/platform/artificial-intelligence/agent-builder/interaction-channels/teams-interactions-getting-started.md): Enable AI-powered assistance directly in Microsoft Teams workspaces
- [Testing Your Agent](https://tray.ai/documentation/platform/artificial-intelligence/agent-builder/testing.md)
- [Logs and Debugging](https://tray.ai/documentation/platform/artificial-intelligence/agent-builder/logs-and-debugging.md)
- [Agent Gateway Overview](https://tray.ai/documentation/platform/artificial-intelligence/agent-gateway/overview.md): Enterprise-grade governance and control for AI agents connecting to your business systems through the Model Context Protocol (MCP).
- [Getting Started with Agent Gateway](https://tray.ai/documentation/platform/artificial-intelligence/agent-gateway/getting-started.md): Prerequisites and initial setup steps for using Tray Agent Gateway and MCP servers.
- [MCP Server Configuration](https://tray.ai/documentation/platform/artificial-intelligence/agent-gateway/mcp-server-configuration.md): Configure and manage MCP servers in your Tray workspace to expose workflows and connector operations as AI tools.
- [Authentication and Access](https://tray.ai/documentation/platform/artificial-intelligence/agent-gateway/authentication-and-access.md): Understand how client authentication and user access control work in Tray Agent Gateway.
- [Workflow Tools](https://tray.ai/documentation/platform/artificial-intelligence/agent-gateway/workflow-tools.md): Expose Tray workflows as Composite Tools through your MCP server to execute complex multi-step business logic.
- [Connector Tools](https://tray.ai/documentation/platform/artificial-intelligence/agent-gateway/connector-tools.md): Expose individual connector operations as MCP tools for quick, granular access to your integrated systems.
- [Connecting to Agent Gateway](https://tray.ai/documentation/platform/artificial-intelligence/agent-gateway/connecting-clients.md): Connect AI clients to your Tray MCP server using OAuth2 authentication or API token setup.
- [Dynamic (User-provided) Authentication](https://tray.ai/documentation/platform/artificial-intelligence/agent-gateway/dynamic-authentication.md): Allow end users to execute MCP tools using their own credentials, ensuring actions run with the right permissions and full auditability.
- [Observability and Monitoring](https://tray.ai/documentation/platform/artificial-intelligence/agent-gateway/observability-and-monitoring.md): Monitor MCP tool executions, audit user activity, and track performance using workflow execution logs and the Monitor tab.
- [Troubleshooting and Limitations](https://tray.ai/documentation/platform/artificial-intelligence/agent-gateway/troubleshooting-and-limitations.md): Known limitations, current behaviours, and troubleshooting guidance for Tray Agent Gateway.
- [AI Palette](https://tray.ai/documentation/platform/artificial-intelligence/ai-palette.md): Tray has a 'palette' of AI connectors which significantly the power of your automations, allowing you to incorporate advanced AI functionalities into your workflows and integrations.
- [Tray IDP](https://tray.ai/documentation/platform/artificial-intelligence/tray-idp.md): Intelligent Document Processing (IDP) extracts structured data from unstructured documents and integrates it directly into your business systems through Tray's automation platform.
- [Intelligent Automations](https://tray.ai/documentation/platform/artificial-intelligence/intelligent-automations.md): With Tray you can build AI applications and infuse AI wherever necessary into your automations.
- [Getting started with vector tables](https://tray.ai/documentation/platform/artificial-intelligence/vector-storage.md): Tray’s vector tables is a key feature in terms of making your organization AI-ready. Post-ingestion, it allows you to store your data in ‘vector embedding’ format, which means it is primed to work with AI systems.
- [Fine-Tuning AI Models with Enterprise Data](https://tray.ai/documentation/platform/artificial-intelligence/ai-use-cases/fine-tuning-models.md): Learn how to fine-tune AI models using data extracted from enterprise systems like Jira, ServiceNow, or Zendesk to create specialized support and knowledge agents.
- [Merlin Build](https://tray.ai/documentation/platform/artificial-intelligence/augmented-development/merlin-build.md): Tray Build powered by Merlin AI can help you build your workflows from scratch, significantly reducing the time involved in deciding what logic and connectors to use
- [Usage tips and FAQs](https://tray.ai/documentation/platform/artificial-intelligence/augmented-development/usage-tips-and-faqs.md): The key to using Merlin is to work out how specific your query needs to be so that they can be matched with existing Tray connectors and their operations
- [Tray Headless](https://tray.ai/documentation/platform/tray-headless/overview.md): Build on Tray from any AI IDE. The full Tray platform — workflows, connectors, authentication, validation, and runs — built from natural language in your AI development environment.
- [Tray Headless for Claude Code](https://tray.ai/documentation/platform/tray-headless/headless-for-claude-code.md): The tray-workflows plugin for Claude Code — plan, build, validate, run, and debug Tray workflows from natural language, without leaving your terminal.
- [Tray Headless for Codex](https://tray.ai/documentation/platform/tray-headless/headless-for-codex.md): The tray-workflows plugin for the OpenAI Codex CLI — plan, build, validate, run, and debug Tray workflows from natural language, without leaving your terminal.
- [Tray Headless MCP](https://tray.ai/documentation/platform/tray-headless/tray-headless-mcp.md): Connect Cursor, Windsurf, Codex, Claude Code, or any MCP-compatible client to the hosted Tray MCP server at api.tray.io/mcp.
- [What is Embedded?](https://tray.ai/documentation/platform/embedded/overview/what-is-embedded.md): Put the power of Tray in the hands of End Users (internal staff or external customers) by templatizing automations and making them available as integrations
- [Preparing your environment](https://tray.ai/documentation/platform/embedded/overview/preparing-your-environment.md): Getting set up for Tray Embedded integrations
- [Quickstart](https://tray.ai/documentation/platform/embedded/overview/quickstart.md): A walkthrough of turning a project into a templatized integration
- [Embedded API](https://tray.ai/documentation/platform/embedded/overview/embedded-api.md): The Tray Embedded APIs are based on GraphQL
- [Integration marketplace app](https://tray.ai/documentation/platform/embedded/overview/integration-marketplace-app.md): On this page, we will take you through our Integration marketplace app - a NextJS application for quickly deploying an integration/automation marketplace so that your end users can discover and use your Embedded solutions.
- [Solutions](https://tray.ai/documentation/platform/embedded/key-concepts/solutions.md): A solution is a Project that has been templatized so that anyone can activate an instance of it and personalize it for their own use.
- [Solution instances](https://tray.ai/documentation/platform/embedded/key-concepts/solution-instances.md): A Solution Instance is an instance of a Solution that an End User has activated for their own use
- [The Config Wizard](https://tray.ai/documentation/platform/embedded/key-concepts/config-wizard.md): The primary function of the Config Wizard is to allow End Users to configure your integration for their own use
- [Auth-only dialog](https://tray.ai/documentation/platform/embedded/key-concepts/auth-only-dialog.md): It is possible to allow your users to complete the authentication step using an auth-only dialog, instead of the Configuration Wizard.
- [Config slots](https://tray.ai/documentation/platform/embedded/key-concepts/config-slots.md): The source workflows of your Solutions contain variables (e.g. Slack channel, Trello board ID) which might need to be set by the End User of your solution. You set these as 'project config' when building your workflows
- [Auth slots](https://tray.ai/documentation/platform/embedded/key-concepts/auth-slots.md): Any services in your source workflows will have authentications that will need to be set by the End Users of your Solutions.
- [End Users](https://tray.ai/documentation/platform/embedded/key-concepts/end-users.md): An End User of your Embedded integration is somebody who has Instances of your Solutions set up and configured for their own use.
- [Intro to data mapping](https://tray.ai/documentation/platform/embedded/advanced-features/data-mapping/introduction.md): In your Embedded solutions you may want to go a step further and allow your End Users to set up their own field mappings according to their particular needs.
- [Determining input schema](https://tray.ai/documentation/platform/embedded/advanced-features/data-mapping/determining-input-schema.md): This page shows the steps you need to take to find the required input schema for any operation under any Service Connector.
- [Tray partner-defined schema](https://tray.ai/documentation/platform/embedded/advanced-features/data-mapping/tray-partner-defined-schema.md): Here we present a scenario where you can use the 'Hardcoded list' option for mapping data in your integration.
- [End User-defined schema](https://tray.ai/documentation/platform/embedded/advanced-features/data-mapping/end-user-defined-schema.md): Here we take you through data mapping use cases where the End User configures the mapping for their solution instance
- [Many-to-one mapping](https://tray.ai/documentation/platform/embedded/advanced-features/data-mapping/many-to-one-mapping.md): It is possible to implement many-to-one mapping for your Embedded solutions.
- [Post-mapping transformations (partner-defined schema)](https://tray.ai/documentation/platform/embedded/advanced-features/data-mapping/data-transformation/partner-defined-schema.md): In this article, you will go through some common data transformation challenges that you might run into while building integrations.
- [Post-mapping transformations (End User-defined schema)](https://tray.ai/documentation/platform/embedded/advanced-features/data-mapping/data-transformation/end-user-defined-schema.md): In this article, you will go through some common data transformation challenges that you might run into while building ETL (extracting from source service A, transforming it using end user-defined schema, loading into destination service B) integrations.
- [Custom JS intro](https://tray.ai/documentation/platform/embedded/advanced-features/custom-js/intro.md): The Custom Javascript feature allows you to control the behaviour of configuration slots by inputting your own Javascript functions.
- [Components](https://tray.ai/documentation/platform/embedded/advanced-features/custom-js/components.md): To interact with the slots in the javascript code, you need to use the Tray javascript class
- [Notes and Best Practices](https://tray.ai/documentation/platform/embedded/advanced-features/custom-js/best-practices.md): Notes and best practices for using Tray Embedded custom js
- [Examples](https://tray.ai/documentation/platform/embedded/advanced-features/custom-js/examples.md): In this article, you will go through some common use cases of Custom JS in your embedded solutions.
- [Using the Call Connector API](https://tray.ai/documentation/platform/embedded/advanced-features/custom-js/call-connector-api.md): This mutation can be used to call a specific connector operation. This powerful feature is used in combination with a User Token and Authentication Id, to pull data from a particular service connector operation and display it in your app
- [Intro](https://tray.ai/documentation/platform/embedded/advanced-features/whitelabelling/introduction.md): When creating Tray Embedded integrations you will generally want to 'whitelabel' all parts of the integration so that Tray.io branding is not visible anywhere.
- [Public / webhook URLs](https://tray.ai/documentation/platform/embedded/advanced-features/whitelabelling/public-urls.md): When your End Users create Solution Instances, the Workflow Instances found within will have automatically-generated public urls
- [Custom OAuth apps](https://tray.ai/documentation/platform/embedded/advanced-features/whitelabelling/custom-oauth-apps.md): How to fully whitelabel the Config Wizard
- [Config Wizard CSS](https://tray.ai/documentation/platform/embedded/advanced-features/whitelabelling/config-wizard.md): In order to customize the Configuration Wizard which pops up when End Users are configuring a Solution Instance for their own use, it is possible to upload your own custom CSS in your Partner Account settings.
- [Your app CSS](https://tray.ai/documentation/platform/embedded/advanced-features/whitelabelling/your-app.md): Using tags and custom fields to manage CSS and icon urls
- [Available experiences](https://tray.ai/documentation/platform/embedded/delivery-methods/overview.md): There are 3 major ways to present the end-user experience with Tray Embedded integrations
- [The Standard Experience (Config Wizard)](https://tray.ai/documentation/platform/embedded/delivery-methods/config-wizard.md): This page will introduce you to all the API calls necessary in order to register an End User and allow them to click on an available solution to activate their own instance.
- [Auth-only dialog experience](https://tray.ai/documentation/platform/embedded/delivery-methods/auth-only-dialog.md): A breakdown of the calls involved with the Auth-only dialog experience
- [Custom form experience](https://tray.ai/documentation/platform/embedded/delivery-methods/custom-experience.md): A breakdown of the API calls involved with the Custom form experience
- [Error handling (Embedded)](https://tray.ai/documentation/platform/embedded/error-handling.md): Different stakeholders need to be taken into consideration for debugging/ troubleshooting Embedded solution instances - integration builders, customer support, and the client themselves. Tray has several features available to facilitate this
- [Overview](https://tray.ai/documentation/platform/api-management/overview.md): Tray offers a fully featured API management platform to build and publish accessible endpoints
- [API Operations](https://tray.ai/documentation/platform/api-management/api-operations.md): How to create endpoints for your packaged APIs
- [Access Control](https://tray.ai/documentation/platform/api-management/access-control.md): Setting roles and access policies for your published APIs
- [Using the API](https://tray.ai/documentation/platform/api-management/using-the-api.md): How to make basic calls to packaged APIs
- [API reference viewer](https://tray.ai/documentation/platform/api-management/openapi-spec/api-reference-viewer.md): View your API reference directly in the Tray Operations UI
- [Export OpenAPI spec](https://tray.ai/documentation/platform/api-management/openapi-spec/export-openapi-spec.md): Make use of your OpenAPI specs in order to manage your APIs as an organization and deliver a smooth experience for users of your APIs:
- [Create connector](https://tray.ai/documentation/platform/api-management/openapi-spec/create-connector.md): Export your OView penAPI spec and auto-create a connector using the Tray CDK
- [API management and Embedded integrations](https://tray.ai/documentation/platform/api-management/apim-in-embedded-integrations.md): To make use of API management in your Embedded integrations, you can use the HTTP client to make any necessary calls to endpoints that you have set up in a standalone API management project
- [Troubleshooting](https://tray.ai/documentation/platform/api-management/troubleshooting.md): How to troubleshoot your managed APIs and operations
- [Authenticating connectors](https://tray.ai/documentation/platform/connectivity/authentications.md): Just as when you log into your Gmail, Facebook, Salesforce, LinkedIn account etc., any service connectors you wish to use also require an authentication to verify the user.
- [Authenticating Google connectors](https://tray.ai/documentation/platform/connectivity/authenticating-google-connectors.md): At Tray.io, we use the Google OAuth2 API to enable our customers to authenticate into Google applications when building workflows on the Tray Platform
- [Updating connector version](https://tray.ai/documentation/platform/connectivity/updating-connector-version.md): Connectors have different "versions" in Tray.io. Every time an update is made to a connector (i.e. every time we add new operations and functionality to a service or helper connector), a new version is created.
- [Authentication collector](https://tray.ai/documentation/platform/connectivity/authentication-collector.md): The Authentication Collector feature allows you to securely gather authentications from your End Users for particular services.
- [Additional security (SSL / TLS)](https://tray.ai/documentation/platform/connectivity/additional-security-ssl-tls.md): For certain connectors it is possible to enable SSL / TLS to add additional security. This will be available in the authentication modal
- [Connector builder](https://tray.ai/documentation/platform/connectivity/connector-builder.md): The Tray Connector Builder allows you to build your own connectors.
- [Introduction](https://tray.ai/documentation/platform/connectivity/custom-services/introduction.md): When you want to use a service which is not available in the list of pre-built Tray connectors, you will have to build a custom service.
- [OAuth2 services](https://tray.ai/documentation/platform/connectivity/custom-services/oauth2-services.md): This is the default and preferred way of authenticating services that use OAuth2 based authentication as it ensures high security.
- [Token-based services](https://tray.ai/documentation/platform/connectivity/custom-services/token-based-services.md): To enable Token based authentication, you'll need access to the token of the third-party service you wish to use, as well as knowledge of any additional properties needed to authenticate.
- [On Prem Options](https://tray.ai/documentation/platform/connectivity/on-premise-systems/on-prem-options.md): Tray offers several options for On-prem setups which can help you comply with your infosec requirements for execution runtimes with 3rd party vendors
- [Getting started](https://tray.ai/documentation/platform/connectivity/on-premise-systems/on-prem-agent/getting-started.md): Getting started (on-prem agent)
- [Agent download](https://tray.ai/documentation/platform/connectivity/on-premise-systems/on-prem-agent/agent-download.md): Download links
- [Agent group config](https://tray.ai/documentation/platform/connectivity/on-premise-systems/on-prem-agent/agent-group-config.md): Learn how to configure an Agent group for On-Premise connectivity on Tray
- [Agent installation](https://tray.ai/documentation/platform/connectivity/on-premise-systems/on-prem-agent/agent-installation.md): On-prem agent installation
- [Testing and authenticating connectors](https://tray.ai/documentation/platform/connectivity/on-premise-systems/on-prem-agent/testing-and-authenticating-connectors.md): Testing and authenticating on-prem connectors
- [Logging](https://tray.ai/documentation/platform/connectivity/on-premise-systems/on-prem-agent/logging.md): Viewing on-prem agent logs
- [Public IPs](https://tray.ai/documentation/platform/connectivity/on-premise-systems/public-ips.md): For all services, you can allow-list the Tray public IPs, so that you are not opening your services to the world:
- [Site-to-site VPN](https://tray.ai/documentation/platform/connectivity/on-premise-systems/site-to-site-vpn.md): This option allows Tray connectors to access your network using VPN tunnels.
- [AWS Transit Gateway](https://tray.ai/documentation/platform/connectivity/on-premise-systems/aws-connectivity/aws-transit-gateway.md): This setup will allow Tray's connectors to reach inside your private network using routes established via attachment of a Tray-owned VPC to the your Transit Gateway.
- [AWS PrivateLink](https://tray.ai/documentation/platform/connectivity/on-premise-systems/aws-connectivity/aws-privatelink.md): This setup will allow specific Tray connectors to reach your services hosted on AWS. VPC Endpoints are what facilitate this type of connectivity - using a technology called PrivateLink.
- [AWS VPC peering](https://tray.ai/documentation/platform/connectivity/on-premise-systems/aws-connectivity/aws-vpc-peering.md): Allows Tray connectors to reach inside your private network using routes established via attachment of a Tray-owned VPC, as if both our VPCs were inside the same network.
- [Insights](https://tray.ai/documentation/platform/enterprise-core/insights.md): Insights Hub is the mission control room for your Tray organisation, surfacing analytics and operational insights into the health and performance of your assets
- [Usage & Billing](https://tray.ai/documentation/platform/enterprise-core/usage-billing.md): The Tray.io usage dashboard gives you full visibility of your workspaces and overall workflow usage stats, respective of the amount of entitlements you have been given.
- [Tray Org setup](https://tray.ai/documentation/platform/enterprise-core/organisation-management/tray-org-setup.md): It is vital that you set up your Tray org in a way that meets the needs of your company.
- [Regional Hosting](https://tray.ai/documentation/platform/enterprise-core/organisation-management/regional-hosting.md): A Tray instance can be hosted in one of the following Data Regions: US, EU or APAC. This can help ensure that business data will never leave the region that it originated in, and compliance with data regulations according to your region.
- [Workspaces and projects](https://tray.ai/documentation/platform/enterprise-core/organisation-management/workspaces-and-projects.md): Workspaces can be used to divide your Organization into subsections. Projects are self contained and they contain key Tray building blocks such as workflows.
- [Managing authentications](https://tray.ai/documentation/platform/enterprise-core/organisation-management/managing-authentications.md): Moving authentications can be risky. Once you move an authentication you are liable to potentially break any Workflow that is currently using it.
- [Managing workflows](https://tray.ai/documentation/platform/enterprise-core/organisation-management/managing-workflows.md): How to move, duplicate, and delete workflows between workspaces.
- [AI Features](https://tray.ai/documentation/platform/enterprise-core/organisation-management/ai-features.md): Learn how to administrate Merlin AI features
- [Anomaly Detection](https://tray.ai/documentation/platform/enterprise-core/organisation-management/anomaly-detection.md): Guide to using Anomaly Detection log streaming to alert unusual behaviors across your workspaces.
- [User management and RBAC](https://tray.ai/documentation/platform/enterprise-core/organisation-management/users/roles.md): Guidance on managing user access to workspaces and assets
- [Profile & Login](https://tray.ai/documentation/platform/enterprise-core/organisation-management/users/profile-login.md): Manage your 2FA settings, multiple account logins, and SSO configuration.
- [API Users & Tokens](https://tray.ai/documentation/platform/enterprise-core/organisation-management/api-users-tokens.md): Guide to creating and managing API users and tokens for programmatic access to Tray workspaces.
- [Security Policies](https://tray.ai/documentation/platform/enterprise-core/security-compliance/security-policies.md): An overview of Tray's security practices and data handling procedures.
- [How does Merlin AI use my data?](https://tray.ai/documentation/platform/enterprise-core/security-compliance/how-does-merlin-ai-use-my-data.md): Details on how Merlin AI features process and retain your data.
- [Support Access Controls](https://tray.ai/documentation/platform/enterprise-core/security-compliance/support-access-controls.md): Tray's Support Access feature allows you to determine when our support team can access your workflows, ensuring a high level of security and control.
- [Security Statement](https://tray.ai/documentation/platform/enterprise-core/security-compliance/security-statement.md): Tray has implemented the measures as described in this exhibit insofar as the respective measure contributes or is capable of contributing directly or indirectly to the protection of the personal data under the DPA entered into between the parties
- [Data Protection Commitment](https://tray.ai/documentation/platform/enterprise-core/security-compliance/data-protection-commitment.md): To meet the requirements of data protection laws and regulations like the GDPR and CCPA, Tray employs privacy and information security controls
- [Log Masking](https://tray.ai/documentation/platform/enterprise-core/security-compliance/log-masking.md): Hide a workflow step's input and output values in execution logs UI so sensitive data stays protected from workspace members, while admins keep on-demand access.
- [Building Securely](https://tray.ai/documentation/platform/enterprise-core/security-compliance/building-securely.md): How to ensure your Tray projects are managed in a secure fashion
- [Overview](https://tray.ai/documentation/platform/enterprise-core/lifecycle-management/overview.md): An overview of the lifecycle management process in Tray
- [Setting up your environment](https://tray.ai/documentation/platform/enterprise-core/lifecycle-management/setting-up-your-environment.md): Exactly how you will want to manage your Org to enable version control and environment promotion will depend on your use case and which package of Tray you are working with.
- [Project Versioning](https://tray.ai/documentation/platform/enterprise-core/lifecycle-management/project-versioning.md): In the Software Development Life Cycle (SDLC) at Tray, versions act like code commits or release candidates - stable snapshots of the project's state that are documented and can be deployed to higher environments.
- [Import / Export](https://tray.ai/documentation/platform/enterprise-core/lifecycle-management/import-export.md): In Tray you can use Projects to manage a classic dev > production setup. Tray has a system whereby you can export and import projects (and individual workflows) as json files.
- [Authentication mapping at import](https://tray.ai/documentation/platform/enterprise-core/lifecycle-management/environment-variables/mapping-authentications.md): Users must map authentications when importing workflows and projects across workspaces.
- [Service / connector mapping at import](https://tray.ai/documentation/platform/enterprise-core/lifecycle-management/environment-variables/mapping-dependencies.md): Mapping custom service and connectors when importing version of Tray projects
- [Resolving config values](https://tray.ai/documentation/platform/enterprise-core/lifecycle-management/environment-variables/resolving-config.md): The configuration resolution feature allows users to manage conflicts in configuration values during project import.
- [Import preview](https://tray.ai/documentation/platform/enterprise-core/lifecycle-management/pre-import-checks/import-preview.md): The Import Preview helps you see the potential import impact before it happens
- [Publish solution preview](https://tray.ai/documentation/platform/enterprise-core/lifecycle-management/pre-import-checks/publish-solution-preview.md): After importing an Embedded project you will have an updated version of your Solution. In order to roll it out to your users, you will need to click 'publish' in the Solution Editor UI:
- [Automated SDLC Pipeline with Tray APIs](https://tray.ai/documentation/platform/enterprise-core/lifecycle-management/automated-pipeline.md): Setting Up an Automated SDLC Pipeline with Tray APIs
- [Promoting new releases (Embedded)](https://tray.ai/documentation/platform/enterprise-core/lifecycle-management/embedded-release-management/promoting-new-releases.md): When you first import a project to a prod environment you will need to do so manually, in order to allow you to create / select the correct prod authentications. Imports thereafter can be done programatically via API
- [Change management (Embedded)](https://tray.ai/documentation/platform/enterprise-core/lifecycle-management/embedded-release-management/change-management.md): Any subsequent versions of your integrations can be imported programatically via API, unless there are new or modified authentications:
- [Logs and debugging](https://tray.ai/documentation/platform/enterprise-core/logs-debugging/debug-logs.md): When a workflow is run, it will produce a workflow log which can be used for debugging
- [Log Streaming](https://tray.ai/documentation/platform/enterprise-core/logs-debugging/log-streaming.md): Tray streams workflow logs to an external endpoint, so you can analyse them in a system such as Datadog, Sentry, Redshift, New Relic or Kibana.
- [Disabling Log Storage](https://tray.ai/documentation/platform/enterprise-core/logs-debugging/disabling-log-storage.md): This feature allows customers to change the standard log retention time and disable sharing log data.
- [Technical limits, timeouts and retries](https://tray.ai/documentation/platform/enterprise-core/logs-debugging/technical-limits.md): This page brings together all information on technical limits of connectors on the Tray Platform.

## Developer

- [Introduction](https://tray.ai/documentation/developer/getting-started/introduction.md): Tray's APIs give you direct programmatic access to the power of Tray's connectors and auth creation / storage tools.
- [Master and user tokens](https://tray.ai/documentation/developer/getting-started/prerequisites/master-and-user-tokens.md): All endpoints require either a master token or a user token passed as a bearer. When using a Master token, you are the one taking actions (getting connectors,…
- [Whitelabelling with Custom OAuth apps](https://tray.ai/documentation/developer/getting-started/prerequisites/custom-oauth-apps.md): When building integrations with Tray's API, you will need to authenticate your End Users with the service connectors involved.
- [Storing users and integrations](https://tray.ai/documentation/developer/getting-started/building-integrations/storing-users-and-integrations.md): For your integrations you will need to manage: Users and their authentications The connectors, operations, input schema and service environments involved in…
- [The user journey](https://tray.ai/documentation/developer/getting-started/building-integrations/the-user-journey.md): This page will be a detailed breakdown of the following process flow. It will also link to the Form builder tutorial which will be deep dive code tutorial on…
- [Create users and tokens](https://tray.ai/documentation/developer/getting-started/creating-end-user-auths/create-users-and-tokens.md): The users of your integrations (end users) need to have corresponding Tray user records so you can attach auths to them and run integrations (call connectors)…
- [Create new auths](https://tray.ai/documentation/developer/getting-started/creating-end-user-auths/create-new-auths.md): If you need to prompt your End Users to create new auths from scratch, you can make use of Tray's auth-only dialog: In order to open the auth collection…
- [Import existing auths](https://tray.ai/documentation/developer/getting-started/creating-end-user-auths/import-existing-auths.md): This page illustrates the steps involved in importing existing authentications from your infrastructure to Tray.
- [Auth dialog Events](https://tray.ai/documentation/developer/getting-started/creating-end-user-auths/auth-dialog-events.md): Auth dialog is used to capture new auths from your end users. The dialog window to the global window object that can be captures to take further actions.
- [Using connectors and operations](https://tray.ai/documentation/developer/getting-started/calling-connectors/using-connectors-and-operations.md): This page will take you through what endpoints are involved in discovering and using connectors and their operations.
- [DDL operations](https://tray.ai/documentation/developer/getting-started/calling-connectors/ddl-operations.md): Info: Please also see our Building a UI form tutorial for guidance on rendering DDLs in your integration.
- [Dynamic outputs](https://tray.ai/documentation/developer/getting-started/calling-connectors/dynamic-outputs.md): One of the properties included with each operation is the boolean hasDynamicOutput.
- [Enums](https://tray.ai/documentation/developer/getting-started/calling-connectors/enums.md): Some fields in connector operations are enum lists that can be rendered as set lists for your End Users to choose from: You can use our Ops Explorer dev tool…
- [Example use case](https://tray.ai/documentation/developer/getting-started/calling-connectors/example-use-case.md): The screenshot above shows a mockup of an interface you might create to make use of the Twilio connector. This would allow your users to: 1.
- [Using triggers](https://tray.ai/documentation/developer/getting-started/using-triggers/discovering-triggers-and-operations.md): This page will take you through what endpoints are involved in discovering and using triggers and their operations.  The Get triggers endpoint will return…
- [Creating subscriptions](https://tray.ai/documentation/developer/getting-started/using-triggers/creating-subscriptions.md): For subscribing to a service using Tray, you need to make a call to Create Subscription.
- [Verifying subscription payloads](https://tray.ai/documentation/developer/getting-started/using-triggers/verifying-subcription-payloads.md): Verifying the payload is an optional step to ensure the authenticity of the payload.
- [Pagination](https://tray.ai/documentation/developer/getting-started/implementation-notes/pagination.md): When using the Call connector endpoint, certain 3rd party operations such as Salesforce 'List records' or Marketo 'List leads' may return long lists of data…
- [Working with webhooks](https://tray.ai/documentation/developer/getting-started/implementation-notes/working-with-webhooks.md): If you are creating integrations that are dependent on 3rd-party webhooks, you may find that some policies are quite restrictive. e.g.
- [File storage](https://tray.ai/documentation/developer/getting-started/implementation-notes/file-storage.md): When using the Call connector endpoint, certain operations require temporary file storage, when e.g.
- [Building a UI form](https://tray.ai/documentation/developer/getting-started/tutorials/building-a-ui-form.md): This page is a tutorial on how you can code a generic frontend form which works with all Tray connectors and operations.
- [Error handling (Tray)](https://tray.ai/documentation/developer/getting-started/troubleshooting/error-handling-tray.md): When calling operations using the Call connector endpoint you may experience errors associated with the input payload or with the authentication referenced by…
- [Error handling (3rd party)](https://tray.ai/documentation/developer/getting-started/troubleshooting/error-handling-3rd-party.md): When calling operations using the Call connector endpoint, even though your payload may have passed Tray's input schema validation, you may encounter errors…
- [DDL issues](https://tray.ai/documentation/developer/getting-started/troubleshooting/ddl-issues.md): You may find that some DDL operations (identified as 'lookup' in the input schema) may be missing parameters which affect their functionality.
- [Input schema issues](https://tray.ai/documentation/developer/getting-started/troubleshooting/input-schema-issues.md): If you are having trouble getting the input schema exactly right for a particular operation, we recommend making use of our Form builder demo app to run live…
- [Rate limiting (Tray)](https://tray.ai/documentation/developer/getting-started/troubleshooting/rate-limiting-tray.md): The APIs use a number of safeguards against bursts of incoming traffic to help maximise its stability.
- [Rate limiting](https://tray.ai/documentation/developer/getting-started/troubleshooting/rate-limiting-3rd-party.md): When using the Call connector endpoint if you exceed the rate limiting policy of the 3rd party service you are calling, the 429 response will be contained…
- [FAQs](https://tray.ai/documentation/developer/getting-started/faqs.md): Can connectors built with Connector builder be used with the APIs? Yes, you can retrieve their Service and Service Environment IDs Can I use…
- [Note on billing](https://tray.ai/documentation/developer/getting-started/note-on-billing.md): | API Endpoint | Usage | Billable | | ------------ | ------------------------------------------------------------------------------- | -------- | | | Returns a…
- [Introduction](https://tray.ai/documentation/developer/connector-development-kit/overview/introduction.md): If you know your way around CDK already, you can jump to the CLI and DSL references directly: - @trayio/cdk-cli - @trayio/cdk-dslMake sure you check out the…
- [Anatomy of a CDK connector](https://tray.ai/documentation/developer/connector-development-kit/overview/key-concepts.md): This article breaks down the anatomy of a CDK connector, explaining each component in detail.
- [Example use case](https://tray.ai/documentation/developer/connector-development-kit/overview/examples.md): The screenshot above shows a mockup of an interface you might create to make use of the Twilio connector. This would allow your users to: 1.
- [Raw HTTP (Token) Quickstart](https://tray.ai/documentation/developer/connector-development-kit/overview/quickstarts/token-raw-http.md): Learn how to deploy a token-based service connector with a single Raw HTTP operation using the TMDB API
- [Single HTTP Quickstart](https://tray.ai/documentation/developer/connector-development-kit/overview/quickstarts/single-http.md): Build a single HTTP operation for a service connector using the TMDB API's get top rated movies endpoint
- [Raw HTTP (OAuth2) Quickstart](https://tray.ai/documentation/developer/connector-development-kit/overview/quickstarts/oauth2-raw-http.md): Deploy an OAuth2 service connector with a single Raw HTTP operation using the Dropbox API
- [Composite Quickstart](https://tray.ai/documentation/developer/connector-development-kit/overview/quickstarts/composite.md): Create a helper/utility connector with a composite operation that converts HTML to Markdown
- [auth.ts configuration](https://tray.ai/documentation/developer/connector-development-kit/developing-connectors/authentications/auth-ts.md): You don't need to configure this file if your conector does not need a user auth e.g.
- [GlobalConfig.ts configuration](https://tray.ai/documentation/developer/connector-development-kit/developing-connectors/authentications/global-config.md): Currently, Global configs can only used be with a HTTP handler.  This file defines the configs that can be shared by all the operations.
- [Raw HTTP (Token) Quickstart](https://tray.ai/documentation/developer/connector-development-kit/developing-connectors/authentications/raw-http-operation.md): Info: Follow composite quickstart if you are building up a Helper / Utility connector.
- [Token request operation](https://tray.ai/documentation/developer/connector-development-kit/developing-connectors/authentications/token-request-non-standard.md): Info: Once the operation has been configured, a support request will need to be created so that a Tray engineer can enable token request for the specified…
- [input.ts configuration](https://tray.ai/documentation/developer/connector-development-kit/developing-connectors/operations/input-ts-configuration.md): You can deploy a connector with just Raw HTTP operation and test it in the UI. This would confirm if you have set up the custom service properly and your auth…
- [Dynamic outputs](https://tray.ai/documentation/developer/connector-development-kit/developing-connectors/operations/output-ts-configuration.md): One of the properties included with each operation is the boolean hasDynamicOutput.
- [Single HTTP Quickstart](https://tray.ai/documentation/developer/connector-development-kit/developing-connectors/operations/handler-ts-configuration.md): Info: Follow composite quickstart if you are building up a Helper / Utility connector. This is a follow up guide after Raw HTTP quickstarts.
- [handler.test.ts configuration](https://tray.ai/documentation/developer/connector-development-kit/developing-connectors/operations/handler-test-ts-configuration.md): This file will contain the unit tests that ensure the operation is working as expected. This page shows how to create and run tests.
- [File handling](https://tray.ai/documentation/developer/connector-development-kit/developing-connectors/operations/file-handling.md): Through CDK, You can build operations that can handle file uploads and downloads. You can send binary data or multipart/form-data depending on the service you…
- [Building a DDL (Dynamic dropdown list) operation](https://tray.ai/documentation/developer/connector-development-kit/developing-connectors/dynamic-dropdown-lists/building-ddl-operation.md): Through CDK, you can also build operations that use dropdown lists on the operation's input properties panel.
- [DDL operations](https://tray.ai/documentation/developer/connector-development-kit/developing-connectors/dynamic-dropdown-lists/using-ddl-operation.md): Info: Please also see our Building a UI form tutorial for guidance on rendering DDLs in your integration.
- [Generate a connector using OpenAPI](https://tray.ai/documentation/developer/connector-development-kit/developing-connectors/import-openapi-specification.md): You can auto-generate a connector for an API if you have the file for it. See full list of supported features below.
- [Using Claude Code with CDK](https://tray.ai/documentation/developer/connector-development-kit/developing-connectors/using-claude-code.md): Claude Code is Anthropic's official CLI tool for working with Claude directly in your terminal.
- [Deploying a CDK connector using APIs](https://tray.ai/documentation/developer/connector-development-kit/deploying-connectors/deploy-using-api.md): You can deploy connectors built through CDK using the Connector Deployment API. In order to deploy a connector, you will need an RBAC (Role Based Access…
- [Deploying a CDK connector using CLI](https://tray.ai/documentation/developer/connector-development-kit/deploying-connectors/deploy-using-cli.md): You can deploy connectors built through CDK using the CDK CLI. In order to deploy a connector, you will need an RBAC (Role Based Access Control) API token, you…
- [CI / CD Pipeline with Github Actions](https://tray.ai/documentation/developer/connector-development-kit/deploying-connectors/ci-cd-pipeline.md): Info: This guide uses the from our public repo.The setup assumes you have a Github monorepo that holds all CDK connectors built by your organization.Even if…
- [Tips and FAQs](https://tray.ai/documentation/developer/connector-development-kit/troubleshooting.md): This page contains troubleshooting tips and FAQs for CDK. You can use console.log statement in the handler to log requests and responses: You can also log…
- [Release Notes](https://tray.ai/documentation/developer/connector-development-kit/releases/notes.md): What's New We've added support for Claude Code, Anthropic's CLI tool, to accelerate CDK connector development.
- [Migration Guide](https://tray.ai/documentation/developer/connector-development-kit/releases/migration-guide.md): The v4 of CDK introduces two major changes. With v4, you get: 1. a global config object that gets passed to every operation of the connector 2.
- [CDK CLI Reference](https://tray.ai/documentation/developer/connector-development-kit/reference/cli-reference.md): Display help for tray-cdk. Display autocomplete installation instructions Retrieves the connector namespace for your organization, if one exists Creates a new…
- [Connector Development Kit (CDK) DSL](https://tray.ai/documentation/developer/connector-development-kit/reference/dsl-reference.md): The CDK Domain Specific Language (DSL) is the main component of Tray's CDK, it is used to define all the aspects of a connectors, including the behaviour of…
- [Connector Tester tool](https://tray.ai/documentation/developer/developer-tools/connector-tester.md): There are two versions of the Connector Tester tool: The in-browser version. [Launch the tool in a new tab]() The local version (can be cloned from the Tray…
- [Operations Explorer](https://tray.ai/documentation/developer/developer-tools/operations-explorer.md): The Ops explorer tool below helps you quickly discover the input schemas for any Tray connector / trigger and it's operations.
- [Data Transformer](https://tray.ai/documentation/developer/developer-tools/data-transformer.md): Data transformation is a key step in building integrations between services as the schemas of the data expected or returned by these services keeps changing.
- [Tray Sync CLI](https://tray.ai/documentation/developer/developer-tools/tray-sync-cli.md): CLI tool to clone Tray projects and related assets to a local directory, and promote them between Tray environments

## Help center

- [FAQs](https://tray.ai/documentation/help/frequently-asked-questions/account-management-faqs.md): Can connectors built with Connector builder be used with the APIs? - Yes, you can retrieve their Service and Service Environment IDs Can I use…
- [Custom service and auth FAQs](https://tray.ai/documentation/help/frequently-asked-questions/custom-service-and-auth-faqs.md): Common questions Tray customers ask about creating custom services and authentications for apps which are not in the Tray connector library
- [Service Connector FAQs](https://tray.ai/documentation/help/frequently-asked-questions/service-connector-faqs.md): Common questions Tray customers ask about what they can do with key service connectors such as Salesforce, Slack and Google Sheets
- [Working with data FAQs](https://tray.ai/documentation/help/frequently-asked-questions/working-with-data-faqs.md): Common questions Tray customers ask about what you can do with data that is received from and sent to third party services
- [Working with logs](https://tray.ai/documentation/help/troubleshooting/working-with-logs.md): Troubleshooting information and tips and tricks for Tray customers using the logs panel to debug their workflows
- [Error messages](https://tray.ai/documentation/help/troubleshooting/error-messages.md): Troubleshooting information for common error messages customers may experience when using the Tray builder
- [Authentication troubleshooting](https://tray.ai/documentation/help/troubleshooting/authentication-troubleshooting.md): Troubleshooting information for issues Tray customers may encounter when authenticating with key services such as Salesforce, Slack, MS Teams and Marketo
- [General troubleshooting](https://tray.ai/documentation/help/troubleshooting/general-troubleshooting.md): Troubleshooting information for issues Tray customers may encounter when using the Tray builder
- [Creating a support ticket](https://tray.ai/documentation/help/getting-support/creating-a-support-ticket.md): Guidance on how to communicate with Tray support when customers are experiencing issues when building workflows
- [HubSpot](https://tray.ai/documentation/help/transition-guides/hubspot.md): HubSpot release notes

## Agent Hub

Agent Hub conceptual documentation lives under the Platform section:

- [Agent Builder overview](https://tray.ai/documentation/platform/artificial-intelligence/agent-builder/overview.md)
- [Agent Gateway overview](https://tray.ai/documentation/platform/artificial-intelligence/agent-gateway/overview.md)

## Connectors

Tray ships hundreds of pre-built connectors across five categories: service, core, helper, artificial-intelligence, and trigger. The full listing is at [`https://tray.ai/documentation/connectors/llms.txt`](https://tray.ai/documentation/connectors/llms.txt).

## Release notes

- [Recent releases (2026 + 2025)](https://tray.ai/documentation/releases.md) — 57 entries inline, newest first
- [2024 archive](https://tray.ai/documentation/releases-2024.md) — 68 entries
- [2023 archive](https://tray.ai/documentation/releases-2023.md) — 129 entries

Each release entry is also individually fetchable at `https://tray.ai/documentation/releases/{category}/{slug}.md` (categories: `features`, `fixes`, `connector-updates`, `deprecations`, `new-connector`).