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

# Put a withdrawn proposal back

> Requires `radar:write`.



## OpenAPI

````yaml https://api.gpuoutlet.ai/v1/openapi.yaml post /radar/submissions/{id}/republish
openapi: 3.1.0
info:
  title: GPU Outlet Partner API
  version: 2.0.0
  description: >
    Programmatic access to the GPU Outlet introduction marketplace: state what
    capacity your company needs, read the opportunities offered to you, follow
    the introductions you are party to, and consult Radar.


    **Authentication.** Every endpoint except this document requires
    `Authorization: Bearer gpk_…`. Mint a key in your dashboard under Settings →
    API keys. The key is shown once, at creation, and is not recoverable — we
    store only its hash.


    **Company context.** A key belongs to a person; the company and the role the
    call acts with are that person's company membership, exactly as in the
    dashboard. A key whose owner is in no company gets `company_required`; a
    role short of the action gets `forbidden_role`. Nothing in a request body
    can name a company.


    **Scopes.** Each endpoint names the scope it needs. A key carries the scopes
    it was minted with and cannot grow one later; a key without the required
    scope gets `insufficient_scope` with `required_scope` in the error.


    **Idempotency.** Every `POST`, `PUT` and `PATCH` under Requests,
    Opportunities and Introductions **requires** `Idempotency-Key`. Generate one
    per intent (a UUID is fine) and reuse it verbatim on every retry of that
    same request: you get the original response back, marked
    `Idempotency-Replayed: true`, and nothing is written twice. The same key
    with a different body is `idempotency_key_reused`; a key whose first attempt
    is still running is `idempotency_key_in_flight` with `Retry-After`. Keys are
    remembered for 24 hours. Radar writes accept the header and echo it but do
    not require it.


    **Rate limits.** Every response carries `RateLimit-Limit`,
    `RateLimit-Remaining` and `RateLimit-Reset`; a 429 adds `Retry-After`.
    Writes have a smaller bucket of their own on top. Limits are enforced per
    API server instance and are approximate — treat `RateLimit-Remaining` as
    advisory, and back off on 429 rather than predicting it.


    **Compatibility.** We may add endpoints, add response fields, add optional
    query parameters, and add values to response enums at any time. Your client
    **must ignore fields it does not recognise.** Removing or renaming a field,
    changing a type, or tightening validation requires a new major version.


    **UI only.** The steps with legal effect stay in the dashboard, behind a
    second factor a key cannot present: accepting an opportunity and revealing
    the buyer, existing-relationship claims, deal reports and receipts, deal and
    success-fee invoices, and signing agreements. This API reads what those
    steps produced; it does not perform them.


    **What we do not publish.** Before a reveal, an opportunity carries the
    buyer's demand and nothing about the buyer — no name, no country, no id.
    Internal identifiers of people are never on the wire. Do not build on
    inferring either.
servers:
  - url: https://api.gpuoutlet.ai/v1
security:
  - bearerAuth: []
tags:
  - name: Account
    description: Facts about the calling key.
  - name: Radar
    description: >
      Curated nodes of reserved capacity — what a signed-in buyer sees on the
      Radar page, and what a seller has proposed to it.
  - name: Requests
    description: >
      Your company's demand. A request is what the operator matches sellers
      against; sellers see an anonymised copy of it as an opportunity.
  - name: Opportunities
    description: >
      The seller's inbox — demand matched to your listing, anonymised until you
      accept it in the dashboard. Declining needs no second factor and is here.
  - name: Introductions
    description: >
      What both parties read after a reveal, and the one move either may make
      without a person present — "we are ready".
paths:
  /radar/submissions/{id}/republish:
    post:
      tags:
        - Radar
      summary: Put a withdrawn proposal back
      description: Requires `radar:write`.
      operationId: republishRadarSubmission
      parameters:
        - name: id
          in: path
          required: true
          schema:
            type: string
        - $ref: '#/components/parameters/OptionalIdempotencyKey'
      responses:
        '200':
          description: The proposal, listed again if approved
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RadarSubmission'
        '401':
          $ref: '#/components/responses/Unauthorized'
        '403':
          $ref: '#/components/responses/Forbidden'
        '404':
          $ref: '#/components/responses/NotFound'
        '429':
          $ref: '#/components/responses/RateLimited'
components:
  parameters:
    OptionalIdempotencyKey:
      name: Idempotency-Key
      in: header
      required: false
      schema:
        type: string
        minLength: 1
        maxLength: 255
        pattern: ^[\x20-\x7E]+$
      description: Validated and echoed on Radar writes; not stored there.
  schemas:
    RadarSubmission:
      allOf:
        - $ref: '#/components/schemas/RadarNode'
        - type: object
          required:
            - status
            - rejection_reason
            - listed
            - created_at
          properties:
            status:
              type: string
              enum:
                - pending
                - approved
                - rejected
            rejection_reason:
              type:
                - string
                - 'null'
            listed:
              type: boolean
              description: Whether buyers can see it right now
            created_at:
              type: string
              format: date-time
    RadarNode:
      type: object
      required:
        - id
        - title
        - gpu_model
        - gpu_count
        - gpu_memory_gb
        - cpu_model
        - cpu_sockets
        - ram_gb
        - ram_type
        - storage_tb
        - storage_type
        - interconnect
        - network_uplink
        - os
        - spec_summary
        - quantity_available
        - currency
        - price_per_hour_cents
        - region
        - available_from
        - duration_min
        - duration_max
        - auction
      properties:
        id:
          type: string
        title:
          type: string
        gpu_model:
          type:
            - string
            - 'null'
        gpu_count:
          type:
            - integer
            - 'null'
          description: GPUs in ONE node
        gpu_memory_gb:
          type:
            - integer
            - 'null'
        cpu_model:
          type:
            - string
            - 'null'
        cpu_sockets:
          type:
            - integer
            - 'null'
        ram_gb:
          type:
            - integer
            - 'null'
        ram_type:
          type:
            - string
            - 'null'
        storage_tb:
          type:
            - integer
            - 'null'
        storage_type:
          type:
            - string
            - 'null'
        interconnect:
          type:
            - string
            - 'null'
        network_uplink:
          type:
            - string
            - 'null'
        os:
          type:
            - string
            - 'null'
        spec_summary:
          type:
            - string
            - 'null'
        quantity_available:
          type: integer
          description: Nodes on offer
        currency:
          type: string
          enum:
            - usd
        price_per_hour_cents:
          type:
            - integer
            - 'null'
          description: Per GPU-hour; null while the rate is still being agreed
        region:
          type:
            - string
            - 'null'
        available_from:
          type:
            - string
            - 'null'
          format: date-time
        duration_min:
          type:
            - string
            - 'null'
        duration_max:
          type:
            - string
            - 'null'
        auction:
          description: >
            Null on a fixed-price node, and null on any node with no lot taking
            bids right now — the two look identical here, which is correct:
            neither has anything to bid on. `format` is what lets you tell them
            apart from "there is a live lot with no leading bid yet". Always
            present as a key, never omitted, so an absent value is never
            ambiguous between "no lot" and "not sent yet".


            A CLOSED lot is not this field's business: once a lot's window
            passes it stops being "live" and this goes back to null for that
            node. Reading a decided lot's outcome — who won, the settlement
            amount — is not something this API offers today, and placing a bid
            through this API is a separate, unreleased scope: neither is this
            field's concern.
          oneOf:
            - type: 'null'
            - $ref: '#/components/schemas/RadarNodeAuction'
    Error:
      type: object
      required:
        - error
      properties:
        error:
          type: object
          required:
            - type
            - code
            - message
            - doc_url
            - request_id
          properties:
            type:
              type: string
              enum:
                - invalid_request_error
                - authentication_error
                - permission_error
                - rate_limit_error
                - api_error
            code:
              type: string
              description: Stable machine-readable code
            message:
              type: string
            param:
              type: string
              description: The offending parameter, when applicable
            doc_url:
              type: string
              format: uri
            request_id:
              type: string
              description: >-
                Quote this when contacting support — it locates the exact
                request
            required_scope:
              type: string
              description: 'On `insufficient_scope`: the scope this endpoint needs'
            retry_after_seconds:
              type: integer
              description: >-
                On a rate-limit error or `idempotency_key_in_flight`: seconds to
                wait
            current:
              type: string
              description: >
                On `request_not_editable`, `opportunity_not_pending` and
                `introduction_not_active`: the status the resource is in.
            problems:
              type: array
              items:
                type: string
              description: >-
                On `request_invalid`: every field at fault (`gpu_model`, `term`,
                …)
    RadarNodeAuction:
      type: object
      required:
        - lot_id
        - format
        - ends_at
        - reserve_cents
        - currency
        - bid_count
        - current_bid_cents
      properties:
        lot_id:
          type: string
        format:
          type: string
          enum:
            - open
            - sealed
          description: >
            The lot's own rule for who may see the leading bid while it is still
            open — never a quality grade. On `sealed`, nobody sees a bid amount
            before the close, the seller included; `open` allows it, to anyone.
            This is what makes the absence of `current_bid_cents` readable: a
            `sealed` lot has none to show by design, an `open` one may simply
            have drawn no bid yet.
        ends_at:
          type: string
          format: date-time
        reserve_cents:
          type:
            - integer
            - 'null'
          description: >
            The seller's own published floor. Terms, not a position — this is
            published before any bid exists, and a bidder has to accept it
            before bidding, so it is never anyone's rival amount.
        currency:
          type: string
        bid_count:
          type: integer
          description: >-
            How many bids the lot has drawn. A count, never an amount — safe to
            publish on a sealed lot.
        current_bid_cents:
          type:
            - integer
            - 'null'
          description: >
            The leading bid, and ONLY on an `open` lot with at least one bid.
            Always `null` on a `sealed` lot before it closes — for every reader,
            including the lot's own seller — because on this format no bid is
            visible to anybody until the close. Never the amount of a bid that
            is not currently leading.
  responses:
    Unauthorized:
      description: Missing, malformed, unknown, revoked or expired key
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
    Forbidden:
      description: >
        The key is valid but not allowed to do this: `insufficient_scope` (with
        `required_scope`), `company_required`, `forbidden_role`,
        `api_keys_disabled`, or `banned`.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
    NotFound:
      description: '`not_found` — no such resource, or it is not visible to you'
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
    RateLimited:
      description: Rate limit or daily quota spent
      headers:
        Retry-After:
          schema:
            type: integer
          description: Seconds to wait before retrying
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: 'An API key from your dashboard, sent as `Authorization: Bearer gpk_…`.'

````

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