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

# Leave a computer shared with you

> For someone the computer is shared with, with their own sign-in. Removes the caller's own access exactly as the owner removing them would (DELETE /api/computers/{id}/shares/{membership_id}): their access ends at once. A public computer still opens by its address; a private one needs a new invitation from the owner.



## OpenAPI

````yaml https://www.cool.computer/openapi.json delete /api/computers/{id}/membership
openapi: 3.1.0
info:
  title: Cool Computers API
  version: 1.0.0
  description: >-
    Create and operate reachable computers. Each computer keeps a stable
    name.cool.computer address, persistent files, and agent-ready command
    execution. REST requests use UTC-aligned one-minute limits: 600 requests per
    account identified by a recognized valid account bearer credential, a
    separate 600-request budget per computer-scoped credential, a separate
    600-request browser budget per account for a browser session's same-origin
    app API requests and another for its document routes, or 60 requests per
    source IP otherwise (IPv6 addresses share their /64 network allowance).
    Read-only GETs answered from API state spend a separate read budget reported
    as account-read or computer-read, so status polling cannot exhaust the
    budget that protects work and mutations. To bound authentication-provider
    traffic, at most 60 first-seen credentials (bearers or browser cookies) are
    checked per source IP (IPv6 /64) in a minute; recognized valid credentials
    use their account or computer policy. Account bearer and browser-cookie
    authentication is reused for at most five seconds, with one shared
    validation for concurrent requests; transient provider failures are not
    cached. Computer tokens retain recognition for admission, but every
    authorized request checks their current database credential generation.
    Revoking a credential through this API (POST /api/auth/logout or DELETE
    /api/api-keys/{id}) fences it in every listening process. WorkOS holds
    shared session revocation state. A restarted process checks afresh; a missed
    notification leaves at most five seconds of credential reuse. If WorkOS
    cannot answer a revalidation, retry after the 503 response. JSON request
    bodies must be sent with Content-Type: application/json; any other body
    answers 415 unsupported_media_type. A request that gives a published site
    its own VM (POST /api/computers/{id}/vm, POST
    /api/computers/{id}/service/run, or a publish whose cool.json declares run)
    answers with a Cool-Notice header saying that the site now runs there and
    cool.json no longer applies; exec, terminals, the port proxy and exposure
    never give one and answer 409 needs_vm on a site with no VM. Every error is
    an application/problem+json object whose type links to
    https://cool.computer/docs/api-reference/errors; a malformed body names the
    unknown field, the wrong type, or the byte where the JSON breaks. Non-exempt
    API responses include the structured RateLimit and RateLimit-Policy fields;
    request admission 429 responses use code api_request_rate_exceeded and also
    include Retry-After. Health is exempt and shares its observation for one
    second. Browser sign-in routes under /auth/, including callbacks and logout,
    spend the existing source budget when called without a bearer. Other cookie
    requests without a same-origin signal retain the source budget, except
    document routes. Comment writes and steps sent without an Authorization
    header spend their own 60-request budget per source IP (comment-write).
    OpenAPI, provider webhooks, SSE, and WebSocket endpoints are exempt from the
    REST request budget. Anonymous counter saturation does not consume
    authenticated accounts' counter capacity; each scope has its own capped map,
    and new keys in a full map are refused until the next window. Authenticated
    SSE connection attempts remain subject to the authentication safeguards and
    can receive the same typed 429 response.
servers:
  - url: https://api.cool.computer
    description: Canonical API origin
security: []
tags:
  - name: Authentication
    description: Obtain and manage bearer credentials.
  - name: Billing
    description: >-
      Inspect and manage the account's plan: Free (sites with no VM, at most 20
      at once) or Pro (adds VMs and any number of sites).
  - name: Computers
    description: Create, inspect, and delete resident computers.
  - name: Execution
    description: Run commands on a computer.
  - name: Files
    description: Read and change a computer's persistent files.
  - name: Publishing
    description: >-
      Publish files to a computer's URL as immutable releases, with no VM. To
      show something, publish the files; to run something, give the site its own
      VM with POST /api/computers/{id}/vm or start a service with POST
      /api/computers/{id}/service/run, then use exec, terminals and services.
  - name: Services
    description: >-
      Manage processes and select the HTTP port exposed at a computer's stable
      address.
  - name: Email
    description: Read and send mail through a computer's inbox.
  - name: Comments
    description: >-
      Comments people leave on a computer's page, unless its owner switched
      comments off: the owner, the people it is shared with and, when the
      computer is public, any signed-in person. A comment is content; the
      owner's agents (Operator, or any agent with the owner's credential) pull
      the open comments and answer them, and the owner hands chosen comments as
      a job with POST /api/computers/{id}/comments/ask to Operator, or to the
      owner's own coding agent while it listens on the site with POST
      /api/computers/{id}/comments/watch (one listening session per site; it
      claims the job by pulling it, and Operator takes the job over when it goes
      quiet).
  - name: Network
    description: Control a computer's public visibility and outbound network policy.
  - name: Sharing
    description: Invite people to use a computer without granting owner controls.
  - name: Domains
    description: >-
      Serve a computer at a hostname you control, such as app.example.com,
      beside its own address.
  - name: Public
    description: Unauthenticated endpoints.
  - name: Secrets
    description: Inspect secret sets and their audit history; values are never returned.
  - name: Integrations
    description: Connect, inspect and revoke outside service accounts.
  - name: GitHub
    description: Work with repository workspaces using the connected user account.
  - name: Messaging
    description: >-
      Connect Telegram, Slack or WhatsApp so direct messages, and mentions of
      the Slack app in a channel, become chat turns.
  - name: Terminals
    description: Inspect a computer's terminal sessions.
  - name: Operator
    description: Read the operator agent's conversations, turns, and events.
  - name: Feedback
    description: >-
      Tell the Cool Computers team what works and what does not, with or without
      an account.
externalDocs:
  description: Cool Computers agent registration guide
  url: https://www.cool.computer/auth.md
paths:
  /api/computers/{id}/membership:
    delete:
      tags:
        - Sharing
      summary: Leave a computer shared with you
      description: >-
        For someone the computer is shared with, with their own sign-in. Removes
        the caller's own access exactly as the owner removing them would (DELETE
        /api/computers/{id}/shares/{membership_id}): their access ends at once.
        A public computer still opens by its address; a private one needs a new
        invitation from the owner.
      operationId: leaveComputer
      parameters:
        - $ref: '#/components/parameters/ComputerID'
      responses:
        '204':
          headers:
            RateLimit:
              $ref: '#/components/headers/RateLimit'
            RateLimit-Policy:
              $ref: '#/components/headers/RateLimit-Policy'
          description: Access removed.
        '400':
          headers:
            RateLimit:
              $ref: '#/components/headers/RateLimit'
            RateLimit-Policy:
              $ref: '#/components/headers/RateLimit-Policy'
          description: >-
            Bad Request. `owner_not_removable`: the caller owns the computer;
            delete it instead.
          content:
            application/problem+json:
              schema:
                $ref: '#/components/schemas/Problem'
        '401':
          $ref: '#/components/responses/Unauthorized'
        '404':
          headers:
            RateLimit:
              $ref: '#/components/headers/RateLimit'
            RateLimit-Policy:
              $ref: '#/components/headers/RateLimit-Policy'
          description: >-
            Not Found: the computer does not exist or is not shared with the
            caller.
          content:
            application/problem+json:
              schema:
                $ref: '#/components/schemas/Problem'
        '429':
          $ref: '#/components/responses/TooManyRequests'
        '500':
          $ref: '#/components/responses/InternalServerError'
      security:
        - bearerAuth: []
components:
  parameters:
    ComputerID:
      name: id
      in: path
      required: true
      description: >-
        The computer's name, such as agent-atlas, or its id (cmp_…). Every
        caller may use either, the computer's own runtime token included.
      schema:
        type: string
        minLength: 1
        example: agent-atlas
  headers:
    RateLimit:
      description: >-
        The applied policy name, requests remaining after this request, and
        whole seconds until the current UTC-aligned window resets.
      schema:
        type: string
        pattern: >-
          ^"(account|account-read|computer|computer-read|browser|browser-read|document|source|comment-board|comment-live|comment-write)";r=[0-9]+;t=([1-9]|[1-5][0-9]|60)$
        examples:
          - '"account";r=599;t=42'
          - '"computer-read";r=598;t=42'
    RateLimit-Policy:
      description: >-
        The selected policy name, quota, and window in seconds. Valid account
        credentials use account or account-read with q=600, computer credentials
        use computer or computer-read with q=600, a browser session uses browser
        or browser-read with q=600 on the website's same-origin requests and
        document with q=600 on document routes, unauthenticated or unrecognized
        requests use source with q=60 for their source IP, a request without an
        Authorization header reading a comment board uses comment-board with
        q=300 for its source IP, writing to comments (the comment layer's writes
        and steps) uses comment-write with q=60 for its source IP, and a browser
        session's handshake of a comment live channel uses comment-live with
        q=60 for its source IP.
      schema:
        type: string
        pattern: >-
          ^("(account|account-read|computer|computer-read|browser|browser-read|document)";q=600|"(source|comment-live|comment-write)";q=60|"comment-board";q=300);w=60$
        examples:
          - '"account";q=600;w=60'
          - '"computer-read";q=600;w=60'
    Retry-After:
      description: >-
        Whole seconds to wait after an api_request_rate_exceeded,
        comment_rate_exceeded, comment_site_rate_exceeded, comment_live_full or
        computer_starting response before retrying (up to 3600 for
        comment_site_rate_exceeded, whose window is an hour). Other 429 problem
        codes describe separate resource or provider limits and do not inherit
        this retry value.
      schema:
        type: integer
        minimum: 1
        maximum: 3600
        examples:
          - 42
  schemas:
    Problem:
      type: object
      additionalProperties: false
      required:
        - type
        - title
        - status
        - code
        - detail
      properties:
        type:
          type: string
          format: uri
          description: >-
            https://cool.computer/docs/api-reference/errors, the page that
            explains every code.
        title:
          type: string
        status:
          type: integer
          minimum: 400
          maximum: 599
        code:
          type: string
          pattern: ^[a-z0-9_]+$
        detail:
          type: string
        resolution:
          type: string
        context:
          type: object
          additionalProperties: true
        suggestions:
          type: array
          items:
            type: string
          maxItems: 3
          description: >-
            Values to send instead. With name_taken: up to three free names made
            from the requested one, the first with a random suffix; each was
            free when the answer was made.
  responses:
    Unauthorized:
      headers:
        RateLimit:
          $ref: '#/components/headers/RateLimit'
        RateLimit-Policy:
          $ref: '#/components/headers/RateLimit-Policy'
      description: Unauthorized.
      content:
        application/problem+json:
          schema:
            $ref: '#/components/schemas/Problem'
    TooManyRequests:
      headers:
        RateLimit:
          $ref: '#/components/headers/RateLimit'
        RateLimit-Policy:
          $ref: '#/components/headers/RateLimit-Policy'
        Retry-After:
          $ref: '#/components/headers/Retry-After'
      description: >-
        Too Many Requests. If the problem code is api_request_rate_exceeded,
        wait for Retry-After seconds; other problem codes describe a separate
        limit.
      content:
        application/problem+json:
          schema:
            $ref: '#/components/schemas/Problem'
    InternalServerError:
      headers:
        RateLimit:
          $ref: '#/components/headers/RateLimit'
        RateLimit-Policy:
          $ref: '#/components/headers/RateLimit-Policy'
      description: Internal Server Error.
      content:
        application/problem+json:
          schema:
            $ref: '#/components/schemas/Problem'
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      bearerFormat: WorkOS user or agent access token, or Cool Computers API key
      description: >-
        A Cool Computers API key, user access token, or claimed agent access
        token in the Authorization header. Follow
        https://www.cool.computer/auth.md for agent registration and
        https://www.cool.computer/authentication.md for direct user credentials.

````

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