Skip to main content

API

This page summarizes the API provided by the Wave container service.

API limits​

The Wave service implements API rate limits for API calls. Authenticated users have higher rate limits than anonymous users.

If an access token is provided, the following rate limits apply:

  • 250 container builds per hour
  • 2,000 container pulls per minute

If an access token isn't provided, the following rate limits apply:

  • 25 container builds per day
  • 100 container pulls per hour

How Wave pull rate limits work​

When you pull a container image:

  1. The Docker service downloads the container manifest (a JSON file detailing each layer of the final image).
  2. The Docker service downloads each layer listed in the manifest file.

Wave defines a pull as downloading both the container manifest and all layers. Therefore:

  • The manifest request to Wave counts as one pull against your rate limit
  • Layer and blob requests don't count against rate limits
  • A container image with 100 layers counts as 1 pull

Rate limits affect pipelines with high concurrency. The following example demonstrates this issue:

  • 50 concurrent pipeline runs
  • Each run spawns 10,000 tasks
  • Each task runs on it's own VM
  • Each task pulls a container image
  • 500,000 manifest requests are made

This volume exceeds the 2,000 container pulls per minute limit and causes failed tasks and pipeline errors.

General API​

POST /container-token​

warning

This API endpoint is deprecated in current versions of Wave.

Submit a request to access a private container registry via Wave, or build a container image on-the-fly with a Dockerfile or Conda recipe file.

The endpoint returns the name of the container request made available by Wave.

Request body​

{
    containerImage: string,
    containerFile: string,
    containerConfig: {
        entrypoint: string[],
        cmd: string[],
        env: string[],
        workingDir: string
        layers: [
            {
                location: string,
                gzipDigest: string,
                gzipSize: string,
                tarDigest: string
            },
            ...
        ]
    },
    condaFile: string,
    containerPlatform: string,
    buildRepository: string,
    cacheRepository: string,
    timestamp: string,
    fingerprint: string,
    freeze: boolean,
    towerAccessToken: string,
    towerRefreshToken: string,
    towerEndpoint: string,
    towerWorkspaceId: number,
}

Container token request attributes

AttributeDescription
containerImageName of the container to be served, e.g., docker.io/library/ubuntu:latest (optional). If omitted, the containerFile must be provided.
containerConfig.entrypointThe container entrypoint command, e.g., ['/bin/bash'].
containerConfig.cmdThe launch command to be used by the Wave container, e.g., ['echo', 'Hello world'] (optional).
containerConfig.envThe environment variables to be defined in the Wave container, e.g., ['FOO=one','BAR=two'] (optional).
containerConfig.workingDirThe work directory to be used in the Wave container, e.g., /some/work/dir (optional).
containerConfig.layers.locationSpecifies a container image layer stored as a tar.gz file (optional). Either a HTTP URL to the file or a base64 encoded string prefixed with data:.
containerConfig.layers.tarDigestThe SHA256checksum of the provided tar file, e.g., sha256:a7c724b02....
containerConfig.layers.gzipDigestThe SHA256 checksum of the provided layer tar gzip file, e.g., sha256:a7c724b02....
containerConfig.layers.gzipSizeThe size in bytes of the the provided layer tar gzip file.
containerFileDockerfile used for building a new container encoded in base64 (optional). When provided, the attribute containerImage must be omitted.
condaFileConda environment file encoded as base64 string.
containerPlatformTarget container architecture of the built container, e.g., linux/amd64 (optional). Currently only supporting amd64 and arm64.
buildRepositoryContainer repository where container builds should be pushed, e.g., docker.io/user/my-image (optional).
cacheRepositoryContainer repository used to cache build layers docker.io/user/my-cache (optional).
timestampRequest submission timestamp using ISO-8601.
fingerprintRequest unique fingerprint.
freezeFreeze requires buildRepository to push the build container to a user-defined repository. This provides the container URL from the user-defined repository, not the Wave generated URL. This URL won't change.
towerEndpointSeqera Platform service endpoint from where container registry credentials are retrieved (optional). Default https://api.cloud.seqera.io.
towerAccessTokenAccess token of the user account granting access to the Seqera Platform service specified via towerEndpoint (optional).
towerWorkspaceIdID of the Seqera Platform workspace from where the container registry credentials are retrieved (optional). When omitted the personal workspace is used.

Response​

{
    containerToken: string,
    targetImage: string,
    expiration: string
}

Container token response attributes

AttributeDescription
containerTokenThe unique token identifying the Wave container request, e.g., 0123456789.
targetImageThe Wave container image name, e.g., wave.seqera.io/wt/0123456789/library/ubuntu:latest.
expirationThe expiration timestamp of the Wave container using ISO-8601 format.

POST /v1alpha2/container​

Submit a request to access a private container registry via Wave, or build a container image on-the-fly with a Dockerfile or Conda recipe file.

Returns the name of the container request made available by Wave.

Request body​

{
    containerImage: string,
    containerFile: string,
    containerConfig: {
        entrypoint: string[],
        cmd: string[],
        env: string[],
        workingDir: string
        layers: [
            {
                location: string,
                gzipDigest: string,
                gzipSize: string,
                tarDigest: string
            },
            ...
        ]
    },
    condaFile: string,
    containerPlatform: string,
    buildRepository: string,
    cacheRepository: string,
    timestamp: string,
    fingerprint: string,
    freeze: boolean,
    towerAccessToken: string,
    towerRefreshToken: string,
    towerEndpoint: string,
    towerWorkspaceId: number,
    packages: {
                  type: string,
                  environment: string,
                  entries: string[],
                  channels: string[],
                  condaOpts: {
                                mambaImage: string,
                                commands: string[],
                                basePackages: string
                              }

              },
    nameStrategy: string
}

Container token request attributes

AttributeDescription
containerImageName of the container to be served, e.g., docker.io/library/ubuntu:latest (optional). If omitted, the containerFile must be provided.
containerConfig.entrypointThe container entrypoint command, e.g., ['/bin/bash'].
containerConfig.cmdThe launch command to be used by the Wave container, e.g., ['echo', 'Hello world'] (optional).
containerConfig.envThe environment variables to be defined in the Wave container, e.g., ['FOO=one','BAR=two'] (optional).
containerConfig.workingDirThe work directory to be used in the Wave container, e.g., /some/work/dir (optional).
containerConfig.layers.locationSpecifies a container image layer stored as a tar.gz file (optional). Either a HTTP URL to the file or a base64 encoded string prefixed with data:.
containerConfig.layers.tarDigestThe SHA256checksum of the provided tar file, e.g., sha256:a7c724b02....
containerConfig.layers.gzipDigestThe SHA256 checksum of the provided layer tar gzip file, e.g., sha256:a7c724b02....
containerConfig.layers.gzipSizeThe size in bytes of the the provided layer tar gzip file.
containerFileDockerfile used for building a new container encoded in base64 (optional). When provided, the attribute containerImage must be omitted.
condaFileConda environment file encoded as base64 string.
containerPlatformTarget container architecture of the built container, e.g., linux/amd64 (optional). Currently only supporting amd64 and arm64.
buildRepositoryContainer repository where container builds should be pushed, e.g., docker.io/user/my-image (optional).
cacheRepositoryContainer repository used to cache build layers docker.io/user/my-cache (optional).
timestampRequest submission timestamp using ISO-8601.
fingerprintRequest unique fingerprint.
freezeFreeze requires buildRepository to push the build container to a user-defined repository. This provides the container URL from the user-defined repository, not the Wave generated URL. This URL won't change.
towerEndpointSeqera Platform service endpoint from where container registry credentials are retrieved (optional). Default https://api.cloud.seqera.io.
towerAccessTokenAccess token of the user account granting access to the Seqera Platform service specified via towerEndpoint (optional).
towerWorkspaceIdID of the Seqera Platform workspace from where the container registry credentials are retrieved (optional). When omitted the personal workspace is used.
packagesThis object specifies Conda or CRAN packages environment information.
environmentThe package environment file encoded as a base64 string.
typeThis represents the type of package builder. Options: CONDA CRAN.
entriesList of the packages names.
channelsList of Conda channels or CRAN repositories, which will be used to download packages.
condaOptsConda build options (when type is CONDA).
mambaImageName of the Docker image used to build Conda containers.
commandsCommand to be included in the container.
basePackagesNames of base packages.
baseImageBase image for the final stage of multi-stage Conda/Pixi builds.
pixiOptsPixi build options (when type is CONDA and buildTemplate is conda/pixi:v1).
pixiImageName of the Docker image used for Pixi package manager (e.g., ghcr.io/prefix-dev/pixi:latest).
cranOptsCRAN build options (when type is CRAN).
rImageName of the R Docker image used to build CRAN containers (e.g., rocker/r-ver:4.4.1).
buildTemplateThe build template to use for container builds. Supported values: conda/pixi:v1 (Pixi with multi-stage builds), conda/micromamba:v2 (Micromamba 2.x with multi-stage builds). Default: conda/micromamba:v1 template.
nameStrategyThe name strategy to be used to create the name of the container built by Wave. Options: none, tagPrefix, imageSuffix.

Response​

{
    containerToken: string,
    targetImage: string,
    expiration: string,
    buildId: string,
    cached: boolean
}

Container token response attributes

AttributeDescription
containerTokenThe unique token identifying the Wave container request, e.g., 0123456789.
targetImageThe Wave container image name, e.g., wave.seqera.io/wt/0123456789/library/ubuntu:latest.
expirationThe expiration timestamp of the Wave container using ISO-8601 format.
cachedIndicates if the requested image is built or in progress.

Examples​

  • Create Docker image with Conda packages:

    Request:

    curl --location 'http://localhost:9090/v1alpha2/container' \
    --header 'Content-Type: application/json' \
    --data '{
        "packages":{
            "type": "CONDA",
            "entries": ["salmon", "bwa"],
            "channels": ["conda-forge", "bioconda"]
        }
    }'

    Response

    {
        "containerToken":"732b73aa17c8",
        "targetImage":"0625dce899da.ngrok.app/wt/732b73aa17c8/hrma017/dev:salmon_bwa--5e49881e6ad74121",
        "expiration":"2024-04-09T21:19:01.715321Z",
        "buildId":"5e49881e6ad74121_1",
        "cached":false,
        "freeze":false
    }

  • Create Singularity image with Conda packages:

    Request

    curl --location 'http://localhost:9090/v1alpha2/container' \
    --header 'Content-Type: application/json' \
    --data '{
        "format": "sif",
        "containerPlatform": "arm64",
        "packages":{
            "type": "CONDA",
            "entries": ["salmon"],
            "channels": ["conda-forge", "bioconda"]
        },
        "freeze": true,
        "buildRepository": <CONTAINER_REPOSITORY>,
        "towerAccessToken":<YOUR_SEQERA_PLATFORM_TOWER_TOKEN>,
        "towerEndpoint": "http://localhost:8008/api"
    }'

    Response

    {
        "targetImage":"oras://<CONTAINER_REPOSITORY>:salmon--6c084f2e43f86a78",
        "buildId":"6c084f2e43f86a78_1",
        "cached":false,
        "freeze":true
    }
    note

    To create Singularity images with the freeze feature, you must add your container registry credentials in Seqera Platform.

  • Create Docker image with CRAN packages:

    Request

    curl --location 'http://localhost:9090/v1alpha2/container' \
    --header 'Content-Type: application/json' \
    --data '{
        "packages":{
            "type": "CRAN",
            "entries": ["dplyr", "ggplot2"],
            "channels": ["cran"],
            "cranOpts": {
                "rImage": "rocker/r-ver:4.4.1",
                "basePackages": "littler r-cran-docopt"
            }
        }
    }'

    Response

    {
        "requestId": "22d3c6c1cb06",
        "containerToken": "22d3c6c1cb06",
        "targetImage": "wave.seqera.io/wt/22d3c6c1cb06/wave/build:49b26ca0c3a07b1b",
        "expiration": "2025-11-09T02:50:23.254497148Z",
        "containerImage": "private.cr.seqera.io/wave/build:49b26ca0c3a07b1b",
        "buildId": "bd-49b26ca0c3a07b1b_1",
        "cached": false,
        "freeze": false,
        "mirror": false,
        "scanId": "sc-a6acedfe6969f4bf_1"
    }

  • Create Singularity image with CRAN packages:

    Request

    curl --location 'https://wave.seqera.io/v1alpha2/container' \
    --header 'Content-Type: application/json' \
    --data '{
        "format": "sif",
        "containerPlatform": "linux/amd64",
        "packages":{
            "type": "CRAN",
            "entries": ["tidyverse", "data.table"],
            "channels": ["cran"],
            "cranOpts": {
                "rImage": "rocker/r-ver:4.4.1",
                "basePackages": "build-essential"
            }
        },
        "freeze": true,
        "buildRepository": "<CONTAINER_REPOSITORY>", # hrma017/test
        "towerAccessToken": "<TOKEN>"
    }'

    Response

    {
        "requestId": "6706d70da258",
        "targetImage": "oras://hrma017/test:a4fd48144607aaa7",
        "containerImage": "oras://hrma017/test:a4fd48144607aaa7",
        "buildId": "bd-a4fd48144607aaa7_1",
        "freeze": true,
        "mirror": false,
        "succeeded": true
    }

GET /v1alpha1/builds/{buildId}/status​

Get status of build against buildId passed as path variable

Response​

{
    "requestId": "6706d70da258",
    "targetImage": "oras://hrma017/test:a4fd48144607aaa7",
    "containerImage": "oras://hrma017/test:a4fd48144607aaa7",
    "buildId": "bd-a4fd48144607aaa7_1",
    "freeze": true,
    "mirror": false,
    "succeeded": true
}

  • Create Docker image with Pixi v1 template (multi-stage build):

    Request

    curl --location 'https://wave.seqera.io/v1alpha2/container' \
    --header 'Content-Type: application/json' \
    --data '{
        "containerPlatform": "linux/amd64",
        "format": "docker",
        "buildTemplate": "conda/pixi:v1",
        "packages":{
            "type": "CONDA",
            "entries": ["numpy", "pandas", "scikit-learn"],
            "channels": ["conda-forge"],
            "pixiOpts": {
                "pixiImage": "ghcr.io/prefix-dev/pixi:0.59.0-noble",
                "basePackages": "conda-forge::procps-ng",
                "baseImage": "ubuntu:24.04",
                "commands": []
            }
        }
    }'

    Response

    {
        "requestId":"bf31a6445b41",
        "containerToken":"bf31a6445b41",
        "targetImage":"https://wave.seqera.io/wt/bf31a6445b41/hrma017/dev:numpy_pandas_scikit-learn--ad24e45802adb349",
        "expiration":"2025-12-02T11:47:55.908498Z",
        "containerImage":"hrma017/dev:numpy_pandas_scikit-learn--ad24e45802adb349",
        "buildId":"bd-ad24e45802adb349_1",
        "cached":false,
        "freeze":false,
        "mirror":false,
        "scanId":"sc-98fd615516bd93d6_1"
    }

  • Create Docker image with Micromamba v2 template (multi-stage build):

    Request

    curl --location 'https://wave.seqera.io/v1alpha2/container' \
    --header 'Content-Type: application/json' \
    --data '{
        "containerPlatform": "linux/amd64",
        "format": "docker",
        "buildTemplate": "conda/micromamba:v2",
        "packages":{
            "type": "CONDA",
            "entries": ["bwa=0.7.15", "salmon=1.10.0", "samtools=1.17"],
            "channels": ["conda-forge", "bioconda"],
            "condaOpts": {
                "mambaImage": "mambaorg/micromamba:2-amazon2023",
                "basePackages": "conda-forge::procps-ng",
                "baseImage": "ubuntu:24.04",
                "commands": []
            }
        }
    }'

    Response

    {
        "requestId":"248eefc1fc14",
        "containerToken":"248eefc1fc14",
        "targetImage":"wave.local/wt/248eefc1fc14/hrma017/dev:bwa-0.7.15_salmon-1.10.0_samtools-1.17--40730eb5c2c3dc6e",
        "expiration":"2025-12-02T12:14:59.672505Z",
        "containerImage":"hrma017/dev:bwa-0.7.15_salmon-1.10.0_samtools-1.17--40730eb5c2c3dc6e",
        "buildId":"bd-40730eb5c2c3dc6e_1",
        "cached":false,
        "freeze":false,
        "mirror":false,
        "scanId":"sc-f36486d1a7e3053a_1"
    }

  • Create Singularity image with Pixi v1 template (multi-stage build):

    Request

    curl --location 'https://wave.seqera.io/v1alpha2/container' \
    --header 'Content-Type: application/json' \
    --data '{
        "containerPlatform": "linux/amd64",
        "format": "sif",
        "buildTemplate": "conda/pixi:v1",
        "packages":{
            "type": "CONDA",
            "entries": ["numpy", "pandas", "scikit-learn"],
            "channels": ["conda-forge"],
            "pixiOpts": {
                "pixiImage": "ghcr.io/prefix-dev/pixi:0.59.0-noble",
                "basePackages": "conda-forge::procps-ng",
                "baseImage": "ubuntu:24.04",
                "commands": []
            }
        },
        "freeze": true,
        "buildRepository": "<CONTAINER_REPOSITORY>", # hrma017/test
        "towerAccessToken": "<TOKEN>"
    }'

    Response

    {
        "requestId":"7159b38c6c04",
        "targetImage":"oras://hrma017/test:numpy_pandas_scikit-learn--717309e30359606f",
        "containerImage":"oras://hrma017/test:numpy_pandas_scikit-learn--717309e30359606f",
        "buildId":"bd-717309e30359606f_1",
        "cached":false,
        "freeze":true,
        "mirror":false
    }

  • Create Singularity image with Micromamba v2 template (multi-stage build):

    Request

    curl --location 'https://wave.seqera.io/v1alpha2/container' \
    --header 'Content-Type: application/json' \
    --data '{
        "containerPlatform": "linux/amd64",
        "format": "sif",
        "buildTemplate": "conda/micromamba:v2",
        "packages":{
            "type": "CONDA",
            "entries": ["bwa=0.7.15", "salmon=1.10.0", "samtools=1.17"],
            "channels": ["conda-forge", "bioconda"],
            "condaOpts": {
                "mambaImage": "mambaorg/micromamba:2-amazon2023",
                "basePackages": "conda-forge::procps-ng",
                "baseImage": "ubuntu:24.04",
                "commands": []
            }
        },
        "freeze": true,
        "buildRepository": "<CONTAINER_REPOSITORY>", # hrma017/test
        "towerAccessToken": "<TOKEN>"
    }'

    Response

    {
        "requestId":"b93c35abca4e",
        "targetImage":"oras://hrma017/test:bwa-0.7.15_salmon-1.10.0_samtools-1.17--e85b5c89438aa3ff",
        "containerImage":"oras://hrma017/test:bwa-0.7.15_salmon-1.10.0_samtools-1.17--e85b5c89438aa3ff",
        "buildId":"bd-e85b5c89438aa3ff_1",
        "cached":false,
        "freeze":true,
        "mirror":false
    }
note

Multi-stage build templates (conda/pixi:v1 and conda/micromamba:v2) create optimized container images by separating the build environment from the final runtime environment. This results in smaller container images that only contain the installed packages and runtime dependencies, without the build tools.

important

Image Requirements for Singularity Builds with Pixi and Micromamba v2 Templates

When building Singularity images (format: "sif") with the conda/pixi:v1 or conda/micromamba:v2 build templates, base images (via baseImage option) must have the tar utility installed.

This requirement exists because Singularity's multi-stage builds use proot to emulate filesystem operations, which cannot reliably copy directory structures between build stages. The templates support this by compressing the environment into a tarball (tar czf) and extracting it (tar xzf) in the final stage.

Docker builds are not affected by this requirement. Docker's native COPY --from=build directive handles directory copying directly.

Most standard base images (Ubuntu, Debian, Alpine, etc.) include tar by default, but minimal or distroless images may require explicit installation.

GET /v1alpha1/builds/{buildId}/status​

Provides status of build against buildId passed as path variable

Response​

{
    id: string,
    status: string,
    startTime: string,
    duration: string,
    succeeded: boolean
}
note

Status can only be PENDING or COMPLETED.

Examples​

% curl --location 'http://localhost:9090/v1alpha1/builds/6c084f2e43f86a78_1/status'
{
    "id":"6c084f2e43f86a78_1",
    "status":"COMPLETED",
    "startTime":"2024-04-09T20:31:35.355423Z",
    "duration":123.914989000,
    "succeeded":true
}

GET /v1alpha1/builds/{buildId}/logs​

Supply logs corresponding to the specified buildId within the API request.

Response​

string

Examples​

% curl --location 'http://localhost:9090/v1alpha1/builds/<BUILD_ID>/logs'
INFO[0001] Retrieving image manifest alpine:latest
INFO[0001] Retrieving image alpine:latest from registry index.docker.io
INFO[0002] Retrieving image manifest alpine:latest
INFO[0002] Returning cached image manifest
INFO[0002] Built cross stage deps: map[]
INFO[0002] Retrieving image manifest alpine:latest
INFO[0002] Returning cached image manifest
INFO[0002] Retrieving image manifest alpine:latest
INFO[0002] Returning cached image manifest
INFO[0002] Executing 0 build triggers
INFO[0002] Building stage 'alpine:latest' [idx: '0', base-idx: '-1']
INFO[0002] Skipping unpacking as no commands require it.
INFO[0002] Pushing image to <REPO>/<IMAGE>
INFO[0005] Pushed index.docker.io/<REPO>/<IMAGE>

GET /service-info​

Get basic information about the service status.

Response​

{
    serviceInfo: {
        version: string,
        commitId: string
    }
}

POST /v1alpha1/inspect​

Returns the metadata about provided container image

Request​

{
    containerImage: string,
    towerAccessToken: string,
    towerEndpoint: string,
    towerWorkspaceId: string
}

Container inspect request attributes

AttributeDescription
containerImageName of the container to be inpected, e.g., docker.io/library/ubuntu:latest
towerEndpointSeqera Platform service endpoint from where container registry credentials are retrieved (optional). Default https://api.cloud.seqera.io.
towerAccessTokenAccess token of the user account granting the access to the Seqera Platform service specified via towerEndpoint (optional).
towerWorkspaceIdID of the Seqera Platform workspace from where the container registry credentials are retrieved (optional). When omitted the personal workspace is used.

Response​

{
    container: {
        registry: string,
        hostName: string,
        imageName: string,
        reference: string,
        digest: string,
        config: {
            architecture: string,
            config: {
                attachStdin: boolean,
                attachStdout: boolean,
                attachStderr: boolean,
                tty: boolean,
                env: string[],
                cmd: string[],
                image: string
            },
            container: string,
            created: string,
            rootfs: {
                type: string,
                diff_ids: string[]
            }
        },
        manifest: {
            schemaVersion: integer,
            mediaType: string,
            config: {
                mediaType: string,
                digest: string,
                size: integer
            },
            layers: [
                {
                    mediaType: string,
                    digest: string,
                    size: integer
                }
            ]
        },
        v1: boolean,
        v2: boolean,
        oci: boolean
    }
}
note

You can find the explanation of the response attributes (here)[https://github.com/opencontainers/image-spec/blob/main/spec.md]

Examples​

  • API call

    Request

    curl --location 'http://localhost:9090/v1alpha1/inspect' \
    --header 'Content-Type: application/json' \
    --data '{
        "containerImage": "docker.io/<REPO>/<IMAGE>",
        "towerAccessToken": "<TOWER_TOKEN>",
        "towerEndpoint": "http://localhost:8000/api"
    }'

    Response

    {
        "container": {
            "registry": "docker.io",
            "hostName": "https://registry-1.docker.io",
            "imageName": "<WAVE_TOKEN>/<REPO>/<IMAGE>",
            "reference": "9b80535d04eceefd",
            "digest": "sha256:1fcabdb850dc7c46646b3796fca01aca5721330252b586058e0d326705374dd5",
            "config": {
                "architecture": "amd64",
                "config": {
                    "env": [
                        "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
                    ],
                    "cmd": [
                        "/bin/sh"
                    ],
                    "image": "sha256:9a5ce069f40cfe0f2270eafbff0a0f2fa08f1add73571af9f78209e96bb8a5e9"
                },
                "container": "4189cbc534955765760c227f328ec1cdd52e8550681c2bf9f8f990b27b644f9c",
                "created": "2024-04-19T14:38:17.047396956Z",
                "rootfs": {
                    "type": "layers",
                    "diff_ids": [
                        "sha256:d4fc045c9e3a848011de66f34b81f052d4f2c15a17bb196d637e526349601820"
                    ]
                }
            },
            "manifest": {
                "schemaVersion": 2,
                "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
                "config": {
                    "mediaType": "application/vnd.docker.container.image.v1+json",
                    "digest": "sha256:639823e18eb8b62cf43e92bac114ae35c03c07449e4ee5c10f8ebf8d033877d6",
                    "size": 774
                },
                "layers": [
                    {
                        "mediaType": "application/vnd.docker.image.rootfs.diff.tar.gzip",
                        "digest": "sha256:4abcf20661432fb2d719aaf90656f55c287f8ca915dc1c92ec14ff61e67fbaf8",
                        "size": 3408729
                    }
                ]
            },
            "v1": false,
            "v2": true,
            "oci": false
        }
    }

Metrics API​

These APIs provide usage (builds and pulls) metrics of Wave for a specific date and/or a organization. They require basic authentication (i.e., a username and password).

All Metrics API endpoints use these query parameters:

NameDescriptionsample Value
dateFormat: yyyy-mm-dd, The date of the required metrics.2024-04-08
orgDomain of the organization used in emails, e.g., org=seqera.ioseqera.io

GET /v1alpha2/metrics/builds​

Get the builds performed by Wave.

Response​

{
    metric: "builds",
    count: integer,
    orgs: {
        String: integer,
        String: integer,
        ...
    }
}

Examples​

Requests

curl -u foo:bar "http://localhost:9090/v1alpha2/metrics/builds"
{
    "metric": "builds",
    "count": 18,
    "orgs": {
        "seqera.io": 13,
        "gmail.com": 5
    }
}
curl -u foo:bar "http://localhost:9090/v1alpha2/metrics/builds?date=2024-04-08&org=seqera.io"
{"count":4}
curl -u foo:bar "http://localhost:9090/v1alpha2/metrics/builds?date=2024-04-08"
{
    "metric": "builds",
    "count": 8,
    "orgs": {
        "gmail.com": 4,
        "seqera.io": 4
    }
}
curl -u foo:bar "http://localhost:9090/v1alpha2/metrics/builds?org=seqera.io"
{
    "metric": "builds",
    "count": 13,
    "orgs": {
        "seqera.io": 13
    }
}

GET /v1alpha2/metrics/pulls​

Get the pulls performed through Wave.

Response​

{
    metric: "pulls",
    count: integer,
    orgs: {
        String: integer,
        String: integer,
        ...
    }
}

Examples​

curl -u foo:bar "http://localhost:9090/v1alpha2/metrics/pulls"
{
    "metric": "pulls",
    "count": 11,
    "orgs": {
        "seqera.io": 7,
        "gmail.com": 4
    }
}
curl -u foo:bar "http://localhost:9090/v1alpha2/metrics/pulls?date=2024-04-08&org=seqera.io"
{"count":5}
curl -u foo:bar "http://localhost:9090/v1alpha2/metrics/pulls?date=2024-04-08"
{
    "metric": "pulls",
    "count": 4,
    "orgs": {
        "seqera.io": 1,
        "gmail.com": 3
    }
}
curl -u foo:bar "http://localhost:9090/v1alpha2/metrics/pulls?org=seqera.io"
{
    "metric": "pulls",
    "count": 7,
    "orgs": {
        "seqera.io": 7
    }
}

GET /v1alpha2/metrics/fusion/pulls​

Get the pulls of Fusion-based containers performed through Wave.

Response​

{
    metric: "fusion",
    count: integer,
    orgs: {
        String: integer,
        String: integer,
        ...
    }
}

Examples​

curl -u foo:bar "http://localhost:9090/v1alpha2/metrics/fusion/pulls"
{
    "metric": "fusion",
    "count": 2,
    "orgs": {
        "seqera.io": 1,
        "gmail.com": 1
    }
}
curl -u foo:bar "http://localhost:9090/v1alpha2/metrics/fusion/pulls?date=2024-04-08&org=seqera.io"
{"count":2}
curl -u foo:bar "http://localhost:9090/v1alpha2/metrics/fusion/pulls?date=2024-04-08"
{
    "metric": "fusion",
    "count": 1,
    "orgs": {
        "gmail.com": 1
    }
}
curl -u foo:bar "http://localhost:9090/v1alpha2/metrics/fusion/pulls?org=seqera.io"
{
    "metric": "fusion",
    "count": 1,
    "orgs": {
        "seqera.io": 1
    }
}