> ## Documentation Index
> Fetch the complete documentation index at: https://superthread.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# Import tasks with an AI assistant
> Move tasks into Superthread from 22 tools using ChatGPT, Claude, Gemini, or Microsoft Copilot
You can use an AI assistant as a migration bridge when Superthread does not have a built-in importer. The assistant reads your source through an official MCP server, a read-only API token, or an exported spreadsheet, then creates cards through the [Superthread MCP server](https://mcp.superthread.com/).
An AI-assisted import is not a transactional backup restore. Test with five cards first, review the field mapping, and keep the source data until you have checked the completed import. For Jira, Trello, and Shortcut, use Superthread's built-in importer for the best fidelity.
This guide was verified against the providers' official documentation on **27 August 2026**. “Official MCP” means the source vendor publishes and supports the server. A route described as “compatible MCP” uses standards both products document, but may not have a source-vendor setup page for that exact assistant. Where authentication compatibility is not documented, this guide gives a file or local-client fallback instead.
These routes were checked against current vendor documentation, but were not live-tested in every paid plan, tenant, and regional deployment. Rows marked as compatible rather than vendor-verified include a documented file, API, or local-client fallback.
## Choose your assistant
The exact product surface matters because the four assistants do not expose the same tools.
| Assistant | Surface used in this guide | Important limitation |
| ----------------- | --------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| ChatGPT | ChatGPT Business or Enterprise/Edu on the web with Developer mode and custom MCP apps | Full MCP write actions are required to create Superthread cards. Pro currently supports only read/fetch through custom MCP apps, so it cannot run this import end to end. |
| Claude | Claude web/desktop for remote MCP; Claude Code for API-token and local-server imports | Claude Free allows one custom connector, while an MCP-to-MCP migration normally needs both the source and Superthread enabled. |
| Gemini | Gemini CLI for MCP-to-MCP imports; Gemini Spark for file-to-Superthread imports | Google's Spark documentation explains how to select one custom app, but does not document invoking two custom MCP apps in one task. Use Gemini CLI when both the source and Superthread are MCP servers. |
| Microsoft Copilot | Copilot Studio for hosted MCP servers; GitHub Copilot in VS Code for local/API/file workflows | The consumer Microsoft Copilot chat does not provide the two-connector workflow described here. |
## Import methods at a glance
| Source | Recommended method | Authentication |
| --------------- | ----------------------------------------------- | --------------------------------------------------------------------- |
| Jira | Native Superthread importer | Jira email, cloud hostname, and API token |
| Trello | Native Superthread importer | Trello authorization |
| Shortcut | Native Superthread importer | Shortcut API token |
| Linear | Official hosted MCP | OAuth |
| Asana | Official hosted MCP | OAuth |
| ClickUp | Official hosted MCP | OAuth |
| monday.com | Official hosted MCP | OAuth or API token |
| Confluence | Atlassian Rovo MCP | OAuth |
| Notion | Official hosted MCP | OAuth |
| Wrike | Official hosted MCP | Directory app, OAuth app, or permanent token |
| Smartsheet | Official hosted MCP or spreadsheet export | OAuth or API token; Business, Enterprise, or Advanced Work Management |
| Airtable | Official hosted MCP | OAuth; PAT or CSV as fallback |
| Todoist | Official hosted MCP | OAuth |
| Azure DevOps | Hosted or local official MCP | Microsoft Entra, or PAT for the local server |
| Teamwork | Official hosted MCP | OAuth; paid Teamwork plan and admin enablement |
| Basecamp | Official CLI and agent skill | OAuth |
| GitHub Projects | Official GitHub MCP | OAuth or PAT |
| GitLab | Official hosted MCP (beta), or CSV/API fallback | OAuth; GitLab administrator prerequisites apply |
| YouTrack | Official hosted MCP | OAuth or permanent token |
| Redmine | REST API | API key |
| Google Sheets | Download and attach `.xlsx` or `.csv` | No API token required |
| Microsoft Excel | Attach `.xlsx` or `.csv` | No API token required |
## Before you import
1. Create the destination space, board, and statuses in Superthread.
2. Decide which source projects, boards, lists, or views are in scope.
3. Decide whether completed and archived work should be included.
4. Make sure assignees already belong to the Superthread workspace. Do not let the assistant guess user matches.
5. Choose a stable source identifier, such as the original task ID or URL, for duplicate detection.
### Recommended field mapping
| Source value | Superthread value | Rule |
| ----------------------------------------- | ---------------------- | --------------------------------------------------- |
| Task, issue, item, row, or to-do title | Card title | Required |
| Description, notes, or body | Card description | Preserve formatting where possible |
| Workflow state, section, group, or status | Status | Show the proposed mapping before writing |
| Project, board, list, or base | Board or project | Confirm the destination first |
| Assignee | Assignee | Match by email first; leave unassigned if ambiguous |
| Priority | Priority | Normalize only after showing the mapping |
| Start and due dates | Start and due dates | Preserve ISO dates and timezone where supplied |
| Labels or tags | Tags | Reuse existing tags before creating new ones |
| Parent or epic | Parent card or project | Import parents before children |
| Source ID and URL | Description footer | Use for provenance and duplicate detection |
## Connect Superthread
Connect Superthread before adding the source. The server URL is:
```text theme={null}
https://mcp.superthread.com/mcp
```
Full MCP write support currently requires ChatGPT Business or Enterprise/Edu on the web. On Business, an admin or owner creates and publishes the app. On Enterprise/Edu, an admin can authorize developers through role-based access control.
1. Open **Settings → Apps → Advanced settings** and enable **Developer mode**. Business admins can also start from **Workspace settings → Apps → Create**.
2. Open **Settings → Apps → Create** (or the equivalent Workspace settings page).
3. Name the app `Superthread`, enter `https://mcp.superthread.com/mcp`, select OAuth, and scan the tools.
4. Complete Superthread authorization, create the draft, and have an admin or owner publish it if other workspace members need it.
5. In a new chat, select Superthread from the tools menu. For an MCP-to-MCP import, select both the source app and Superthread in the same message.
ChatGPT supports remote MCP servers only. It can invoke multiple apps in one prompt and may ask for confirmation before write actions. Pro users can use custom MCP apps only for read/fetch, so Pro cannot create the destination cards. See OpenAI's [Developer mode and MCP apps guide](https://help.openai.com/en/articles/12584461-developer-mode-and-mcp-apps-in-chatgpt).
1. Open **Customize → Connectors**.
2. Select **+ → Add custom connector**.
3. Name it `Superthread`, enter `https://mcp.superthread.com/mcp`, and leave the optional client ID and secret blank.
4. Select **Add**, then **Connect**, and authorize Superthread.
5. In a chat, use **+ → Connectors** to enable Superthread.
On Team and Enterprise plans, an Owner must add the connector under **Organization settings → Connectors** before members connect it. See [Claude's remote MCP guide](https://support.claude.com/en/articles/11175166-get-started-with-custom-connectors-using-remote-mcp).
**Gemini Spark for file imports:** in the Gemini web app, open **Settings & help → Connected Apps → Custom apps for Spark**, add `https://mcp.superthread.com/mcp`, and complete OAuth. Attach the source file to a Spark task and type `@Superthread` to select it. Spark currently requires a personal US Google Account, age 18+, English, Keep Activity, and Spark access.
**Gemini CLI for MCP-to-MCP imports:** add this to `~/.gemini/settings.json`, restart Gemini CLI, then run `/mcp auth superthread`:
```json theme={null}
{
"mcpServers": {
"superthread": {
"httpUrl": "https://mcp.superthread.com/mcp"
}
}
}
```
Google's Spark guide documents selecting a custom app with `@`, but does not document calling two custom apps in one task. Use Gemini CLI when the source is another MCP server. See Google's guides for [Gemini Spark custom apps](https://support.google.com/gemini/answer/17209137) and [Gemini CLI MCP servers](https://geminicli.com/docs/tools/mcp-server/).
**Copilot Studio:** open the agent's **Tools** page and select **Add a tool → New tool → Model Context Protocol**. Enter the Superthread URL, choose **OAuth 2.0 → Dynamic discovery**, create the connection, authorize it, then add and publish the tool.
**GitHub Copilot in VS Code:** run **MCP: Open User Configuration** from the Command Palette and add:
```json theme={null}
{
"servers": {
"superthread": {
"type": "http",
"url": "https://mcp.superthread.com/mcp"
}
},
"inputs": []
}
```
Start the server, complete OAuth, then use Copilot Chat in **Agent** mode. See Microsoft's [Copilot Studio MCP guide](https://learn.microsoft.com/en-us/microsoft-copilot-studio/mcp-add-existing-server-to-agent) and [VS Code MCP guide](https://code.visualstudio.com/docs/agent-customization/mcp-servers).
## Run a controlled import
Use this prompt after both sides are connected. Replace every value in square brackets.
```text theme={null}
Import tasks from [SOURCE] into Superthread.
Source scope: [PROJECT, BOARD, LIST, VIEW, QUERY, OR FILE]
Destination workspace: [WORKSPACE]
Destination space: [SPACE]
Destination board or project: [BOARD OR PROJECT]
Rules:
1. Read from [SOURCE], but do not change or delete anything there.
2. Inspect the destination statuses, members, priorities, and tags before mapping data.
3. Fetch the complete source scope, following every pagination cursor or next-page link.
4. Show me the source count, proposed field mapping, status mapping, and any unsupported fields before creating cards.
5. Use the original source ID and URL for duplicate detection. Put both in a "Source" footer in each card description.
6. Match assignees by email. If there is no single confident match, leave the card unassigned and report it.
7. Import parent items before children. Preserve title, description, status, priority, start date, due date, tags, and relationships where Superthread supports them.
8. Create five sample cards, then stop and show their Superthread links for review.
9. After I approve the sample, continue in batches of 25. Before each create, check that the source ID has not already been imported.
10. At the end, report created, skipped as duplicate, and failed counts, with a reason for every skipped or failed item.
```
Keep the assistant's confirmation requirement enabled. A prompt, task description, comment, or attachment from the source can contain instructions that were never intended for the assistant.
## Jira
**Recommended:** use the [built-in Jira importer](/docs/help/import-jira). It preserves more Jira-specific structure than recreating issues through an assistant.
| Assistant | Exact route |
| ----------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
| ChatGPT | Do not connect Jira for the migration. Open **Superthread → Settings → Workspace → Importers → Jira** and follow the native guide. |
| Claude | Same native importer. Claude is optional for planning the mapping, not for transferring the issues. |
| Gemini | Same native importer. Gemini is optional for checking the imported result. |
| Microsoft Copilot | Same native importer. Copilot is optional for checking the imported result. |
For a selective AI-assisted migration instead, connect the Atlassian Rovo MCP endpoint `https://mcp.atlassian.com/v1/mcp/authv2` and use the controlled-import prompt. The same connection can read Jira and Confluence. See [Atlassian's client guide](https://support.atlassian.com/atlassian-rovo-mcp-server/docs/using-with-other-supported-mcp-clients/).
## Trello
**Recommended:** use the [built-in Trello importer](/docs/help/import-trello).
| Assistant | Exact route |
| ----------------- | ------------------------------------------------------------------------------------------------------------------ |
| ChatGPT | Open **Superthread → Settings → Workspace → Importers → Trello**, authorize Trello, select the boards, and import. |
| Claude | Use the same native importer; no Claude connector is required. |
| Gemini | Use the same native importer; no Gemini connector is required. |
| Microsoft Copilot | Use the same native importer; no Copilot connector is required. |
## Shortcut
**Recommended:** use the [built-in Shortcut importer](/docs/help/import-shortcut).
| Assistant | Exact route |
| ----------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| ChatGPT | Generate the token requested by the native guide, then import from **Superthread → Settings → Workspace → Importers → Shortcut**. Do not paste the token into ChatGPT. |
| Claude | Use the same native importer. |
| Gemini | Use the same native importer. |
| Microsoft Copilot | Use the same native importer. |
Shortcut tokens are created at `https://app.shortcut.com/settings/account/api-tokens`. See the [Shortcut REST API authentication reference](https://developer.shortcut.com/api/rest/v3).
## Linear
**Source MCP URL:** `https://mcp.linear.app/mcp/readonly`
| Assistant | Exact route |
| ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
| ChatGPT | Add Linear as a second custom app using the read-only source URL, authorize it, and select both Linear and Superthread in the migration message. |
| Claude | Add Linear under **Customize → Connectors**, connect it, and enable Linear and Superthread in the chat. |
| Gemini | Add `"linear": {"httpUrl": "https://mcp.linear.app/mcp/readonly"}` alongside Superthread in Gemini CLI, restart it, then run `/mcp auth linear`. |
| Microsoft Copilot | Add Linear as a second Copilot Studio MCP tool with **OAuth 2.0 → Dynamic discovery**, or add it as an HTTP server in VS Code's `mcp.json`. |
Linear's endpoint supports OAuth 2.1 with dynamic client registration. The `/readonly` variant deliberately prevents changes to the source during migration. See the [Linear MCP documentation](https://linear.app/docs/mcp).
## Asana
**Source MCP URL:** `https://mcp.asana.com/v2/mcp`
| Assistant | Exact route |
| ----------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| ChatGPT | Connect the official Asana app, then select Asana and the published Superthread custom app in the same migration message. If your Asana workspace blocks the client, request approval from an Asana administrator. |
| Claude | Connect the official Asana app, then enable both Asana and Superthread in the chat. For Claude Code, follow Asana's registered-client setup with a client ID, client secret, and the documented localhost redirect URL. |
| Gemini | Asana does not currently document Gemini as a verified V2 MCP client. Export the Asana project as CSV and use Gemini Spark with Superthread, or use Gemini CLI with a short-lived Asana PAT stored in an environment variable and paginate the REST API. |
| Microsoft Copilot | Use GitHub Copilot in VS Code, which Asana documents directly. First create an Asana MCP app, register both VS Code redirect URLs, and keep its client ID and secret outside the repository. Add the V2 HTTP server; VS Code prompts for the credentials and completes OAuth. Configure Superthread beside it. |
Asana's V2 server uses Streamable HTTP and OAuth. Coding clients need a registered Asana MCP app with client credentials; Asana does not support Dynamic Client Registration on this endpoint. The old beta `/sse` endpoint is deprecated; do not configure a new import with it. See Asana's [MCP server guide](https://developers.asana.com/docs/using-asanas-mcp-server), [verified-client list](https://developers.asana.com/docs/mcp-clients), and [coding-client setup](https://developers.asana.com/docs/connecting-mcp-clients-to-asanas-v2-server). A [CSV export](https://help.asana.com/s/article/project-importing-and-exporting?language=en) remains the fallback when the assistant cannot register with Asana.
## ClickUp
**Source MCP URL:** `https://mcp.clickup.com/mcp`
| Assistant | Exact route |
| ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| ChatGPT | Open **Apps**, connect the ClickUp app, then select ClickUp and the Superthread developer app in the migration message. Workspace admins control availability on managed plans. |
| Claude | Add the source URL under **Customize → Connectors**, authorize ClickUp, and enable ClickUp and Superthread. |
| Gemini | Add `"clickup": {"httpUrl": "https://mcp.clickup.com/mcp"}` alongside Superthread in Gemini CLI and authenticate both servers. |
| Microsoft Copilot | In Copilot Studio, add another MCP tool with the source URL and choose **OAuth → Dynamic discovery**. In VS Code, add it as an HTTP MCP server. |
ClickUp's hosted MCP is currently public beta and supports OAuth only; an API key cannot authenticate this endpoint. ClickUp applies MCP-specific rate limits, so keep batches small and retry only failed items. See [ClickUp's MCP guide](https://developer.clickup.com/docs/connect-an-ai-assistant-to-clickups-mcp-server).
## monday.com
**Source MCP URL:** `https://mcp.monday.com/mcp`
| Assistant | Exact route |
| ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| ChatGPT | Connect monday.com from ChatGPT's app directory, then select monday.com and Superthread for the import message. |
| Claude | Add the source URL as a custom connector and complete OAuth. Enable it with Superthread. |
| Gemini | Add the source URL alongside Superthread in Gemini CLI. If client registration is rejected, configure a monday API token in an `Authorization` header instead of putting the token in the prompt. |
| Microsoft Copilot | Add the hosted MCP in Copilot Studio with OAuth dynamic discovery. In VS Code, add it as an HTTP MCP server and complete OAuth. |
The hosted server is Streamable HTTP and supports OAuth or a bearer API token. See the [monday.com MCP client guide](https://developer.monday.com/api-reference/docs/compatible-mcp-clients).
## Confluence
**Source MCP URL:** `https://mcp.atlassian.com/v1/mcp/authv2`
| Assistant | Exact route |
| ----------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| ChatGPT | Add the Atlassian endpoint as a developer-mode app, authorize the Confluence site, and select Atlassian and Superthread. |
| Claude | Add it as a custom connector, authorize Confluence, and enable it with Superthread. |
| Gemini | Add `"atlassian": {"httpUrl": "https://mcp.atlassian.com/v1/mcp/authv2"}` alongside Superthread in Gemini CLI and authenticate both servers. |
| Microsoft Copilot | Add it as a Copilot Studio MCP tool using OAuth dynamic discovery, or as an HTTP MCP server in VS Code. |
Scope the prompt to a Confluence space or parent page. Ask the assistant whether each page should become a Superthread page, project, or card before it writes anything. Atlassian retired the old `/v1/sse` endpoint after 30 June 2026; use the URL above. See [Atlassian's official guide](https://support.atlassian.com/atlassian-rovo-mcp-server/docs/using-with-other-supported-mcp-clients/).
## Notion
**Source MCP URL:** `https://mcp.notion.com/mcp`
| Assistant | Exact route |
| ----------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
| ChatGPT | Add Notion from the app directory or create a custom app using the source URL. Select Notion and Superthread in the import message. |
| Claude | Add Notion under **Customize → Connectors**, authorize the pages/databases, and enable it with Superthread. |
| Gemini | Add the source URL alongside Superthread as an `httpUrl` server in Gemini CLI and run `/mcp auth notion`. |
| Microsoft Copilot | Add it in Copilot Studio with OAuth dynamic discovery, or add it to VS Code as an HTTP MCP server. |
Scope the import to specific databases or parent pages. Notion's hosted MCP requires interactive OAuth and does not accept bearer tokens. See [Notion's connection guide](https://developers.notion.com/guides/mcp/get-started-with-mcp).
## Wrike
**Source MCP URL:** `https://mcp.wrike.com/v2`
| Assistant | Exact route |
| ----------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| ChatGPT | Prefer the Wrike app in ChatGPT's app directory: **Apps → Wrike → Connect**. On Enterprise, an owner enables, configures, and publishes it first. Select Wrike and Superthread in the import message. |
| Claude | An admin must create a Wrike OAuth app, add `https://claude.ai/api/mcp/auth_callback` as a redirect URL, then add the connector with its client ID and secret. Members then connect Wrike and enable it with Superthread. |
| Gemini | Prefer the Wrike connector in Gemini Enterprise. For Gemini CLI, create a Wrike permanent token and send it as `Authorization: Bearer` in the server configuration; Wrike does not currently provide DCR for generic clients. |
| Microsoft Copilot | In Copilot Studio, create a Wrike OAuth app, add the Wrike MCP tool with manual OAuth, then copy Copilot's generated redirect URL back into the Wrike app before connecting. |
Do not use Wrike's older `/app/mcp/stream` or `/app/mcp/sse` endpoints. See Wrike's official guides for [ChatGPT](https://developers.wrike.com/docs/setup-chatgpt-with-wrike-mcp), [Claude](https://developers.wrike.com/docs/setup-claude-with-wrike-mcp), and [Copilot Studio](https://developers.wrike.com/docs/setup-microsoft-copilot-studio-with-wrike-mcp).
## Smartsheet
**Source MCP URLs:** US `https://mcp.smartsheet.com` · EU `https://mcp.smartsheet.eu` · Australia `https://mcp.smartsheet.au`
| Assistant | Exact route |
| ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| ChatGPT | Connect the official Smartsheet Connector, then select Smartsheet and the published Superthread custom app in the same message. Smartsheet documents OAuth for ChatGPT web and mobile. |
| Claude | Connect the official Smartsheet Connector in Claude or Claude Desktop, then enable it with Superthread. Both use Smartsheet OAuth. |
| Gemini | Use Gemini CLI. Store a Smartsheet API token as `SMARTSHEET_API_TOKEN`, add the regional MCP URL with `Authorization: Bearer ${SMARTSHEET_API_TOKEN}`, and configure Superthread beside it. Smartsheet also documents OAuth for Gemini Enterprise Plus, but not a two-custom-app workflow there. |
| Microsoft Copilot | Use GitHub Copilot in VS Code with the regional MCP URL and `SMARTSHEET_API_TOKEN` supplied through an environment variable, alongside Superthread. Smartsheet documents an OAuth connector for Microsoft 365 Copilot, but not using that connector together with an arbitrary Superthread MCP server. |
Smartsheet MCP requires Business, Enterprise, or Advanced Work Management. Its official MCP documentation lists US, EU, and Australia production endpoints, but no Gov endpoint. For a token-based client, generate the token under **Account → Personal Settings → API Access** and keep it in an environment variable. See Smartsheet's [MCP installation guide](https://developers.smartsheet.com/ai-mcp/smartsheet/install-the-smartsheet-mcp-server), [ChatGPT guide](https://developers.smartsheet.com/ai-mcp/smartsheet/install-the-smartsheet-mcp-server/connect-chatgpt), and [Claude guide](https://developers.smartsheet.com/ai-mcp/smartsheet/install-the-smartsheet-mcp-server/connect-claude). On an unsupported plan or Gov instance, export the sheet as `.xlsx` or `.csv` and use the spreadsheet workflow below.
## Airtable
**Source MCP URL:** `https://mcp.airtable.com/mcp`
| Assistant | Exact route |
| ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| ChatGPT | Add Airtable as a custom app using the source URL and OAuth, restrict the authorized bases, then select Airtable and the published Superthread custom app in the same message. |
| Claude | Add Airtable as a custom connector and complete OAuth, then enable Airtable and Superthread. Airtable also documents `claude mcp add --transport http airtable https://mcp.airtable.com/mcp` for Claude Code. |
| Gemini | Add the source URL alongside Superthread in Gemini CLI. Airtable supports MCP-compatible tools, but does not currently publish a Gemini-specific setup guide; if OAuth registration fails, use a read-only PAT in the MCP configuration or export CSV. |
| Microsoft Copilot | Add the source URL as an HTTP MCP server in GitHub Copilot for VS Code. If OAuth registration is unavailable in the chosen Copilot surface, use a read-only Airtable PAT in the local MCP configuration or export CSV. |
Airtable MCP is available on all plans, uses OAuth, mirrors the connected user's Airtable permissions, and can be restricted to selected bases after authorization. Enterprise integration restrictions may require an administrator to allowlist it. For a read-only PAT fallback, grant only `data.records:read`, `schema.bases:read`, `data.recordComments:read`, and `workspacesAndBases:read`, then restrict resources to the bases being migrated. Create PATs in Airtable's **Developer Hub**; legacy API keys no longer work. See Airtable's [official MCP guide](https://support.airtable.com/articles/9897799762-using-the-airtable-mcp-server) and [PAT guide](https://support.airtable.com/articles/9934989703-creating-personal-access-tokens).
## Todoist
**Source MCP URL:** `https://ai.todoist.net/mcp`
| Assistant | Exact route |
| ----------------- | ----------------------------------------------------------------------------------------------------------------------------- |
| ChatGPT | Add Todoist from ChatGPT's app directory or create a custom app with the source URL, then select Todoist and Superthread. |
| Claude | Add the source URL under **Customize → Connectors**, authorize Todoist, and enable it with Superthread. |
| Gemini | Add `"todoist": {"httpUrl": "https://ai.todoist.net/mcp"}` alongside Superthread in Gemini CLI and authenticate both servers. |
| Microsoft Copilot | Add it as a Copilot Studio MCP tool with OAuth dynamic discovery, or as an HTTP server in VS Code. |
See the [Todoist MCP setup guide](https://developer.todoist.com/api/v1/#todoist-mcp).
## Azure DevOps
**Hosted MCP URL:** `https://mcp.dev.azure.com/{organization}`
| Assistant | Exact route |
| ----------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| ChatGPT | The hosted endpoint's Microsoft Entra flow is not documented as supported in ChatGPT. Export the Azure Boards query as CSV and attach it instead; do not paste an Azure DevOps PAT into ChatGPT. |
| Claude | Microsoft's hosted endpoint cannot currently authenticate Claude. Install Microsoft's local Azure DevOps MCP server, provide the organization and a PAT or Entra login locally, and connect Superthread in Claude Code. |
| Gemini | Use Gemini CLI with Microsoft's local Azure DevOps MCP server. The hosted endpoint may fail because it needs a supported Microsoft Entra client rather than generic DCR. |
| Microsoft Copilot | Use the hosted endpoint. Add it to Copilot Studio, or add `{"type":"http","url":"https://mcp.dev.azure.com/{organization}"}` to VS Code. Sign in with the Microsoft Entra account linked to the Azure DevOps organization. |
For a task import, restrict the source to the `wit` toolset where the client supports the `X-MCP-Toolsets: wit` header. The hosted server requires an Entra-backed Azure DevOps organization; standalone Microsoft accounts are not supported. See Microsoft's [remote Azure DevOps MCP guide](https://learn.microsoft.com/en-us/azure/devops/mcp-server/remote-mcp-server?view=azure-devops) and [local-server overview](https://learn.microsoft.com/en-us/azure/devops/mcp-server/mcp-server-overview?view=azure-devops).
## Teamwork
**Source MCP URL:** `https://mcp.ai.teamwork.com`
| Assistant | Exact route |
| ----------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| ChatGPT | After a Teamwork administrator enables MCP, add Teamwork using the source URL and OAuth. Select Teamwork and the published Superthread custom app in the same migration message. Teamwork publishes a ChatGPT-specific setup guide. |
| Claude | Add the source URL as a custom connector, sign in to Teamwork, and enable it with Superthread. Teamwork publishes a Claude-specific setup guide. |
| Gemini | Add the source URL alongside Superthread in Gemini CLI. Teamwork says Gemini and other MCP-compatible clients may work, but does not publish a Gemini-specific setup guide; export CSV if the OAuth flow is rejected. |
| Microsoft Copilot | Add Teamwork as a Copilot Studio MCP tool with the source URL and OAuth, then add Superthread as a second tool. Teamwork lists Microsoft Copilot as a verified client, although its public help page does not name a specific Copilot surface. |
Teamwork MCP is available to paid customers after an administrator enables it in Teamwork settings. It uses OAuth and the connected user's existing permissions, and supports reading, creating, and updating tasks and projects. See Teamwork's [MCP setup and capability guide](https://support.teamwork.com/projects/TeamworkAI/use-ai-assistants-teamwork-mcp) and [plan/enablement overview](https://www.teamwork.com/ai/mcp/).
## Basecamp
**Recommended source:** Basecamp's official CLI and agent skill.
| Assistant | Exact route |
| ----------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| ChatGPT | Basecamp does not yet provide a generally available hosted MCP connection for this workflow. Ask a Basecamp account owner to create an account export, attach the relevant task data, and select Superthread. |
| Claude | Install the official Basecamp CLI, run `basecamp auth login`, then `basecamp setup claude`. In Claude Code, connect Superthread and ask it to enumerate projects, to-do lists, to-dos, and card tables using JSON output. |
| Gemini | Install the Basecamp CLI, run `basecamp auth login`, and point Gemini CLI at Basecamp's official `skills/basecamp/SKILL.md`. Connect Superthread and use the controlled-import prompt. |
| Microsoft Copilot | Install the Basecamp CLI in the VS Code environment, authenticate it, and let GitHub Copilot use its JSON commands while Superthread is connected over MCP. Copilot Studio requires a custom API connector and a Basecamp OAuth application. |
macOS, Linux, and WSL2 installation:
```bash theme={null}
curl -fsSL https://basecamp.com/install-cli | bash
basecamp auth login
```
The CLI stores OAuth credentials itself; never ask the assistant to print or read its credential file. See the [official Basecamp CLI](https://github.com/basecamp/basecamp-cli) and [Basecamp 4 API](https://github.com/basecamp/bc3-api).
## GitHub Projects
**Source MCP URL:** `https://api.githubcopilot.com/mcp/`
| Assistant | Exact route |
| ----------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| ChatGPT | Prefer exporting the GitHub Project view as CSV and attaching it. The remote GitHub MCP expects a client-supplied GitHub token, which ChatGPT's custom-app form does not safely collect as an arbitrary bearer header. |
| Claude | Use Claude Code with GitHub's official local MCP server and OAuth, or a fine-grained PAT stored as `GITHUB_PERSONAL_ACCESS_TOKEN`. Enable the `projects` toolset and connect Superthread. |
| Gemini | Use Gemini CLI with GitHub's official local MCP server and OAuth/PAT. Include the `projects` toolset, and request `field_names` when listing project items so status and priority values are returned. |
| Microsoft Copilot | In VS Code, install **GitHub MCP Server** from the MCP gallery (`@mcp github`), authenticate with GitHub, switch Copilot Chat to Agent mode, and connect Superthread. |
For a classic PAT or OAuth token, reading Projects requires the `read:project` scope; a fine-grained PAT instead needs the relevant **Projects: read** permission. The MCP `projects_list` operation returns only titles unless the assistant asks for `field_names` or field IDs. See the [official GitHub MCP server](https://github.com/github/github-mcp-server) and [GitHub's VS Code setup guide](https://docs.github.com/en/copilot/how-tos/provide-context/use-mcp-in-your-ide/set-up-the-github-mcp-server?tool=vscode).
## GitLab
**Source MCP URL:** `https://gitlab.com/api/v4/mcp` or `https:///api/v4/mcp`
| Assistant | Exact route |
| ----------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| ChatGPT | GitLab supports OAuth Dynamic Client Registration, so a ChatGPT custom app is a standards-compatible route, but GitLab does not publish a ChatGPT-specific setup guide. Add the source URL only if tool scanning and OAuth both succeed; otherwise export issues as CSV and attach the file. |
| Claude | Use Claude Code, which GitLab documents directly: run `claude mcp add --transport http GitLab https:///api/v4/mcp`, then `/mcp` and authorize. Configure Superthread beside it. |
| Gemini | Add the source URL alongside Superthread in `~/.gemini/settings.json`, restart Gemini CLI, then run `/mcp auth GitLab`. GitLab documents this exact flow. |
| Microsoft Copilot | In VS Code run **MCP: Add Server**, choose **HTTP**, enter the source URL, authorize GitLab, and use GitHub Copilot Agent mode with Superthread. GitLab documents this exact flow. |
GitLab's MCP server is beta on Free, Premium, and Ultimate for GitLab.com, Self-Managed, and Dedicated. Before users can connect, an administrator must make GitLab Duo available, enable beta and experimental features, and allow MCP access. The server uses OAuth Dynamic Client Registration and Streamable HTTP. See GitLab's [official MCP guide](https://docs.gitlab.com/user/model_context_protocol/mcp_server/). If the prerequisites cannot be enabled, use GitLab's [CSV export](https://docs.gitlab.com/user/project/issues/csv_export/) or a short-lived `read_api` PAT with the [Issues API](https://docs.gitlab.com/api/issues/).
## YouTrack
**Source MCP URL:** `https://.youtrack.cloud/mcp`
| Assistant | Exact route |
| ----------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| ChatGPT | Add the source URL as a custom app if your YouTrack administrator has enabled automatic OAuth registration through CIMD or supplies a manually registered OAuth client. This is a standards-compatible path, not a JetBrains-published ChatGPT setup. If authorization fails, export the filtered issues and attach the file. |
| Claude | Add the remote server in Claude Code using OAuth. If your YouTrack instance cannot auto-register the client, ask an administrator for OAuth client credentials or store a permanent token locally and use the documented `Authorization: Bearer` header. Configure Superthread beside it. |
| Gemini | Add the source URL alongside Superthread in Gemini CLI. Use browser OAuth when client registration is available; otherwise put a permanent token in an environment-backed `Authorization` header, never in the prompt or repository. |
| Microsoft Copilot | Add the source URL as an HTTP MCP server in GitHub Copilot for VS Code. Use OAuth when YouTrack client registration is configured; otherwise use an environment-backed permanent-token header. |
The server is built into YouTrack 2025.3 and later. Its `search_issues` and `get_issue` tools are sufficient for a source-only migration; restrict the advertised tools with `?tools=search_issues,get_issue,get_issue_comments` if comments are in scope. OAuth setup depends on whether the client supports Client ID Metadata Documents (CIMD); otherwise an administrator creates an OAuth client manually. See JetBrains' [remote MCP guide](https://www.jetbrains.com/help/youtrack/cloud/model-context-protocol-server.html), [OAuth client guide](https://www.jetbrains.com/help/youtrack/cloud/oauth-clients.html), and [permanent-token guide](https://www.jetbrains.com/help/youtrack/cloud/manage-permanent-token.html).
## Redmine
**Source API:** `{Redmine URL}/issues.json`
| Assistant | Exact route |
| ----------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| ChatGPT | Filter the issue list, export CSV from Redmine, attach it, and select Superthread. Do not paste the API key into ChatGPT. |
| Claude | In Claude Code, store the key as `REDMINE_API_KEY` and paginate `/issues.json?project_id={id}&status_id=*&limit=100&offset={offset}` using the `X-Redmine-API-Key` header. |
| Gemini | Use Gemini CLI with `REDMINE_API_KEY` and the same offset pagination. |
| Microsoft Copilot | Use GitHub Copilot in VS Code with the key stored outside the repository, or add Redmine as a REST API tool in Copilot Studio. |
An administrator must enable REST web services in Redmine. Each user finds their API key on **My account**, in the right-hand pane. See the [Redmine REST API guide](https://www.redmine.org/projects/redmine/wiki/REST_Api).
## Google Sheets
1. In Google Sheets, select **File → Download → Microsoft Excel (.xlsx)**. Use **Comma-separated values (.csv)** only when the workbook has one relevant tab; CSV exports the current sheet only.
2. Make sure the first row contains clear field names such as `Title`, `Description`, `Status`, `Assignee email`, `Priority`, `Start date`, `Due date`, `Tags`, and `Source URL`.
3. Remove formulas or hidden columns that should not be sent to the assistant.
| Assistant | Exact route |
| ----------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| ChatGPT | On Business or Enterprise/Edu, attach the `.xlsx` or `.csv`, select the published Superthread custom app, and run the controlled-import prompt. ChatGPT supports both formats; full MCP write access is the plan constraint. |
| Claude | Attach the file in Claude and enable Superthread. `.csv` is supported directly; `.xlsx` requires **Code execution and file creation** to be enabled. For very large workbooks, use Claude Code with the local file and Superthread MCP. |
| Gemini | In Gemini Spark, attach the file and select `@Superthread`; spreadsheet uploads currently require Google AI Pro or Ultra. Otherwise place it in a Gemini CLI working folder with Superthread configured. |
| Microsoft Copilot | Put the file in a VS Code workspace and use GitHub Copilot Agent mode with Superthread MCP. In Copilot Studio, add the file as conversation input only if the agent's channel supports attachments. |
See Google's [spreadsheet export guide](https://support.google.com/docs/answer/9330963), OpenAI's [ChatGPT data-analysis guide](https://help.openai.com/en/articles/8437071-data-analysis-with-chatgpt), Anthropic's [file-upload guide](https://support.claude.com/en/articles/8241126-upload-files-to-claude), and Google's [Gemini file-upload guide](https://support.google.com/gemini/answer/14903178).
## Microsoft Excel
Prefer `.xlsx` because it preserves every worksheet. Use CSV only for a single active sheet and remember that CSV discards formatting, formulas, graphics, and other workbook features.
| Assistant | Exact route |
| ----------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| ChatGPT | On Business or Enterprise/Edu, attach the workbook, select the published Superthread custom app, name the worksheet(s) to import, and run the controlled-import prompt. |
| Claude | Enable **Code execution and file creation**, attach the workbook, and enable Superthread; or use Claude Code when the file is large or needs preprocessing. |
| Gemini | On Google AI Pro or Ultra, attach it in Gemini Spark and select `@Superthread`; otherwise use Gemini CLI with the local workbook. |
| Microsoft Copilot | Put the workbook in the VS Code workspace and use GitHub Copilot Agent mode with Superthread MCP. |
If you need CSV, use **File → Save As/Save a Copy → CSV** and repeat for each worksheet. See Microsoft's [CSV export guide](https://support.microsoft.com/en-us/excel/save-a-workbook-to-text-format-txt-or-csv).
## Verify the result
After the assistant reports completion:
1. Compare the source count with `created + skipped + failed`.
2. Open the five sample cards and at least five cards from later batches.
3. Check status, assignee, priority, dates, tags, parent-child relationships, and source links.
4. Search Superthread for two or three source IDs to confirm duplicate detection works.
5. Review every failure before rerunning. Do not rerun the entire import without the source-ID duplicate check.
6. Revoke temporary source tokens and disconnect source connectors that are no longer needed.
## What AI-assisted imports may not preserve
Unlike a native importer, an assistant may not preserve every source-specific feature. Review these explicitly:
* Original creator and original creation timestamp
* Complete comment history and comment authorship
* Attachments and inline images
* Automation rules, formulas, dependencies, watchers, and notifications
* Custom fields that do not have an agreed Superthread mapping
* Historical state changes and audit logs
* Permissions that differ between the source and Superthread
If any of these are essential, keep the source available as an archive and include the original item URL on every imported card.