Codefresh Images API

images

Operations 10

GET /images List #
POST /images/external Add from external source #
POST /images/{imageId}/promote Promote an image #
GET /images/{id} Get #
GET /images/{id}/tags Get tags #
POST /images/{imageId}/tag/{tagName} Tag #
DELETE /images/{imageId}/tag/{tagName} Untag #
POST /images/{dockerImageId}/metadata Upsert metadata #
GET /images/{dockerImageId}/metadata Get metadata #
DELETE /images/{dockerImageId}/metadata/{keyName} Delete metadata #

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/codefresh:codefresh-images-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

codefresh-images-api-openapi.yml Raw ↑
openapi: 3.2.0
info:
  contact:
    name: Codefresh
    url: https://www.codefresh.io
  description: Codefresh API openAPI 3.0 specification
  termsOfService: https://codefresh.io/docs/docs/terms-and-privacy-policy/terms-of-service/
  title: Codefresh Images API
  version: 0.0.2
  x-logo:
    url: https://g.codefresh.io/modules/cf.resources/codefresh-api-docs-images/codefresh-logo-api.svg
    backgroundColor: '#FFFFFF'
    altText: Codefresh
servers:
- url: https://g.codefresh.io/api
security:
- API-key: []
tags:
- name: Images
  description: images
  x-id: images
paths:
  /images:
    get:
      responses:
        '200':
          content:
            application/json:
              schema:
                type: array
                items:
                  properties:
                    id:
                      type: string
                    hash:
                      type: string
                    created:
                      type: string
                    status:
                      type: string
                    imageName:
                      type: string
                    branch:
                      type: string
                    sha:
                      type: string
                    commit:
                      type: string
                    commitURL:
                      type: string
                    user:
                      type: object
                    account:
                      type: string
                    dockerFile:
                      type: string
                    tags:
                      type: object
                    service:
                      type: object
                    imageDisplayName:
                      type: string
                    internalImageId:
                      type: string
                    size:
                      type: integer
                    info:
                      type: object
                    internalName:
                      type: string
                example:
                  docs:
                  - _id: '0000000000000000000000000000000000000000'
                    created: '2019-11-25T11:01:38.501Z'
                    imageName: codefresh/image
                    branch: master
                    sha: '0000000000000000000000000000000000000000'
                    commit: commit message
                    commitURL: https://github.com/username/repo/commit/0000000000000000000000000000000000000000
                    tags: []
                    service:
                      _id: '000000000000000000000000'
                      name: username/repo/repo
                    imageDisplayName: username/repo
                    size: 666666666
                    repo: username/repo
                  total: 1
                  limit: 10
                  offset: 0
          description: list of images
      tags:
      - Images
      operationId: images-list
      parameters:
      - in: query
        name: limit
        schema:
          type: string
        description: Limit
      - in: query
        name: offset
        schema:
          type: string
        description: Offset
      - in: query
        name: metadata
        schema:
          type: string
        description: Metadata
      - in: query
        name: tag
        schema:
          type: string
        description: Tag
      - in: query
        name: type
        schema:
          type: string
        description: Type
      - in: query
        name: branch
        schema:
          type: string
        description: Branch
      - in: query
        name: imageDisplayNameRegex
        schema:
          type: string
        description: Image display name regex
      - in: query
        name: select
        schema:
          type: string
        description: Select
      - in: query
        name: sha
        schema:
          type: string
        description: Sha
      - in: query
        name: internalImageId
        schema:
          type: string
        description: internal image id
      summary: List
      x-sdk-interface: images.list
      x-code-samples:
      - lang: curl
        source: "curl  \\\n    -X GET \\\n    -H \"Authorization: ${API_KEY}\" \\\n    \"https://g.codefresh.io/api/images?limit=${LIMIT}&offset=${OFFSET}&metadata=${METADATA}&tag=${TAG}&type=${TYPE}&branch=${BRANCH}&imageDisplayNameRegex=${IMAGE_DISPLAY_NAME_REGEX}&select=${SELECT}&sha=${SHA}&internalImageId=${INTERNAL_IMAGE_ID}\""
      - lang: node.js
        source: "sdk.images.list({\n    limit,\n    offset,\n    metadata,\n    tag,\n    type,\n    branch,\n    imageDisplayNameRegex,\n    select,\n    sha,\n    internalImageId\n})"
  /images/external:
    parameters: []
    post:
      responses:
        '200':
          content:
            application/json:
              schema:
                type: object
          description: json
      tags:
      - Images
      operationId: images-add-from-external-source
      summary: Add from external source
      parameters: []
      requestBody:
        content:
          application/json:
            schema:
              properties:
                Id:
                  type: string
                Digest:
                  type: string
                Image:
                  type: string
              type: object
      x-sdk-interface: images.addFromExternalSource
      x-code-samples:
      - lang: curl
        source: "curl  \\\n    -X POST \\\n    -H \"Authorization: ${API_KEY}\" \\\n    -H 'Content-Type: application/json; charset=utf-8' \\\n    -d \"{\\\"Id\\\":\\\"${ID_STR}\\\",\\\"Digest\\\":\\\"${DIGEST_STR}\\\",\\\"Image\\\":\\\"${IMAGE_STR}\\\"}\" \\\n    \"https://g.codefresh.io/api/images/external\""
      - lang: node.js
        source: "sdk.images.addFromExternalSource({\n    Id: `${ID_STR}`,\n    Digest: `${DIGEST_STR}`,\n    Image: `${IMAGE_STR}`\n})"
  /images/{imageId}/promote:
    post:
      x-entityId:
        pathId: params.imageId
        pathName: body.imageName
      x-action: promoteImage
      x-sdk-interface: images.promote
      operationId: images-promote
      summary: Promote an image
      parameters:
      - description: id of the Image
        in: path
        name: imageId
        required: true
        schema:
          type: string
      responses:
        '200':
          description: ok
      tags:
      - Images
      x-code-samples:
      - lang: curl
        source: "curl  \\\n    -X POST \\\n    -H \"Authorization: ${API_KEY}\" \\\n    \"https://g.codefresh.io/api/images/${IMAGE_ID}/promote\""
      - lang: node.js
        source: sdk.images.promote({ imageId })
  /images/{id}:
    get:
      parameters:
      - description: id of the Image
        in: path
        name: id
        required: true
        schema:
          type: string
      responses:
        '200':
          description: Detailed info for image
          content:
            application/json:
              schema:
                properties:
                  id:
                    type: string
                  hash:
                    type: string
                  created:
                    type: string
                  status:
                    type: string
                  imageName:
                    type: string
                  branch:
                    type: string
                  sha:
                    type: string
                  commit:
                    type: string
                  commitURL:
                    type: string
                  user:
                    type: object
                  account:
                    type: string
                  dockerFile:
                    type: string
                  tags:
                    type: object
                  service:
                    type: object
                  imageDisplayName:
                    type: string
                  internalImageId:
                    type: string
                  size:
                    type: integer
                  info:
                    type: object
                  internalName:
                    type: string
              example:
                buildDetails:
                  progressId: '000000000000000000000000'
                  id: '000000000000000000000000'
                  type: yaml
                systemInvalid: false
                _id: '0000000000000000000000000000000000000000'
                hash: '0000000000000000000000000000000000000000'
                created: '2019-11-25T11:01:38.501Z'
                status: ready
                imageName: user-name/repo-name
                branch: master
                sha: '0000000000000000000000000000000000000000'
                commit: added resources to limit mem usage
                commitURL: https://github.com/user-name/repo-name/commit/0000000000000000000000000000000000000000
                user:
                  key:
                    key: ''
                    pubKey: ''
                  roles:
                  - User
                  - Admin
                  account:
                  - '000000000000000000000000'
                  customer: []
                  status: new
                  settings:
                    sendWeeklyReport: true
                  _id: '000000000000000000000000'
                  userName: test-username
                  email: test-mail@example.com
                  defaultAccount: 2
                  user_data:
                    email: test-mail@example.com
                    emails:
                    - test-mail@example.com
                    id: test-username
                    name: null
                    image: https://avatars0.githubusercontent.com/u/0?v=4
                  register_date: '2016-02-06T11:21:08.054Z'
                  last_login_date: '2018-08-20T13:37:46.540Z'
                  notifications:
                  - events:
                    - build-success
                    - build-failure
                    type: mail
                  logins:
                  - credentials:
                      permissions: []
                    userId: '000000'
                    userName: test-user
                  shortProfile:
                    userName: test-user
                  publicProfile:
                    _id: '000000000000000000000000'
                    userName: test-user
                    email: test-mail@example.com
                    roles:
                    - User
                    - Admin
                    defaultAccount: 2
                    account:
                    - '000000000000000000000000'
                    status: new
                    user_data:
                      email: test-mail@example.com
                      emails:
                      - test-mail@example.com
                      id: test-user
                      name: null
                      image: https://avatars0.githubusercontent.com/u/0?v=4
                    register_date: '2016-02-06T11:21:08.054Z'
                    last_login_date: '2018-08-20T13:37:46.540Z'
                    hasPassword: false
                    notifications:
                    - events:
                      - build-success
                      - build-failure
                      type: mail
                    shortProfile:
                      userName: kosta709
                    settings:
                      sendWeeklyReport: true
                    logins:
                    - userId: '0'
                      userName: test-user
                      personalGit: false
                      permissions: []
                  token:
                    _id: '000000000000000000000000'
                  id: '000000000000000000000000'
                account: '000000000000000000000000'
                dockerFile: 'FROM alpine:latest

                  RUN echo test'
                provider: github
                tags: []
                service:
                  _id: '000000000000000000000000'
                  name: user-name/repo-name/repo-name
                imageDisplayName: user-name/repo-name
                internalImageId: '0000000000000000000000000000000000000000000000000000000000'
                size: 556672382
                info: {}
                internalName: gcr.io/test-name/test-repo/test-image@sha256:0000000000000000000000000000000000000000000000000000000000
                __v: 0
      tags:
      - Images
      operationId: images-get
      summary: Get
      x-sdk-interface: images.get
      x-code-samples:
      - lang: curl
        source: "curl  \\\n    -X GET \\\n    -H \"Authorization: ${API_KEY}\" \\\n    \"https://g.codefresh.io/api/images/${ID}\""
      - lang: node.js
        source: sdk.images.get({ id })
  /images/{id}/tags:
    get:
      parameters:
      - description: name of the image
        in: path
        name: id
        required: true
        schema:
          type: string
      responses:
        '200':
          content:
            application/json:
              schema:
                type: object
          description: json
      tags:
      - Images
      operationId: images-get-tags
      summary: Get tags
      x-sdk-interface: images.getTags
      x-code-samples:
      - lang: curl
        source: "curl  \\\n    -X GET \\\n    -H \"Authorization: ${API_KEY}\" \\\n    \"https://g.codefresh.io/api/images/${ID}/tags\""
      - lang: node.js
        source: sdk.images.getTags({ id })
  /images/{imageId}/tag/{tagName}:
    post:
      x-action: addTagToImage
      x-entityId: params.imageId
      parameters:
      - description: image ObjectId
        in: path
        name: imageId
        required: true
        schema:
          type: string
      - description: tag
        in: path
        name: tagName
        required: true
        schema:
          type: string
      responses:
        '200':
          content:
            application/json:
              schema:
                type: object
          description: json
      tags:
      - Images
      operationId: images-tag
      summary: Tag
      x-sdk-interface: images.tag
      x-code-samples:
      - lang: curl
        source: "curl  \\\n    -X POST \\\n    -H \"Authorization: ${API_KEY}\" \\\n    \"https://g.codefresh.io/api/images/${IMAGE_ID}/tag/${TAG_NAME}\""
      - lang: node.js
        source: sdk.images.tag({ imageId, tagName })
    delete:
      x-action: imageTagDeleted
      x-entityId: params.imageId
      parameters:
      - description: tag ObjectId
        in: path
        name: tagName
        required: true
        schema:
          type: string
      - in: path
        name: imageId
        schema:
          type: object
        description: imageId
        required: true
      responses:
        '200':
          content:
            application/json:
              schema:
                type: object
          description: json
      tags:
      - Images
      operationId: images-untag
      summary: Untag
      x-sdk-interface: images.untag
      x-code-samples:
      - lang: curl
        source: "curl  \\\n    -X DELETE \\\n    -H \"Authorization: ${API_KEY}\" \\\n    \"https://g.codefresh.io/api/images/${IMAGE_ID}/tag/${TAG_NAME}\""
      - lang: node.js
        source: sdk.images.untag({ tagName, imageId })
  /images/{dockerImageId}/metadata:
    post:
      parameters:
      - description: id of the Image (from docker inspect)
        in: path
        name: dockerImageId
        required: true
        schema:
          type: string
      responses:
        '200':
          content:
            application/json:
              schema:
                type: object
          description: json
      tags:
      - Images
      operationId: images-upsert-metadata
      requestBody:
        content:
          application/json:
            schema:
              properties:
                CF_QUALITY:
                  default: true
                  type: boolean
                comment:
                  default: image for qa
                  type: string
                coverage:
                  default: 60%
                  type: string
                failed_tests:
                  default: 7
                  type: integer
              type: object
      summary: Upsert metadata
      x-sdk-interface: images.upsertMetadata
      x-code-samples:
      - lang: curl
        source: "curl  \\\n    -X POST \\\n    -H \"Authorization: ${API_KEY}\" \\\n    -H 'Content-Type: application/json; charset=utf-8' \\\n    -d \"{\\\"CF_QUALITY\\\":${CF_QUALITY_BOOL},\\\"comment\\\":\\\"${COMMENT_STR}\\\",\\\"coverage\\\":\\\"${COVERAGE_STR}\\\",\\\"failed_tests\\\":${FAILED_TESTS_NUM}}\" \\\n    \"https://g.codefresh.io/api/images/${DOCKER_IMAGE_ID}/metadata\""
      - lang: node.js
        source: "sdk.images.upsertMetadata({ dockerImageId }, {\n    CF_QUALITY: CF_QUALITY_BOOL,\n    comment: `${COMMENT_STR}`,\n    coverage: `${COVERAGE_STR}`,\n    failed_tests: FAILED_TESTS_NUM\n})"
    get:
      parameters:
      - description: id of the Image (from docker inspect)
        in: path
        name: dockerImageId
        required: true
        schema:
          type: string
      responses:
        '200':
          content:
            application/json:
              schema:
                type: object
          description: json
      tags:
      - Images
      operationId: images-get-metadata
      summary: Get metadata
      x-sdk-interface: images.getMetadata
      x-code-samples:
      - lang: curl
        source: "curl  \\\n    -X GET \\\n    -H \"Authorization: ${API_KEY}\" \\\n    \"https://g.codefresh.io/api/images/${DOCKER_IMAGE_ID}/metadata\""
      - lang: node.js
        source: sdk.images.getMetadata({ dockerImageId })
  /images/{dockerImageId}/metadata/{keyName}:
    delete:
      parameters:
      - description: id of the Image from docker inspect
        in: path
        name: dockerImageId
        required: true
        schema:
          type: string
      - description: name of the metadata key
        in: path
        name: keyName
        required: true
        schema:
          type: string
      responses:
        '200':
          content:
            application/json:
              schema:
                type: object
          description: json
      tags:
      - Images
      operationId: images-delete-metadata
      summary: Delete metadata
      x-sdk-interface: images.deleteMetadata
      x-code-samples:
      - lang: curl
        source: "curl  \\\n    -X DELETE \\\n    -H \"Authorization: ${API_KEY}\" \\\n    \"https://g.codefresh.io/api/images/${DOCKER_IMAGE_ID}/metadata/${KEY_NAME}\""
      - lang: node.js
        source: sdk.images.deleteMetadata({ dockerImageId, keyName })
components:
  securitySchemes:
    API-key:
      in: header
      name: Authorization
      description: 'An api key got from: User Settings -> API keys -> Generate'
      type: apiKey
x-service-name: api-public
x-base-path: /api
x-internal-services:
- pipeline-manager
- api
x-endpoint-conditions:
- weight: 0
  condition: global.has-general-service-role
  handlerRegex: (.*)
- weight: 1
  condition: global.has-kubernetes-endpoints-service-role
  handlerRegex: kubernetes\.\w+
- weight: 2
  condition: global.has-auth-service-role
  handlerRegex: api-key\.\w+
x-tagGroups:
- name: Pipelines / Builds
  tags:
  - Annotations
  - Builds
  - Execution Contexts
  - Images
  - Pipelines
  - Progress
  - Projects
  - Step-types
  - Triggers
  - Triggers Events
  - Triggers Types
- name: Kubernetes / Helm
  tags:
  - Environments V2
  - Helm Boards
  - Helm Charts
  - Helm Releases
  - Helm Sections
  - Kubernetes
- name: Swarm
  tags:
  - Compositions
  - Environments
- name: Integrations / Contexts
  tags:
  - Clusters
  - Contexts
  - Helm Cluster Configs
  - Helm Repos
  - Registries
  - Repos
- name: Account Management
  tags:
  - Abac
  - Accounts
  - Agents
  - Audit
  - Runtime Environments
  - Teams
  - Tokens
  - Views
- name: User Properties
  tags:
  - favorites
- name: On-Premise
  tags:
  - Features
  - Runtime Environments (Account)
  - Runtime Environments (Plan)
  - Runtime Environments (System)
  - Runtime Environments.
- name: Platform Analytics
  tags:


# --- truncated at 32 KB (145 KB total) ---
# Full source: https://raw.githubusercontent.com/api-evangelist/codefresh/refs/heads/main/openapi/codefresh-images-api-openapi.yml