Connect apps service (gRPC)#

Service for creating and managing Connect Apps

Endpoints#

Archive connect apps#

gRPC /nominal.connect.v1.ConnectAppsService/ArchiveConnectApps

Archive Connect Apps

Request: ArchiveConnectAppsRequest

rids array of string

Response: ArchiveConnectAppsResponse

rids array of string

Request

Python

import grpc
from nominal.protos.connect.v1 import connect_apps_pb2, connect_apps_pb2_grpc

channel = grpc.secure_channel("api.gov.nominal.io:443", grpc.ssl_channel_credentials())
connect_apps_service = connect_apps_pb2_grpc.ConnectAppsServiceStub(channel)
auth = [("authorization", "Bearer <api key>")]

request = connect_apps_pb2.ArchiveConnectAppsRequest(rids=["<rids>"])
response = connect_apps_service.ArchiveConnectApps(request, metadata=auth)
print(response)

package main

import (
	"context"
	"crypto/tls"
	"fmt"
	"log"

	connectv1 "github.com/nominal-io/nominal-api-protos-go/nominal/protos/connect/v1"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials"
	"google.golang.org/grpc/metadata"
)

func main() {
	conn, err := grpc.NewClient("api.gov.nominal.io:443",
		grpc.WithTransportCredentials(credentials.NewTLS(&tls.Config{})))
	if err != nil {
		log.Fatal(err)
	}
	defer conn.Close()
	connectAppsService := connectv1.NewConnectAppsServiceClient(conn)
	ctx := metadata.AppendToOutgoingContext(context.Background(), "authorization", "Bearer <api key>")

	request := &connectv1.ArchiveConnectAppsRequest{
		Rids: []string{
			"<rids>",
		},
	}
	response, err := connectAppsService.ArchiveConnectApps(ctx, request)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(response)
}

Response

{
  "rids": [
    "<rids>"
  ]
}

Commit#

gRPC /nominal.connect.v1.ConnectAppsService/Commit

Commit a bundle to the main branch

Request: CommitRequest

rid string

bundle ConnectAppBundle

Fields of ConnectAppBundle

s3_path Handle

Fields of Handle

s3 string

metadata ConnectAppBundleMetadata

Fields of ConnectAppBundleMetadata

title string
contains_experimental_features boolean
sha256_checksum string
connect_file_path string: name of the .connect file inside the bundle. Will default to app.connect

message string

Response: CommitResponse

app ConnectApp

Fields of ConnectApp

rid string

commit string

metadata ConnectAppMetadata

Fields of ConnectAppMetadata

rid string
display_name string
description string
labels array of string
properties map of string to string
is_archived boolean
is_published boolean
created_at string (date-time)
created_by string
updated_at string (date-time)
workspace string

bundle ConnectAppBundle

Fields of ConnectAppBundle

s3_path Handle

Fields of Handle

s3 string

metadata ConnectAppBundleMetadata

Fields of ConnectAppBundleMetadata

title string
contains_experimental_features boolean
sha256_checksum string
connect_file_path string: name of the .connect file inside the bundle. Will default to app.connect

version_number integer (uint64)

Request

Python

import grpc
from nominal.protos.connect.v1 import connect_apps_pb2, connect_apps_pb2_grpc

channel = grpc.secure_channel("api.gov.nominal.io:443", grpc.ssl_channel_credentials())
connect_apps_service = connect_apps_pb2_grpc.ConnectAppsServiceStub(channel)
auth = [("authorization", "Bearer <api key>")]

request = connect_apps_pb2.CommitRequest(
    rid="<rid>",
    bundle={
        "s3_path": {"s3": "<s3>"},
        "metadata": {
            "title": "<title>",
            "contains_experimental_features": True,
            "sha256_checksum": "<sha256 checksum>",
            "connect_file_path": "<connect file path>",
        },
    },
    message="<message>",
)
response = connect_apps_service.Commit(request, metadata=auth)
print(response)

package main

import (
	"context"
	"crypto/tls"
	"fmt"
	"log"

	connectv1 "github.com/nominal-io/nominal-api-protos-go/nominal/protos/connect/v1"
	"github.com/nominal-io/nominal-api-protos-go/nominal/protos/types"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials"
	"google.golang.org/grpc/metadata"
	"google.golang.org/protobuf/proto"
)

func main() {
	conn, err := grpc.NewClient("api.gov.nominal.io:443",
		grpc.WithTransportCredentials(credentials.NewTLS(&tls.Config{})))
	if err != nil {
		log.Fatal(err)
	}
	defer conn.Close()
	connectAppsService := connectv1.NewConnectAppsServiceClient(conn)
	ctx := metadata.AppendToOutgoingContext(context.Background(), "authorization", "Bearer <api key>")

	request := &connectv1.CommitRequest{
		Rid: "<rid>",
		Bundle: &connectv1.ConnectAppBundle{
			S3Path: &types.Handle{
				Handle: &types.Handle_S3{S3: "<s3>"},
			},
			Metadata: &connectv1.ConnectAppBundleMetadata{
				Title:                        "<title>",
				ContainsExperimentalFeatures: true,
				Sha256Checksum:               "<sha256 checksum>",
				ConnectFilePath:              proto.String("<connect file path>"),
			},
		},
		Message: "<message>",
	}
	response, err := connectAppsService.Commit(ctx, request)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(response)
}

Response

{
  "app": {
    "rid": "<rid>",
    "commit": "<commit>",
    "metadata": {
      "rid": "<rid>",
      "display_name": "<display name>",
      "description": "<description>",
      "labels": [
        "<labels>"
      ],
      "properties": {
        "<key>": "<value>"
      },
      "is_archived": true,
      "is_published": true,
      "created_at": "2026-01-01T00:00:00Z",
      "created_by": "<created by>",
      "updated_at": "2026-01-01T00:00:00Z",
      "workspace": "<workspace>"
    },
    "bundle": {
      "s3_path": {
        "s3": "<s3>"
      },
      "metadata": {
        "title": "<title>",
        "contains_experimental_features": true,
        "sha256_checksum": "<sha256 checksum>",
        "connect_file_path": "<connect file path>"
      }
    },
    "version_number": 1
  }
}

Create connect app#

gRPC /nominal.connect.v1.ConnectAppsService/CreateConnectApp

Create a new Connect App, either with a bundle file or as an empty app

Request: CreateConnectAppRequest

display_name string

separate from the bundle title to allow for creating empty apps At least 1 character.

description string

labels array of string

properties map of string to string

is_published boolean

workspace string

bundle ConnectAppBundle

optional to allow for creating “empty” in-progress connect apps

Fields of ConnectAppBundle

s3_path Handle

Fields of Handle

s3 string

metadata ConnectAppBundleMetadata

Fields of ConnectAppBundleMetadata

title string
contains_experimental_features boolean
sha256_checksum string
connect_file_path string: name of the .connect file inside the bundle. Will default to app.connect

commit_message string

Response: CreateConnectAppResponse

app ConnectApp

Fields of ConnectApp

rid string

commit string

metadata ConnectAppMetadata

Fields of ConnectAppMetadata

rid string
display_name string
description string
labels array of string
properties map of string to string
is_archived boolean
is_published boolean
created_at string (date-time)
created_by string
updated_at string (date-time)
workspace string

bundle ConnectAppBundle

Fields of ConnectAppBundle

s3_path Handle

Fields of Handle

s3 string

metadata ConnectAppBundleMetadata

Fields of ConnectAppBundleMetadata

title string
contains_experimental_features boolean
sha256_checksum string
connect_file_path string: name of the .connect file inside the bundle. Will default to app.connect

version_number integer (uint64)

Request

Python

import grpc
from nominal.protos.connect.v1 import connect_apps_pb2, connect_apps_pb2_grpc

channel = grpc.secure_channel("api.gov.nominal.io:443", grpc.ssl_channel_credentials())
connect_apps_service = connect_apps_pb2_grpc.ConnectAppsServiceStub(channel)
auth = [("authorization", "Bearer <api key>")]

request = connect_apps_pb2.CreateConnectAppRequest(
    display_name="<display name>",
    description="<description>",
    labels=["<labels>"],
    properties={"<key>": "<value>"},
    is_published=True,
    workspace="<workspace>",
    bundle={
        "s3_path": {"s3": "<s3>"},
        "metadata": {
            "title": "<title>",
            "contains_experimental_features": True,
            "sha256_checksum": "<sha256 checksum>",
            "connect_file_path": "<connect file path>",
        },
    },
    commit_message="<commit message>",
)
response = connect_apps_service.CreateConnectApp(request, metadata=auth)
print(response)

package main

import (
	"context"
	"crypto/tls"
	"fmt"
	"log"

	connectv1 "github.com/nominal-io/nominal-api-protos-go/nominal/protos/connect/v1"
	"github.com/nominal-io/nominal-api-protos-go/nominal/protos/types"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials"
	"google.golang.org/grpc/metadata"
	"google.golang.org/protobuf/proto"
)

func main() {
	conn, err := grpc.NewClient("api.gov.nominal.io:443",
		grpc.WithTransportCredentials(credentials.NewTLS(&tls.Config{})))
	if err != nil {
		log.Fatal(err)
	}
	defer conn.Close()
	connectAppsService := connectv1.NewConnectAppsServiceClient(conn)
	ctx := metadata.AppendToOutgoingContext(context.Background(), "authorization", "Bearer <api key>")

	request := &connectv1.CreateConnectAppRequest{
		DisplayName: "<display name>",
		Description: proto.String("<description>"),
		Labels: []string{
			"<labels>",
		},
		Properties: map[string]string{
			"<key>": "<value>",
		},
		IsPublished: proto.Bool(true),
		Workspace:   "<workspace>",
		Bundle: &connectv1.ConnectAppBundle{
			S3Path: &types.Handle{
				Handle: &types.Handle_S3{S3: "<s3>"},
			},
			Metadata: &connectv1.ConnectAppBundleMetadata{
				Title:                        "<title>",
				ContainsExperimentalFeatures: true,
				Sha256Checksum:               "<sha256 checksum>",
				ConnectFilePath:              proto.String("<connect file path>"),
			},
		},
		CommitMessage: "<commit message>",
	}
	response, err := connectAppsService.CreateConnectApp(ctx, request)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(response)
}

Response

{
  "app": {
    "rid": "<rid>",
    "commit": "<commit>",
    "metadata": {
      "rid": "<rid>",
      "display_name": "<display name>",
      "description": "<description>",
      "labels": [
        "<labels>"
      ],
      "properties": {
        "<key>": "<value>"
      },
      "is_archived": true,
      "is_published": true,
      "created_at": "2026-01-01T00:00:00Z",
      "created_by": "<created by>",
      "updated_at": "2026-01-01T00:00:00Z",
      "workspace": "<workspace>"
    },
    "bundle": {
      "s3_path": {
        "s3": "<s3>"
      },
      "metadata": {
        "title": "<title>",
        "contains_experimental_features": true,
        "sha256_checksum": "<sha256 checksum>",
        "connect_file_path": "<connect file path>"
      }
    },
    "version_number": 1
  }
}

Get connect app#

gRPC /nominal.connect.v1.ConnectAppsService/GetConnectApp

Get a Connect App by its RID

Request: GetConnectAppRequest

rid string

branch_or_commit BranchOrCommit

Fields of BranchOrCommit

one of branch, commit required

branch

branch string

commit

commit string

Response: GetConnectAppResponse

app ConnectApp

Fields of ConnectApp

rid string

commit string

metadata ConnectAppMetadata

Fields of ConnectAppMetadata

rid string
display_name string
description string
labels array of string
properties map of string to string
is_archived boolean
is_published boolean
created_at string (date-time)
created_by string
updated_at string (date-time)
workspace string

bundle ConnectAppBundle

Fields of ConnectAppBundle

s3_path Handle

Fields of Handle

s3 string

metadata ConnectAppBundleMetadata

Fields of ConnectAppBundleMetadata

title string
contains_experimental_features boolean
sha256_checksum string
connect_file_path string: name of the .connect file inside the bundle. Will default to app.connect

version_number integer (uint64)

Request

Python

import grpc
from nominal.protos.connect.v1 import connect_apps_pb2, connect_apps_pb2_grpc

channel = grpc.secure_channel("api.gov.nominal.io:443", grpc.ssl_channel_credentials())
connect_apps_service = connect_apps_pb2_grpc.ConnectAppsServiceStub(channel)
auth = [("authorization", "Bearer <api key>")]

request = connect_apps_pb2.GetConnectAppRequest(
    rid="<rid>",
    branch_or_commit={"branch": "<branch>"},
)
response = connect_apps_service.GetConnectApp(request, metadata=auth)
print(response)

package main

import (
	"context"
	"crypto/tls"
	"fmt"
	"log"

	connectv1 "github.com/nominal-io/nominal-api-protos-go/nominal/protos/connect/v1"
	versioningv1 "github.com/nominal-io/nominal-api-protos-go/nominal/protos/versioning/v1"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials"
	"google.golang.org/grpc/metadata"
)

func main() {
	conn, err := grpc.NewClient("api.gov.nominal.io:443",
		grpc.WithTransportCredentials(credentials.NewTLS(&tls.Config{})))
	if err != nil {
		log.Fatal(err)
	}
	defer conn.Close()
	connectAppsService := connectv1.NewConnectAppsServiceClient(conn)
	ctx := metadata.AppendToOutgoingContext(context.Background(), "authorization", "Bearer <api key>")

	request := &connectv1.GetConnectAppRequest{
		Rid: "<rid>",
		BranchOrCommit: &versioningv1.BranchOrCommit{
			BranchOrCommit: &versioningv1.BranchOrCommit_Branch{Branch: "<branch>"},
		},
	}
	response, err := connectAppsService.GetConnectApp(ctx, request)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(response)
}

Response

{
  "app": {
    "rid": "<rid>",
    "commit": "<commit>",
    "metadata": {
      "rid": "<rid>",
      "display_name": "<display name>",
      "description": "<description>",
      "labels": [
        "<labels>"
      ],
      "properties": {
        "<key>": "<value>"
      },
      "is_archived": true,
      "is_published": true,
      "created_at": "2026-01-01T00:00:00Z",
      "created_by": "<created by>",
      "updated_at": "2026-01-01T00:00:00Z",
      "workspace": "<workspace>"
    },
    "bundle": {
      "s3_path": {
        "s3": "<s3>"
      },
      "metadata": {
        "title": "<title>",
        "contains_experimental_features": true,
        "sha256_checksum": "<sha256 checksum>",
        "connect_file_path": "<connect file path>"
      }
    },
    "version_number": 1
  }
}

Get connect app bundle download URL#

gRPC /nominal.connect.v1.ConnectAppsService/GetConnectAppBundleDownloadUrl

Get a pre-signed URL for downloading the bundle of a Connect App at a specific commit or the latest commit on the main branch

Request: GetConnectAppBundleDownloadUrlRequest

rid string

branch_or_commit BranchOrCommit

Fields of BranchOrCommit

one of branch, commit required

branch

branch string

commit

commit string

Response: GetConnectAppBundleDownloadUrlResponse

url string

Request

Python

import grpc
from nominal.protos.connect.v1 import connect_apps_pb2, connect_apps_pb2_grpc

channel = grpc.secure_channel("api.gov.nominal.io:443", grpc.ssl_channel_credentials())
connect_apps_service = connect_apps_pb2_grpc.ConnectAppsServiceStub(channel)
auth = [("authorization", "Bearer <api key>")]

request = connect_apps_pb2.GetConnectAppBundleDownloadUrlRequest(
    rid="<rid>",
    branch_or_commit={"branch": "<branch>"},
)
response = connect_apps_service.GetConnectAppBundleDownloadUrl(request, metadata=auth)
print(response)

package main

import (
	"context"
	"crypto/tls"
	"fmt"
	"log"

	connectv1 "github.com/nominal-io/nominal-api-protos-go/nominal/protos/connect/v1"
	versioningv1 "github.com/nominal-io/nominal-api-protos-go/nominal/protos/versioning/v1"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials"
	"google.golang.org/grpc/metadata"
)

func main() {
	conn, err := grpc.NewClient("api.gov.nominal.io:443",
		grpc.WithTransportCredentials(credentials.NewTLS(&tls.Config{})))
	if err != nil {
		log.Fatal(err)
	}
	defer conn.Close()
	connectAppsService := connectv1.NewConnectAppsServiceClient(conn)
	ctx := metadata.AppendToOutgoingContext(context.Background(), "authorization", "Bearer <api key>")

	request := &connectv1.GetConnectAppBundleDownloadUrlRequest{
		Rid: "<rid>",
		BranchOrCommit: &versioningv1.BranchOrCommit{
			BranchOrCommit: &versioningv1.BranchOrCommit_Branch{Branch: "<branch>"},
		},
	}
	response, err := connectAppsService.GetConnectAppBundleDownloadUrl(ctx, request)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(response)
}

Response

{
  "url": "<url>"
}

Search connect apps#

gRPC /nominal.connect.v1.ConnectAppsService/SearchConnectApps

Searches for Connect Apps, returning paged results. Workspaces the caller lacks workspace:view on are filtered out rather than failing the call.

Request: SearchConnectAppsRequest

query ConnectAppSearchQuery

Fields of ConnectAppSearchQuery

one of 7 fields required

search_text

search_text string

label

label string

property

property Property

Fields of Property

name string
value string

and

and ConnectAppSearchAndQuery

Fields of ConnectAppSearchAndQuery

queries array of ConnectAppSearchQuery

or ConnectAppSearchOrQuery

Fields of ConnectAppSearchOrQuery

queries array of ConnectAppSearchQuery

workspace

workspace string

is_archived

is_archived boolean

options SearchConnectAppsOptions

Fields of SearchConnectAppsOptions

is_descending boolean

default is true

sort_field SearchConnectAppsSortField

default is title

Values of SearchConnectAppsSortField

SEARCH_CONNECT_APPS_SORT_FIELD_UNSPECIFIED
SEARCH_CONNECT_APPS_SORT_FIELD_TITLE
SEARCH_CONNECT_APPS_SORT_FIELD_CREATED_AT
SEARCH_CONNECT_APPS_SORT_FIELD_DISPLAY_NAME

page_size integer

From 1 to 1,000.

next_page_token string

Response: SearchConnectAppsResponse

app_metadata array of ConnectAppMetadata

Fields of ConnectAppMetadata

rid string
display_name string
description string
labels array of string
properties map of string to string
is_archived boolean
is_published boolean
created_at string (date-time)
created_by string
updated_at string (date-time)
workspace string

next_page_token string

Request

Python

import grpc
from nominal.protos.connect.v1 import connect_apps_pb2, connect_apps_pb2_grpc

channel = grpc.secure_channel("api.gov.nominal.io:443", grpc.ssl_channel_credentials())
connect_apps_service = connect_apps_pb2_grpc.ConnectAppsServiceStub(channel)
auth = [("authorization", "Bearer <api key>")]

request = connect_apps_pb2.SearchConnectAppsRequest(
    query={"search_text": "<search text>"},
    options={
        "is_descending": True,
        "sort_field": "SEARCH_CONNECT_APPS_SORT_FIELD_TITLE",
    },
    page_size=1,
    next_page_token="<next page token>",
)
response = connect_apps_service.SearchConnectApps(request, metadata=auth)
print(response)

package main

import (
	"context"
	"crypto/tls"
	"fmt"
	"log"

	connectv1 "github.com/nominal-io/nominal-api-protos-go/nominal/protos/connect/v1"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials"
	"google.golang.org/grpc/metadata"
	"google.golang.org/protobuf/proto"
)

func main() {
	conn, err := grpc.NewClient("api.gov.nominal.io:443",
		grpc.WithTransportCredentials(credentials.NewTLS(&tls.Config{})))
	if err != nil {
		log.Fatal(err)
	}
	defer conn.Close()
	connectAppsService := connectv1.NewConnectAppsServiceClient(conn)
	ctx := metadata.AppendToOutgoingContext(context.Background(), "authorization", "Bearer <api key>")

	request := &connectv1.SearchConnectAppsRequest{
		Query: &connectv1.ConnectAppSearchQuery{
			Query: &connectv1.ConnectAppSearchQuery_SearchText{SearchText: "<search text>"},
		},
		Options: &connectv1.SearchConnectAppsOptions{
			IsDescending: proto.Bool(true),
			SortField:    connectv1.SearchConnectAppsSortField_SEARCH_CONNECT_APPS_SORT_FIELD_TITLE.Enum(),
		},
		PageSize:      proto.Int32(1),
		NextPageToken: proto.String("<next page token>"),
	}
	response, err := connectAppsService.SearchConnectApps(ctx, request)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(response)
}

Response

{
  "app_metadata": [
    {
      "rid": "<rid>",
      "display_name": "<display name>",
      "description": "<description>",
      "labels": [
        "<labels>"
      ],
      "properties": {
        "<key>": "<value>"
      },
      "is_archived": true,
      "is_published": true,
      "created_at": "2026-01-01T00:00:00Z",
      "created_by": "<created by>",
      "updated_at": "2026-01-01T00:00:00Z",
      "workspace": "<workspace>"
    }
  ],
  "next_page_token": "<next page token>"
}

Unarchive connect apps#

gRPC /nominal.connect.v1.ConnectAppsService/UnarchiveConnectApps

Unarchive Connect Apps

Request: UnarchiveConnectAppsRequest

rids array of string

Response: UnarchiveConnectAppsResponse

rids array of string

Request

Python

import grpc
from nominal.protos.connect.v1 import connect_apps_pb2, connect_apps_pb2_grpc

channel = grpc.secure_channel("api.gov.nominal.io:443", grpc.ssl_channel_credentials())
connect_apps_service = connect_apps_pb2_grpc.ConnectAppsServiceStub(channel)
auth = [("authorization", "Bearer <api key>")]

request = connect_apps_pb2.UnarchiveConnectAppsRequest(rids=["<rids>"])
response = connect_apps_service.UnarchiveConnectApps(request, metadata=auth)
print(response)

package main

import (
	"context"
	"crypto/tls"
	"fmt"
	"log"

	connectv1 "github.com/nominal-io/nominal-api-protos-go/nominal/protos/connect/v1"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials"
	"google.golang.org/grpc/metadata"
)

func main() {
	conn, err := grpc.NewClient("api.gov.nominal.io:443",
		grpc.WithTransportCredentials(credentials.NewTLS(&tls.Config{})))
	if err != nil {
		log.Fatal(err)
	}
	defer conn.Close()
	connectAppsService := connectv1.NewConnectAppsServiceClient(conn)
	ctx := metadata.AppendToOutgoingContext(context.Background(), "authorization", "Bearer <api key>")

	request := &connectv1.UnarchiveConnectAppsRequest{
		Rids: []string{
			"<rids>",
		},
	}
	response, err := connectAppsService.UnarchiveConnectApps(ctx, request)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(response)
}

Response

{
  "rids": [
    "<rids>"
  ]
}

Update connect app metadata#

gRPC /nominal.connect.v1.ConnectAppsService/UpdateConnectAppMetadata

Update metadata fields of a Connect App

Request: UpdateConnectAppMetadataRequest

rid string

display_name string

description string

labels LabelUpdateWrapper

Fields of LabelUpdateWrapper

labels array of string

properties PropertyUpdateWrapper

Fields of PropertyUpdateWrapper

properties map of string to string

is_archived boolean

is_published boolean

Response: UpdateConnectAppMetadataResponse

app_metadata ConnectAppMetadata

Fields of ConnectAppMetadata

rid string
display_name string
description string
labels array of string
properties map of string to string
is_archived boolean
is_published boolean
created_at string (date-time)
created_by string
updated_at string (date-time)
workspace string

Request

Python

import grpc
from nominal.protos.connect.v1 import connect_apps_pb2, connect_apps_pb2_grpc

channel = grpc.secure_channel("api.gov.nominal.io:443", grpc.ssl_channel_credentials())
connect_apps_service = connect_apps_pb2_grpc.ConnectAppsServiceStub(channel)
auth = [("authorization", "Bearer <api key>")]

request = connect_apps_pb2.UpdateConnectAppMetadataRequest(
    rid="<rid>",
    display_name="<display name>",
    description="<description>",
    labels={"labels": ["<labels>"]},
    properties={"properties": {"<key>": "<value>"}},
    is_archived=True,
    is_published=True,
)
response = connect_apps_service.UpdateConnectAppMetadata(request, metadata=auth)
print(response)

package main

import (
	"context"
	"crypto/tls"
	"fmt"
	"log"

	connectv1 "github.com/nominal-io/nominal-api-protos-go/nominal/protos/connect/v1"
	"github.com/nominal-io/nominal-api-protos-go/nominal/protos/types"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials"
	"google.golang.org/grpc/metadata"
	"google.golang.org/protobuf/proto"
)

func main() {
	conn, err := grpc.NewClient("api.gov.nominal.io:443",
		grpc.WithTransportCredentials(credentials.NewTLS(&tls.Config{})))
	if err != nil {
		log.Fatal(err)
	}
	defer conn.Close()
	connectAppsService := connectv1.NewConnectAppsServiceClient(conn)
	ctx := metadata.AppendToOutgoingContext(context.Background(), "authorization", "Bearer <api key>")

	request := &connectv1.UpdateConnectAppMetadataRequest{
		Rid:         "<rid>",
		DisplayName: proto.String("<display name>"),
		Description: proto.String("<description>"),
		Labels: &types.LabelUpdateWrapper{
			Labels: []string{
				"<labels>",
			},
		},
		Properties: &types.PropertyUpdateWrapper{
			Properties: map[string]string{
				"<key>": "<value>",
			},
		},
		IsArchived:  proto.Bool(true),
		IsPublished: proto.Bool(true),
	}
	response, err := connectAppsService.UpdateConnectAppMetadata(ctx, request)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(response)
}

Response

{
  "app_metadata": {
    "rid": "<rid>",
    "display_name": "<display name>",
    "description": "<description>",
    "labels": [
      "<labels>"
    ],
    "properties": {
      "<key>": "<value>"
    },
    "is_archived": true,
    "is_published": true,
    "created_at": "2026-01-01T00:00:00Z",
    "created_by": "<created by>",
    "updated_at": "2026-01-01T00:00:00Z",
    "workspace": "<workspace>"
  }
}

Errors#

Errors shows how these errors are sent.

Code	Reason	Message
`INVALID_ARGUMENT`	`CONNECT_APPS_SERVICE_ERROR_CANNOT_COMMIT_TO_ARCHIVED_CONNECT_APP`	Cannot commit to an archived connect app
`INVALID_ARGUMENT`	`CONNECT_APPS_SERVICE_ERROR_INVALID_SEARCH_TOKEN`	Invalid search token
`NOT_FOUND`	`CONNECT_APPS_SERVICE_ERROR_APP_NOT_FOUND`	Connect app not found
`NOT_FOUND`	`CONNECT_APPS_SERVICE_ERROR_COMMIT_NOT_FOUND`	Connect app commit not found
`NOT_FOUND`	`CONNECT_APPS_SERVICE_ERROR_MISSING_BUNDLE`	Connect app bundle is missing in this commit

Types#

BranchOrCommit#

Set exactly one of the fields below.

one of branch, commit required

branch

branch string

commit

commit string

ConnectApp#

rid string
commit string
metadata ConnectAppMetadata
bundle ConnectAppBundle
version_number integer (uint64)

ConnectAppBundle#

s3_path Handle
metadata ConnectAppBundleMetadata

ConnectAppBundleMetadata#

wrapper message for metadata that will probably be extended in the future

title string
contains_experimental_features boolean
sha256_checksum string
connect_file_path string: name of the .connect file inside the bundle. Will default to app.connect

ConnectAppMetadata#

rid string
display_name string
description string
labels array of string
properties map of string to string
is_archived boolean
is_published boolean
created_at string (date-time)
created_by string
updated_at string (date-time)
workspace string

ConnectAppSearchAndQuery#

queries array of ConnectAppSearchQuery

ConnectAppSearchOrQuery#

queries array of ConnectAppSearchQuery

ConnectAppSearchQuery#

Set exactly one of the fields below.

one of 7 fields required

search_text

search_text string

label

label string

property

property Property

and

and ConnectAppSearchAndQuery

or ConnectAppSearchOrQuery

workspace

workspace string

is_archived

is_archived boolean

Handle#

s3 string

LabelUpdateWrapper#

Wrapper classes to allow for optional fields on update requests

labels array of string

Property#

name string
value string

PropertyUpdateWrapper#

properties map of string to string

SearchConnectAppsOptions#

is_descending boolean: default is true
sort_field SearchConnectAppsSortField: default is title

SearchConnectAppsSortField#

SEARCH_CONNECT_APPS_SORT_FIELD_UNSPECIFIED
SEARCH_CONNECT_APPS_SORT_FIELD_TITLE
SEARCH_CONNECT_APPS_SORT_FIELD_CREATED_AT
SEARCH_CONNECT_APPS_SORT_FIELD_DISPLAY_NAME

Page design based on Scalar, MIT License.