> ## Documentation Index
> Fetch the complete documentation index at: https://docs.atako.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Archive a project (never deletes)

> Sets `archivedAt`. A real delete would cascade through the board, the cards, the comments and the whole wiki history — what the team learned would go with what it had left to do. Company admins and the project's creator only.



## OpenAPI

````yaml /api-reference/openapi.json delete /projects/{id}
openapi: 3.1.0
info:
  title: Atako API
  version: 0.1.0
  description: >-
    The Atako customer API — manage AI agents, their files, integrations,
    billing, and your company/team, programmatically.


    ## Authentication


    Every non-public endpoint takes a Bearer token that is either:

    - a **programmatic API key** (`aik_…`) — create one at
    [app.atako.ai](https://app.atako.ai) → Settings → API keys (company-admin
    only), or

    - a **Supabase session JWT** — what the web app itself sends; not practical
    to obtain outside a browser session.


    ```bash

    curl https://api.atako.ai/agents -H "Authorization: Bearer aik_..."

    ```


    An API key acts as its owning user, within the limits of the key:


    - **Scope** — a `read` key can only call GET operations (any other verb:
    `403 API_KEY_READ_ONLY`); a `write` key can call everything its user can,
    except the operations below.

    - **Forbidden to every key** — billing changes (every non-GET
    `/subscriptions/*`), minting agent tokens, listing or managing API keys
    (every `/users/api-keys` operation), deleting the account: `403
    API_KEY_FORBIDDEN`. These need a signed-in user in the app.

    - **Expiry** — optional (30, 90 or 365 days); an expired key gets `401
    API_KEY_EXPIRED`.


    Each operation carries `x-atako-api-key: read | write | forbidden` — the
    minimum key scope it needs, or `forbidden`.


    ## Live events


    `GET /notifications/sse` and `GET /agents/{agentId}/events` are Server-Sent
    Events streams (`text/event-stream`), authenticated with the same Bearer
    header — an API key works.


    ## Uploading a file


    Two steps: `POST /client/files/nodes` then `POST
    /client/files/{nodeId}/upload-url` return a signed storage URL; `PUT` the
    raw bytes to it, then call `POST /client/files/{nodeId}/complete-upload`.
    Grant it to an agent with `POST /agents/{agentId}/file-grants`.


    ## Other Atako HTTP surfaces (not covered by this spec)


    - **Atako MCP server** — `POST /mcp` (auth: same Bearer token as above)
    exposes the same capabilities as Model Context Protocol tools for AI clients
    (Claude Code, Claude Desktop, Cursor, ChatGPT), grouped in toolsets
    (`/mcp?toolsets=projects,agents`); a `read` key only gets read-only tools.
    See
    [docs.atako.ai/developers/mcp/overview](https://docs.atako.ai/developers/mcp/overview).

    - **Content API** (`cak_…` key, `/content/*`) — a separate, more restricted
    key type for headless CMS-style access to blog/news/use-case content. Not
    documented here.


    ## Errors


    Errors use a JSON envelope: `{ "error": string, "code"?: string }`. `error`
    is either a short human-readable message or a SCREAMING_SNAKE_CASE code,
    depending on the route — treat it as an opaque string to match against, not
    a stable enum across the whole API.


    ## Rate limits


    Authenticated routes: 6000 requests/min per user (`authRateLimit`). Public
    GET routes: 60/min per IP. A handful of sensitive public POST routes
    (newsletter signup, email-exists, invitation preview) are limited to 10
    requests / 15 min per IP.


    ## Pagination


    List endpoints use either simple `limit`/`offset` query params (marketing
    content — a plain JSON array response, capped at the documented max) or
    `page`/`limit` (credit transactions). Neither returns a total count today;
    fetch until a page comes back shorter than `limit`.
servers:
  - url: https://api.atako.ai
    description: Production
security: []
tags:
  - name: Agents
  - name: Messages
  - name: Activity
  - name: Agent Options
  - name: API Keys
  - name: Files
  - name: Cron Jobs
  - name: Sub-Agents
  - name: Interagent Messages
  - name: Integrations
  - name: Subscriptions
  - name: Users
  - name: Company
  - name: Teams
  - name: Floor
  - name: Search
  - name: Notices
  - name: Organization
  - name: Projects
  - name: Notifications
  - name: Agent Shared Items
  - name: Agent Email
  - name: Agent Webhooks
  - name: Company Dashboard
  - name: LLM Provider Keys
  - name: Public
  - name: Marketing Content
paths:
  /projects/{id}:
    delete:
      tags:
        - Projects
      summary: Archive a project (never deletes)
      description: >-
        Sets `archivedAt`. A real delete would cascade through the board, the
        cards, the comments and the whole wiki history — what the team learned
        would go with what it had left to do. Company admins and the project's
        creator only.
      operationId: archiveProject
      parameters:
        - name: id
          in: path
          required: true
          description: Project id
          schema:
            type: string
            format: uuid
      responses:
        '200':
          description: The archived project.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Project'
        '400':
          description: Malformed project id.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '401':
          description: >-
            Missing, malformed, or invalid bearer token / API key, or revoked
            session (SESSION_REVOKED).
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '403':
          description: The caller does not have the required role/permission.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '404':
          description: Not found, or the caller is not authorized to access this resource.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
      security:
        - bearerAuth: []
components:
  schemas:
    Project:
      type: object
      description: >-
        A project and everything on it, in one read. A card has no status — its
        state IS the column it stands in — and the wiki is a tree of pages, each
        carrying snapshots of its own past.
      properties:
        id:
          type: string
          format: uuid
        name:
          type: string
        description:
          type: string
        tone:
          $ref: '#/components/schemas/ProjectTone'
        status:
          $ref: '#/components/schemas/ProjectStatus'
        spaceId:
          type: string
          format: uuid
          nullable: true
          description: The project's space (see GET /projects/spaces); null = no space.
        space:
          type: string
          nullable: true
          maxLength: 60
          description: Name of the space (joined from `spaceId`); null = no space.
        owner:
          type: string
        createdAt:
          type: string
          format: date-time
        updatedAt:
          type: string
          format: date-time
        archivedAt:
          type: string
          format: date-time
          nullable: true
        participants:
          type: array
          items:
            $ref: '#/components/schemas/ProjectParticipant'
        columns:
          type: array
          items:
            $ref: '#/components/schemas/ProjectColumn'
          description: Ordered by position.
        cards:
          type: array
          description: >-
            Non-archived cards, ordered by column then position, each with its
            labels, checklist and comments. The embedded comments carry no `id`
            here (only author/at/text) — the comment operations return the full
            ProjectCardComment.
          items:
            $ref: '#/components/schemas/ProjectCard'
        wiki:
          type: array
          description: >-
            Root pages of the wiki, each carrying its own `children` subtree and
            its `history` (newest revision first).
          items:
            $ref: '#/components/schemas/ProjectWikiPage'
      required:
        - id
        - name
        - description
        - tone
        - status
        - spaceId
        - space
        - owner
        - createdAt
        - updatedAt
        - archivedAt
        - participants
        - columns
        - cards
        - wiki
    Error:
      type: object
      description: >-
        Atako's standard error envelope. `error` is either a short
        human-readable message or a SCREAMING_SNAKE_CASE code (routes are
        inconsistent about which — treat it as an opaque string and match on it
        exactly if you need to branch on error type). Some routes add extra
        fields alongside `error` (see the operation's own error responses).
      properties:
        error:
          type: string
        code:
          type: string
          description: >-
            Present on some routes; a stable machine-readable code duplicating
            or refining `error`.
      required:
        - error
      additionalProperties: true
    ProjectTone:
      type: string
      enum:
        - amber
        - mint
        - periwinkle
        - plum
        - blush
    ProjectStatus:
      type: string
      enum:
        - active
        - paused
        - done
    ProjectParticipant:
      type: object
      description: >-
        Somebody on the project — a human or an agent, both held the same way so
        a card can be assigned to either. `id` is the project_members row id
        (that is what a card's `assignee` points at), NOT the user/agent id.
        `kind` is derived from the row (agent_id set ⇒ agent), never stored.
      properties:
        id:
          type: string
          format: uuid
        name:
          type: string
        role:
          type: string
          description: >-
            Free text shown on the card ("Chef de projet"…) — unrelated to
            platform permissions.
        kind:
          type: string
          enum:
            - human
            - agent
        memberRef:
          type: string
          format: uuid
          description: >-
            The user id (human) or agent id — stable across projects, unlike
            `id`.
        photo:
          type: string
          nullable: true
          description: >-
            The person's own profile picture (`users.photo`), null when they
            have not uploaded one — and always null for an agent, which has no
            face. Never a stand-in: a participant without a photo is shown by
            their initials.
      required:
        - id
        - name
        - role
        - kind
        - photo
    ProjectColumn:
      type: object
      description: >-
        One column of a project's board. Columns belong to the project — Atako
        imposes no global set of states — so `kind` is how the rest of the
        interface knows which column means finished without hard-coding a name.
      properties:
        id:
          type: string
          format: uuid
        name:
          type: string
        kind:
          $ref: '#/components/schemas/ProjectColumnKind'
      required:
        - id
        - name
        - kind
    ProjectCard:
      type: object
      description: >-
        A unit of work on the board. It carries no status field: where the card
        stands IS its state, so read `column`. `blocked` and `due` are absent
        rather than null when unset — asking whether a card is blocked is asking
        for the reason.
      properties:
        id:
          type: string
          format: uuid
        title:
          type: string
          maxLength: 500
        description:
          type: string
          maxLength: 20000
        assignee:
          type: string
          format: uuid
          nullable: true
          description: >-
            A ProjectParticipant id (project_members row) — human or agent, both
            assignable — or null when nobody has taken the card.
        column:
          type: string
          format: uuid
          description: 'The column the card stands in: its state.'
        priority:
          $ref: '#/components/schemas/ProjectCardPriority'
        blocked:
          type: string
          maxLength: 500
          description: >-
            Why the card cannot move. Absent when it is not blocked — there is
            no blocked flag, only the reason.
        labels:
          type: array
          items:
            type: string
            maxLength: 40
        createdAt:
          type: string
          format: date-time
        updatedAt:
          type: string
          format: date-time
        due:
          type: string
          format: date-time
          description: Absent when the card has no deadline.
        checklist:
          type: array
          items:
            $ref: '#/components/schemas/ProjectCardChecklistItem'
        comments:
          type: array
          items:
            $ref: '#/components/schemas/ProjectCardComment'
          description: >-
            Oldest first — a discussion is read in the order it was written, not
            like an inbox.
      required:
        - id
        - title
        - description
        - assignee
        - column
        - priority
        - labels
        - createdAt
        - updatedAt
        - checklist
        - comments
    ProjectWikiPage:
      type: object
      description: >-
        A wiki page the way GET /projects/{id} embeds it — the whole tree in one
        read, every page with its current text and the SUMMARY of its history
        (metadata only, no revision text — perf(projects-cron), PLAN-perf.md
        E3). The wiki operations return the richer ProjectWikiPageDetail
        instead, whose `history` still carries each revision's full text.
      properties:
        id:
          type: string
          format: uuid
        title:
          type: string
        path:
          type: string
        content:
          type: string
        history:
          type: array
          items:
            $ref: '#/components/schemas/ProjectWikiRevisionSummary'
          description: Newest first.
        children:
          type: array
          items:
            $ref: '#/components/schemas/ProjectWikiPage'
      required:
        - id
        - title
        - path
        - content
        - history
        - children
    ProjectColumnKind:
      type: string
      enum:
        - backlog
        - active
        - review
        - done
    ProjectCardPriority:
      type: string
      enum:
        - low
        - normal
        - high
    ProjectCardChecklistItem:
      type: object
      description: >-
        One line of a card's checklist — the small steps a card is made of,
        ticked off without splitting it into more cards.
      properties:
        text:
          type: string
          minLength: 1
          maxLength: 500
        done:
          type: boolean
      required:
        - text
        - done
    ProjectCardComment:
      type: object
      description: >-
        A message on a card — where the discussion that led to a decision stays
        attached to the work it decided. `author` is the display name frozen
        when the comment was written, so someone leaving the company never
        empties the thread behind them. `id` is present on everything the card
        operations return; the copy embedded in GET /projects/{id} carries only
        author/at/text.
      properties:
        id:
          type: string
          format: uuid
        author:
          type: string
        at:
          type: string
          format: date-time
        text:
          type: string
          maxLength: 10000
      required:
        - author
        - at
        - text
    ProjectWikiRevisionSummary:
      type: object
      description: >-
        A revision's metadata, without its text (perf(projects-cron),
        PLAN-perf.md E3) — what GET /projects/{id} embeds for every page's
        history, since that single read already returns the whole project and
        every revision's full Markdown on top of that made it arbitrarily large.
        `size` is the text's length in characters, computed in SQL so it never
        travels over the wire; the text itself is a separate, on-demand read
        (GET /projects/{id}/wiki/{pageId}/revisions/{revisionId}).
      properties:
        id:
          type: string
          format: uuid
        sha:
          type: string
          description: Short content fingerprint, as Git displays one.
        at:
          type: string
          format: date-time
        author:
          type: string
        message:
          type: string
          maxLength: 500
          description: Why the page was written, in the spirit of a commit message.
        size:
          type: integer
          description: Length of this revision's content, in characters.
      required:
        - id
        - sha
        - at
        - author
        - message
        - size
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: >-
        An `aik_…` programmatic API key (app.atako.ai → Settings → API keys) or
        a Supabase session JWT.

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.