# Taskade Genesis App URLs: Which Link to Share

> Tell the two Taskade URL families apart. Public share links (/app, /kit, /a, /p, /flow) are what you send to visitors. Workspace links (/spaces, /d, /flows) are where you build.

- Source: https://www.taskade.com/learn/genesis/genesis-urls
- Section: Taskade Genesis
- Updated: 2026-10-30
- Index of all pages: https://www.taskade.com/learn/llms.txt

## Overview

Taskade links come in two families. The whole skill is to tell them apart. **Public share links** are the ones you send to a customer. **Workspace links** are the ones your browser shows while you build, and they need a Taskade account to open. If you copy the wrong one, your visitor lands on a sign-in screen instead of your app.

> **TL;DR:** A published Taskade Genesis app lives on its own web address, either the one Taskade generates for you (something like `your-app.taskade.app`) or your custom domain. To share the app's public listing page use `taskade.com/app/{name}-{id}`, and for a kit use `taskade.com/kit/{name}-{id}`. The `/spaces/{spaceId}` link in your address bar is the builder, not the front door. See [Publishing apps](https://www.taskade.com/learn/genesis/publishing).

## Tell the two families apart

Scan this box first. Everything above the line is safe to paste into an email. Everything below it opens the builder and asks for a login.

```text
┌───────────────────────────────────────────────────────────────────────┐
│  PUBLIC: safe to share with anyone                                    │
├───────────────────────────────────────────────────────────────────────┤
│  Published app     your-app.taskade.app  (or your custom domain)      │
│                    share when…  people should USE the live app        │
│  App listing       taskade.com/app/{name}-{id}                        │
│                    share when…  people should SEE the app listing     │
│  Kit               taskade.com/kit/{name}-{id}                        │
│                    share when…  people should INSTALL a whole bundle  │
│  AI agent          taskade.com/a/{name}-{id}                          │
│                    share when…  people should CHAT with your agent    │
│  Public project    taskade.com/p/{name}-{id}                          │
│                    share when…  people should READ a project          │
│  Creator profile   taskade.com/@{handle}                              │
│                    share when…  people should FOLLOW you              │
├───────────────────────────────────────────────────────────────────────┤
│  WORKSPACE: needs a Taskade account                                   │
├───────────────────────────────────────────────────────────────────────┤
│  Workspace/app     taskade.com/spaces/{spaceId}                       │
│  Project           taskade.com/d/{projectId}                          │
│  Automation        taskade.com/flows/{flowId}                         │
└───────────────────────────────────────────────────────────────────────┘
```

## Know what each public link does

Every public share link follows the same recipe: the kind of thing, a readable name, then its id. So `taskade.com/app/client-portal-01JK82XFM2` is the app named Client Portal. The readable part is there for humans and for search results. The id at the end is what Taskade reads.

```mermaid
graph TD
    APP[/"/app/{name}-{id}<br/>Published app"/]:::pub --> LIVE[Live app<br/>on its own domain]:::out
    KIT[/"/kit/{name}-{id}<br/>Kit"/]:::pub --> INST[Install into<br/>your workspace]:::out
    AGENT[/"/a/{name}-{id}<br/>AI agent"/]:::pub --> CHAT[Chat page<br/>or embed widget]:::out
    PROJ[/"/p/{name}-{id}<br/>Public project"/]:::pub --> READ[Read-only<br/>project page]:::out
    classDef pub fill:#2a1225,color:#ff8fa3,stroke:#ff2d60,stroke-width:2px
    classDef out fill:#11111b,color:#cdd6f4,stroke:#475569
```

| Public link | What it points to | Share it when |
| --- | --- | --- |
| Your app's own domain | The running app itself | Someone wants to use the app |
| `/app/{name}-{id}` | The app's listing page, with a Clone button when the creator shared it as a template | Someone wants to look at the app first, or copy it when the creator allows |
| `/kit/{name}-{id}` | A kit: projects, agents, and automations bundled together | Someone wants to install a whole setup at once |
| `/a/{name}-{id}` | A public AI agent's chat page | Someone wants to talk to your agent |
| `/p/{name}-{id}` | A published, read-only project | Someone wants to read a project without editing it |
| `/form/{name}-{id}` | A published form | Someone wants to fill in a form |
| `/flow/{name}-{id}` | A shared automation others can copy | Someone wants to reuse your automation |
| `/@{handle}` | Your creator profile and everything you have published | Someone wants to follow you or browse your work |

`/app` links work one more way. Cloning is the creator's choice, set with **Let others clone** in the Publish menu. A free or paid kit opens a listing page with the Clone button. A public app that is not a kit forwards to the running app.

## Recognize the builder links

These three are the ones your address bar shows while you work. They are perfectly good for a teammate who is already in your workspace, and wrong for a customer.

| Workspace link | What it opens |
| --- | --- |
| `/spaces/{spaceId}` | The workspace, including the Taskade Genesis app builder |
| `/d/{projectId}` | One project, in whichever [Project View](https://www.taskade.com/learn/projects/project-views) you set as default |
| `/flows/{flowId}` | One automation, in the editor |

The rule of thumb: `/spaces`, `/d`, and `/flows` are builder links. Everything in the public table is safe to send out.

## When to share which

Pick by intent, not by what is open in your browser tab. Start at your goal and follow the arrow.

```mermaid
flowchart TD
    G{What should<br/>they do?} -->|Use the app| A[Send your app's<br/>own domain]:::pink
    G -->|Copy the app| B["Send /app/{name}-{id}"]:::pink
    G -->|Install a bundle| C["Send /kit/{name}-{id}"]:::amber
    G -->|Chat with an agent| D["Send /a/{name}-{id}"]:::blue
    G -->|Follow your work| E["Send /@{handle}"]:::purple
    classDef pink fill:#2a1225,color:#ff8fa3,stroke:#ff2d60,stroke-width:2px
    classDef blue fill:#0d1b2a,color:#7dd3fc,stroke:#38bdf8,stroke-width:1.5px
    classDef amber fill:#1a140a,color:#ffb74d,stroke:#e65100,stroke-width:1.5px
    classDef purple fill:#1a0d24,color:#ce93d8,stroke:#6a1b9a,stroke-width:1.5px
    style G fill:#1e1e2e,color:#94a3b8,stroke:#475569,stroke-width:1.5px
```

1. **To let someone use your app**, send the app's own web address. If you have a custom domain, send that instead. They land on the live app.
2. **To let someone look at the app before they commit**, send the `/app` link. It shows the listing page and a Clone button for a free or paid App Kit. Otherwise, the link forwards to the live app.
3. **To hand over a whole working setup**, send the `/kit` link. A kit install brings the projects, agents, and automations inside it into their own workspace. See [Community Kits](https://www.taskade.com/learn/genesis/community-kits).
4. **To let an outside system start your automation**, use the webhook address from the automation itself. A webhook is a private web address that another system pings to start a run. It belongs to the automation, not to any of these links.

## Keep old links working

You do not have to hunt down links you already sent. Taskade forwards the older shapes to the current ones automatically.

| Older link | Where it lands now |
| --- | --- |
| `taskade.com/share/apps/{id}` | The `/app/{name}-{id}` listing page |
| `taskade.com/k/{id}` | The `/kit/{name}-{id}` page |
| `taskade.com/bundle/{id}` | The same kit page |

The readable name in a link is decoration. Drop it, keep the id, and the link still resolves. That is why an old bookmark or a link with a stale name keeps working after you rename something.

A [custom domain](https://www.taskade.com/learn/genesis/custom-domains) gives the app a second front door on your own name. The address Taskade generated for it keeps working too.

## Know which control is doing the work

The shape of a link and who can open it are separate things. Every link respects the access settings on the thing it points to.

- The [role you give them](https://www.taskade.com/learn/account/roles-permissions) gates workspace members, from Owner down to Viewer.
- You manage the people who sign in to a published app in [App Users](https://www.taskade.com/learn/genesis/app-users).
- You set password protection and sign-in requirements per app in [Publishing apps](https://www.taskade.com/learn/genesis/publishing).
- An app featured in the [Taskade App Factory](https://www.taskade.com/learn/genesis/community-gallery) uses the same links as the private build.

Whether a leaked URL grants access depends on which control you set. A draft does not open from outside your workspace. An app that asks for a password, or one where each person signs in, checks the visitor, so the link alone is not enough. An app open to **Anyone with the link** is different: it is unlisted and hidden from search, but the link *is* the key. Treat that URL like a password. The first build of a new app goes live this way, unlisted. It stays a draft only when it has a sign-in screen and you did not choose who can open it. Use a password or sign-in for anything you do not want forwarded.

## Related guides

- [Publishing apps](https://www.taskade.com/learn/genesis/publishing). Visibility, passwords, and the publish flow
- [App SEO](https://www.taskade.com/learn/genesis/app-seo). Make the published address findable in search
- [Custom Domains](https://www.taskade.com/learn/genesis/custom-domains). Put the app on your own name
- [Community Kits](https://www.taskade.com/learn/genesis/community-kits). What a kit contains and how installing works
- [App Users](https://www.taskade.com/learn/genesis/app-users). Manage who signs in to a published app
- [Taskade App Factory](https://www.taskade.com/learn/genesis/community-gallery). Publish so other makers can find your work
- [App Gallery](https://www.taskade.com/learn/genesis/app-gallery). Browse apps you can clone