Canonical Operation Service API

Manages long-running operations.

Operations 2

GET /v1/operations/{operation} Operation service get operation #
POST /v1/operations:batchGet Operation service batch get operations #

Documentation

Specifications

Other Resources

Work with this as data

Every API here is available over the APIs.io API and to AI agents over MCP.

MCP server

One button, every client — Claude, Cursor, VS Code and the rest.

https://apis.io/mcp

Tools for apis

7 MCP tools reach this
  • find_apisBrowse and filter every API in the catalog.
  • get_api_artifactsOne API's artifacts, grouped by type.
  • get_openapiThe primary OpenAPI for this API.
  • find_similar_apisAPIs that look like this one.
  • apis_io_searchSTART HERE — APIs, providers and tags for one query, each with its total.
  • resolveTurn a domain, URL or GitHub org into the provider it belongs to.
  • find_cohortsEvery scored population of providers in the catalog.
All 92 tools →

Call it yourself

curl for this page
This API
curl "https://apis.io/api/v1/apis/canonical-operationservice-api"
All apis
curl "https://apis.io/api/v1/apis?limit=25"

Discovery needs no key. Ratings and market analysis are Pro.

Get an API key

Free tier, no form to fill in. Signing in shares your email address with us — we store it to create your key and to recognise you if you sign in with another provider. See our Privacy Policy and Terms.

A second provider on the same verified email joins the account you already have.

OpenAPI Specification

canonical-operationservice-api-openapi.yml Raw ↑
openapi: 3.2.0
info:
  title: debarchive Operation Service API
  version: 0.1.0
  description: Manages long-running operations.
tags:
- name: OperationService
  description: Manages long-running operations.
paths:
  /v1/operations/{operation}:
    get:
      tags:
      - OperationService
      description: 'Retrieves the latest state of a long-running operation. Use this

        to poll the operation result.'
      operationId: OperationService_GetOperation
      parameters:
      - name: operation
        in: path
        description: The operation id.
        required: true
        schema:
          type: string
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Operation'
        default:
          description: Default error response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Status'
      summary: Operation service get operation
      x-summary-source: derived
  /v1/operations:batchGet:
    post:
      tags:
      - OperationService
      description: Retrieves a batch of long-running operations based on their names.
      operationId: OperationService_BatchGetOperations
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/BatchGetOperationsRequest'
        required: true
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BatchGetOperationsResponse'
        default:
          description: Default error response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Status'
      summary: Operation service batch get operations
      x-summary-source: derived
components:
  schemas:
    GoogleProtobufAny:
      type: object
      properties:
        '@type':
          type: string
          description: The type of the serialized message.
      additionalProperties: true
      description: Contains an arbitrary serialized message along with a @type that describes the type of the serialized message.
    BatchGetOperationsRequest:
      required:
      - names
      type: object
      properties:
        names:
          type: array
          items:
            type: string
          description: "The names of the long-running operations to retrieve.\n A maximum of 100 long-running operations can be retrieved in a batch.\n Format: operations/{operation}"
        returnPartialSuccess:
          type: boolean
          description: "Setting this field to `true` will opt the request into returning the\n operations that are reachable, and into including the names of those that\n were unreachable in the [BatchGetOperationsResponse.unreachable] field."
      description: The request message for retrieving a batch of long-running operations.
    Operation:
      type: object
      properties:
        name:
          type: string
          description: "The server-assigned name, which is only unique within the same service that\n originally returns it. If you use the default HTTP mapping, the\n `name` should be a resource name ending with `operations/{unique_id}`."
        metadata:
          allOf:
          - $ref: '#/components/schemas/GoogleProtobufAny'
          description: "Service-specific metadata associated with the operation.  It typically\n contains progress information and common metadata such as create time.\n Some services might not provide such metadata.  Any method that returns a\n long-running operation should document the metadata type, if any."
        done:
          type: boolean
          description: "If the value is `false`, it means the operation is still in progress.\n If `true`, the operation is completed, and either `error` or `response` is\n available."
        error:
          allOf:
          - $ref: '#/components/schemas/Status'
          description: The error result of the operation in case of failure or cancellation.
        response:
          allOf:
          - $ref: '#/components/schemas/GoogleProtobufAny'
          description: "The normal, successful response of the operation.  If the original\n method returns no data on success, such as `Delete`, the response is\n `google.protobuf.Empty`.  If the original method is standard\n `Get`/`Create`/`Update`, the response should be the resource.  For other\n methods, the response should have the type `XxxResponse`, where `Xxx`\n is the original method name.  For example, if the original method name\n is `TakeSnapshot()`, the inferred response type is\n `TakeSnapshotResponse`."
      description: "This resource represents a long-running operation that is the result of a\n network API call."
    Status:
      type: object
      properties:
        code:
          type: integer
          description: The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code].
          format: int32
        message:
          type: string
          description: A developer-facing error message, which should be in English. Any user-facing error message should be localized and sent in the [google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client.
        details:
          type: array
          items:
            $ref: '#/components/schemas/GoogleProtobufAny'
          description: A list of messages that carry the error details.  There is a common set of message types for APIs to use.
      description: 'The `Status` type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by [gRPC](https://github.com/grpc). Each `Status` message contains three pieces of data: error code, error message, and error details. You can find out more about this error model and how to work with it in the [API Design Guide](https://cloud.google.com/apis/design/errors).'
    BatchGetOperationsResponse:
      type: object
      properties:
        operations:
          type: array
          items:
            $ref: '#/components/schemas/Operation'
          description: Long-running operations requested.
        unreachable:
          type: array
          items:
            type: string
          description: "Unreachable operations. Populated when the request opts into\n `return_partial_success` and reading across collections."
      description: The response message for retrieving a batch of long-running operations.