Essential Commands

This reference covers the most commonly used Canton Console commands, organized by task. All examples assume you’re connected to a participant console unless otherwise noted. When the Canton Console starts, it reads the configuration file and automatically binds a variable for each configured node. For example, if your configuration defines a participant node, the console makes it available as the participant variable (or whatever name you gave it in the config). You can use this variable directly to call commands like participant.health.status without any additional setup.

Health and Status

Check whether the node is healthy and connected to the synchronizer:

@ participant1.health.status
    res1: NodeStatus[ParticipantStatus] = Participant id: PAR::participant1::12201ff69b1d24edbf0ee2028a304ea702ee8536790dab1a31e7136e6d90ff6d473c
    Uptime: 24.420201s
    Ports: 
    	ledger: 30520
    	admin: 30521
    	json: 30522
    Connected synchronizers: 
    	da::122032922613...::35-0
    Unhealthy synchronizers: None
    Active: true
    Components: 
    	memory_storage : Ok()
    	connected-synchronizer : Ok()
    	sync-ephemeral-state : Ok()
    	sequencer-client : Ok()
    	acs-commitment-processor : Ok()
    	sequencer-connection-pool : Ok()
    	sequencer-subscription-pool : Ok()
    	internal-sequencer-connection-sequencer1-0 : Ok()
    	subscription-sequencer-connection-sequencer1-0 : Ok()
    Version: 3.6.0-SNAPSHOT
    Supported protocol version(s): 35

@ participant1.health.is_running
    res2: Boolean = true

@ participant1.synchronizers.list_connected()
    res3: Seq[ListConnectedSynchronizersResult] = Vector(
      ListConnectedSynchronizersResult(
        synchronizerAlias = Synchronizer 'da',
        physicalSynchronizerId = da::122032922613...::35-0,
        healthy = true
      )
    )

For sequencer nodes:

@ sequencer1.health.status
    res4: NodeStatus[sequencer1.Status] = Sequencer id: sequencer1::1220cb0a22fb0aef9243a11f778497d7cacb19f9c4bcc7606776a109983edfaa6b4a
    Synchronizer id: da::122032922613929d67857e621fb13e3da49ec13883e24908404520319eee6d31fb4d::35-0
    Uptime: 21.962197s
    Ports: 
    	public: 30524
    	admin: 30525
    Connected participants: 
    	PAR::participant1::12201ff69b1d...
    Connected mediators: 
    	MED::mediator1::122009299340...
    Sequencer: SequencerHealthStatus(active = true)
    details-extra: None
    Components: 
    	memory_storage : Ok()
    	sequencer : Ok()
    Accepts admin changes: true
    Version: 3.6.0-SNAPSHOT
    Protocol version: 35

Party Management

Listing Parties

@ participant1.parties.hosted()
    res5: Seq[ListPartiesResult] = Vector(
      ListPartiesResult(
        partyResult = participant1::12201ff69b1d...,
        participants = Vector(
          ParticipantSynchronizers(
            participant = PAR::participant1::12201ff69b1d...,
            synchronizers = Vector(
              SynchronizerPermission(synchronizerId = da::122032922613..., permission = Submission)
            )
          )
        )
      ),
      ListPartiesResult(
        partyResult = Alice::12201ff69b1d...,
        participants = Vector(
          ParticipantSynchronizers(
            participant = PAR::participant1::12201ff69b1d...,
            synchronizers = Vector(
              SynchronizerPermission(synchronizerId = da::122032922613..., permission = Submission)
            )
          )
        )
      )
    )

@ participant1.parties.hosted("Alice")
    res6: Seq[ListPartiesResult] = Vector(
      ListPartiesResult(
        partyResult = Alice::12201ff69b1d...,
        participants = Vector(
          ParticipantSynchronizers(
            participant = PAR::participant1::12201ff69b1d...,
            synchronizers = Vector(
              SynchronizerPermission(synchronizerId = da::122032922613..., permission = Submission)
            )
          )
        )
      )
    )

@ participant1.parties.list()
    res7: Seq[ListPartiesResult] = Vector(
      ListPartiesResult(
        partyResult = participant1::12201ff69b1d...,
        participants = Vector(
          ParticipantSynchronizers(
            participant = PAR::participant1::12201ff69b1d...,
            synchronizers = Vector(
              SynchronizerPermission(synchronizerId = da::122032922613..., permission = Submission)
            )
          )
        )
      ),
      ListPartiesResult(
        partyResult = Alice::12201ff69b1d...,
        participants = Vector(
          ParticipantSynchronizers(
            participant = PAR::participant1::12201ff69b1d...,
            synchronizers = Vector(
              SynchronizerPermission(synchronizerId = da::122032922613..., permission = Submission)
            )
          )
        )
      )
    )

Party Details

@ participant1.parties.hosted("Alice").head
    res8: ListPartiesResult = ListPartiesResult(
      partyResult = Alice::12201ff69b1d...,
      participants = Vector(
        ParticipantSynchronizers(
          participant = PAR::participant1::12201ff69b1d...,
          synchronizers = Vector(
            SynchronizerPermission(synchronizerId = da::122032922613..., permission = Submission)
          )
        )
      )
    )

Package Management

Listing Packages

@ participant1.dars.list()
    res9: Seq[DarDescription] = Vector(
      DarDescription(
        mainPackageId = "de2cc2f90eb523414ff54e899951dadd8789a4c07e0f71f6d6c9eaf57d412a54",
        name = "canton-builtin-admin-workflow-ping",
        version = "3.4.0",
        description = "System package"
      )
    )

@ participant1.packages.list().filter(_.packageId.startsWith("com-example"))
    res10: Seq[PackageDescription] = Vector()

Uploading Packages

@ participant1.dars.upload("dars/CantonExamples.dar")
    res11: String = "2bf40efb6ff32ee400d0f1ade4fbc2aac695c75ed617ccdec57615fabbb4ad38"

Package Vetting

@ participant1.topology.vetted_packages.list()
    res12: Seq[com.digitalasset.canton.admin.api.client.data.topology.ListVettedPackagesResult] = Vector(
      ListVettedPackagesResult(
        context = BaseResult(
          storeId = Synchronizer(id = Right(value = da::122032922613...::35-0)),
          validFrom = 2026-06-04T11:37:11.844338Z,
          validUntil = None,
          sequenced = 2026-06-04T11:37:11.594338Z,
          operation = Replace,
          transactionHash = TxHash(hash = SHA-256:943b0d54ba7a...),
          serial = PositiveNumeric(value = 2),
          signedBy = Vector(12201ff69b1d...)
        ),
        item = VettedPackages(
          participantId = PAR::participant1::12201ff69b1d...,
          packages = VettedPackage(packageId = 6f8e6085f576..., unbounded),VettedPackage(packageId = 60c61c542207..., unbounded),VettedPackage(packageId = a1fa18133ae4..., unbounded),VettedPackage(packageId = cae345b5500e..., unbounded),VettedPackage(packageId = c3bb0c5d0479..., unbounded),... 29 more
        )
      )
    )

@ participant1.topology.vetted_packages.list().filter(_.item.packages.exists(_.packageId.toString.contains(packageId)))
    res13: Seq[com.digitalasset.canton.admin.api.client.data.topology.ListVettedPackagesResult] = Vector(
      ListVettedPackagesResult(
        context = BaseResult(
          storeId = Synchronizer(id = Right(value = da::122032922613...::35-0)),
          validFrom = 2026-06-04T11:37:11.844338Z,
          validUntil = None,
          sequenced = 2026-06-04T11:37:11.594338Z,
          operation = Replace,
          transactionHash = TxHash(hash = SHA-256:943b0d54ba7a...),
          serial = PositiveNumeric(value = 2),
          signedBy = Vector(12201ff69b1d...)
        ),
        item = VettedPackages(
          participantId = PAR::participant1::12201ff69b1d...,
          packages = VettedPackage(packageId = 6f8e6085f576..., unbounded),VettedPackage(packageId = 60c61c542207..., unbounded),VettedPackage(packageId = a1fa18133ae4..., unbounded),VettedPackage(packageId = cae345b5500e..., unbounded),VettedPackage(packageId = c3bb0c5d0479..., unbounded),... 29 more
        )
      )
    )

Topology Inspection

Topology commands show the current state of party-to-participant mappings, package vetting, and other network-wide configuration.

Party-to-Participant Mappings

@ participant1.topology.party_to_participant_mappings.list(synchronizerId)
    res14: Seq[com.digitalasset.canton.admin.api.client.data.topology.ListPartyToParticipantResult] = Vector(
      ListPartyToParticipantResult(
        context = BaseResult(
          storeId = Synchronizer(id = Right(value = da::122032922613...::35-0)),
          validFrom = 2026-06-04T11:37:01.603918Z,
          validUntil = None,
          sequenced = 2026-06-04T11:37:01.353918Z,
          operation = Replace,
          transactionHash = TxHash(hash = SHA-256:6882f6f9ceea...),
          serial = PositiveNumeric(value = 1),
          signedBy = Vector(12201ff69b1d...)
        ),
        item = PartyToParticipant(
          partyId = Alice::12201ff69b1d...,
          participants = PAR::participant1::12201ff69b1d... -> Submission
        )
      )
    )

Synchronizer Parameters

@ participant1.topology.synchronizer_parameters.list(synchronizerId)
    res15: Seq[com.digitalasset.canton.admin.api.client.data.topology.ListSynchronizerParametersStateResult] = Vector(
      ListSynchronizerParametersStateResult(
        context = BaseResult(
          storeId = Synchronizer(id = Right(value = da::122032922613...::35-0)),
          validFrom = 0001-01-01T00:00:00.000001Z,
          validUntil = None,
          sequenced = 0001-01-01T00:00:00.000001Z,
          operation = Replace,
          transactionHash = TxHash(hash = SHA-256:bb924a6165c0...),
          serial = PositiveNumeric(value = 1),
          signedBy = Vector(1220cb0a22fb...)
        ),
        item = DynamicSynchronizerParameters(
          confirmation response timeout = 30s,
          mediator reaction timeout = 30s,
          assignment exclusivity timeout = 1m,
          ledger time record time tolerance = 1m,
          mediator deduplication timeout = 48h,
          reconciliation interval = 1m,
          confirmation requests max rate = 1000000,
          max request size = 10485760,
          sequencer aggregate submission timeout = 6m,
          ACS commitment catchup = AcsCommitmentsCatchUpParameters(
            catchUpIntervalSkip = 5,
            nrIntervalsToTriggerCatchUp = 2
          ),
          participant synchronizer limits = ParticipantSynchronizerLimits(
            confirmation requests max rate = 1000000
          ),
          preparation time record time tolerance = 24h,
          onboarding restriction = UnrestrictedOpen
        )
      )
    )

Namespace Delegations

@ participant1.topology.namespace_delegations.list(store = synchronizerId)
    res16: Seq[com.digitalasset.canton.admin.api.client.data.topology.ListNamespaceDelegationResult] = Vector(
      ListNamespaceDelegationResult(
        context = BaseResult(
          storeId = Synchronizer(id = Right(value = da::122032922613...::35-0)),
          validFrom = 0001-01-01T00:00:00.000001Z,
          validUntil = None,
          sequenced = 0001-01-01T00:00:00.000001Z,
          operation = Replace,
          transactionHash = TxHash(hash = SHA-256:9064e1eaf436...),
          serial = PositiveNumeric(value = 1),
          signedBy = Vector(1220cb0a22fb...)
        ),
        item = NamespaceDelegation(
          namespace = 1220cb0a22fb...,
          target = SigningPublicKey(
            id = 1220cb0a22fb...,
            format = DER-encoded X.509 SubjectPublicKeyInfo,
            keySpec = EC-Curve25519,
            usage = namespace
          ),
          restriction = none
        )
      ),
      ListNamespaceDelegationResult(
        context = BaseResult(
          storeId = Synchronizer(id = Right(value = da::122032922613...::35-0)),
          validFrom = 0001-01-01T00:00:00.000001Z,
          validUntil = None,
          sequenced = 0001-01-01T00:00:00.000001Z,
          operation = Replace,
          transactionHash = TxHash(hash = SHA-256:e5dfa02d10cf...),
          serial = PositiveNumeric(value = 1),
          signedBy = Vector(122009299340...)
        ),
        item = NamespaceDelegation(
          namespace = 122009299340...,
          target = SigningPublicKey(
            id = 122009299340...,
            format = DER-encoded X.509 SubjectPublicKeyInfo,
            keySpec = EC-Curve25519,
            usage = namespace
          ),
          restriction = none
        )
      ),
      ListNamespaceDelegationResult(
        context = BaseResult(
          storeId = Synchronizer(id = Right(value = da::122032922613...::35-0)),
          validFrom = 2026-06-04T11:36:50.051975Z,
          validUntil = None,
          sequenced = 2026-06-04T11:36:49.801975Z,
          operation = Replace,
          transactionHash = TxHash(hash = SHA-256:252f433640a0...),
          serial = PositiveNumeric(value = 1),
          signedBy = Vector(12201ff69b1d...)
        ),
        item = NamespaceDelegation(
          namespace = 12201ff69b1d...,
          target = SigningPublicKey(
            id = 12201ff69b1d...,
            format = DER-encoded X.509 SubjectPublicKeyInfo,
            keySpec = EC-Curve25519,
            usage = namespace
          ),
          restriction = none
        )
      )
    )

Synchronizer Operations

Listing Connected Synchronizers

@ participant1.synchronizers.list_connected()
    res17: Seq[ListConnectedSynchronizersResult] = Vector(
      ListConnectedSynchronizersResult(
        synchronizerAlias = Synchronizer 'da',
        physicalSynchronizerId = da::122032922613...::35-0,
        healthy = true
      )
    )

Reconnecting to a Synchronizer

@ val syncAlias = participant1.synchronizers.list_connected().head.synchronizerAlias
    syncAlias : SynchronizerAlias = Synchronizer 'da'

@ participant1.synchronizers.reconnect(syncAlias)
    res19: Boolean = true

Querying the Ledger

Active Contract Set (ACS)

@ participant1.testing.acs_search(synchronizerAlias, filterTemplate = "Iou:Iou").size
    res20: Int = 1

@ participant1.testing.acs_search(synchronizerAlias, filterTemplate = "Iou:Iou", filterStakeholder = Some(partyId))
    res21: List[com.digitalasset.canton.protocol.package.ContractInstance] = List(
      ContractInstanceImpl(
        contractId = 9b59880d6fb8...ca1212206feb3080...,
        metadata = ContractMetadata(
          signatories = Alice::12201ff69b1d...,
          stakeholders = Alice::12201ff69b1d...
        ),
        created at = 2026-06-04T11:37:21.448022Z
      )
    )

The testing.acs_search command is intended for debugging, not production queries. For production read access, use PQS.

Common Patterns

Getting the Participant ID

@ val participantId = participant1.id
    participantId : ParticipantId = PAR::participant1::12201ff69b1d...

Getting a Party ID

@ val partyId2 = participant1.parties.hosted("Alice").head.party
    partyId2 : PartyId = Alice::12201ff69b1d...

Getting the Synchronizer ID

@ val syncId2 = participant1.synchronizers.list_connected().head.synchronizerId
    syncId2 : SynchronizerId = da::122032922613...

Next Steps

Debugging Workflows — Using these commands in diagnostic scenarios
Canton Console Reference — How to start the console

Overview

Validator Deployment

Super Validator Deployment

Splice Fundamentals

Canton Console

Production Operations

Extension Synchronizers

Troubleshooting

Release Notes

Reference

Community Resources

Health and Status

Party Management

Listing Parties

Party Details

Package Management

Listing Packages

Uploading Packages

Package Vetting

Topology Inspection

Party-to-Participant Mappings

Synchronizer Parameters

Namespace Delegations

Synchronizer Operations

Listing Connected Synchronizers

Reconnecting to a Synchronizer

Querying the Ledger

Active Contract Set (ACS)

Common Patterns

Getting the Participant ID

Getting a Party ID

Getting the Synchronizer ID

Next Steps

​Health and Status

​Party Management

​Listing Parties

​Party Details

​Package Management

​Listing Packages

​Uploading Packages

​Package Vetting

​Topology Inspection

​Party-to-Participant Mappings

​Synchronizer Parameters

​Namespace Delegations

​Synchronizer Operations

​Listing Connected Synchronizers

​Reconnecting to a Synchronizer

​Querying the Ledger

​Active Contract Set (ACS)

​Common Patterns

​Getting the Participant ID

​Getting a Party ID

​Getting the Synchronizer ID

​Next Steps

Health and Status

Party Management

Listing Parties

Party Details

Package Management

Listing Packages

Uploading Packages

Package Vetting

Topology Inspection

Party-to-Participant Mappings

Synchronizer Parameters

Namespace Delegations

Synchronizer Operations

Listing Connected Synchronizers

Reconnecting to a Synchronizer

Querying the Ledger

Active Contract Set (ACS)

Common Patterns

Getting the Participant ID

Getting a Party ID

Getting the Synchronizer ID

Next Steps