curl --request POST \
  --url 'http://localhost:7575/v2/parties/external/allocate' \
  --header 'Authorization: Bearer $TOKEN' \
  --header 'Content-Type: application/json' \
  --data '{
  "synchronizer": "<string>",
  "onboardingTransactions": [
    {
      "transaction": "<string>",
      "signatures": [
        {
          "format": "<string>",
          "signature": "<string>",
          "signedBy": "<string>",
          "signingAlgorithmSpec": "<string>"
        }
      ]
    }
  ],
  "multiHashSignatures": [
    {
      "format": "<string>",
      "signature": "<string>",
      "signedBy": "<string>",
      "signingAlgorithmSpec": "<string>"
    }
  ],
  "identityProviderId": "<string>",
  "waitForAllocation": false,
  "userId": "<string>"
}'

import json
import requests

url = "http://localhost:7575/v2/parties/external/allocate"
headers = {'Authorization': 'Bearer <token>', 'Content-Type': 'application/json'}
payload = json.loads(r'''{
  "synchronizer": "<string>",
  "onboardingTransactions": [
    {
      "transaction": "<string>",
      "signatures": [
        {
          "format": "<string>",
          "signature": "<string>",
          "signedBy": "<string>",
          "signingAlgorithmSpec": "<string>"
        }
      ]
    }
  ],
  "multiHashSignatures": [
    {
      "format": "<string>",
      "signature": "<string>",
      "signedBy": "<string>",
      "signingAlgorithmSpec": "<string>"
    }
  ],
  "identityProviderId": "<string>",
  "waitForAllocation": false,
  "userId": "<string>"
}''')
response = requests.request(
    "POST", url, headers=headers, json=payload
)

print(response.text)

const response = await fetch('http://localhost:7575/v2/parties/external/allocate', {
  method: 'POST',
  headers: {
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
},
  body: JSON.stringify({
  "synchronizer": "<string>",
  "onboardingTransactions": [
    {
      "transaction": "<string>",
      "signatures": [
        {
          "format": "<string>",
          "signature": "<string>",
          "signedBy": "<string>",
          "signingAlgorithmSpec": "<string>"
        }
      ]
    }
  ],
  "multiHashSignatures": [
    {
      "format": "<string>",
      "signature": "<string>",
      "signedBy": "<string>",
      "signingAlgorithmSpec": "<string>"
    }
  ],
  "identityProviderId": "<string>",
  "waitForAllocation": false,
  "userId": "<string>"
}),
});

console.log(await response.text());

<?php
$curl = curl_init();

curl_setopt_array($curl, [
    CURLOPT_URL => 'http://localhost:7575/v2/parties/external/allocate',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_POSTFIELDS => <<<'JSON'
{
  "synchronizer": "<string>",
  "onboardingTransactions": [
    {
      "transaction": "<string>",
      "signatures": [
        {
          "format": "<string>",
          "signature": "<string>",
          "signedBy": "<string>",
          "signingAlgorithmSpec": "<string>"
        }
      ]
    }
  ],
  "multiHashSignatures": [
    {
      "format": "<string>",
      "signature": "<string>",
      "signedBy": "<string>",
      "signingAlgorithmSpec": "<string>"
    }
  ],
  "identityProviderId": "<string>",
  "waitForAllocation": false,
  "userId": "<string>"
}
JSON,
    CURLOPT_HTTPHEADER => [
        "Authorization: Bearer <token>",
        "Content-Type: application/json"
    ],
]);

$response = curl_exec($curl);
echo $response;

package main

import (
  "bytes"
  "fmt"
  "io"
  "net/http"
)

func main() {
  req, _ := http.NewRequest("POST", "http://localhost:7575/v2/parties/external/allocate", bytes.NewBufferString(`{
  "synchronizer": "<string>",
  "onboardingTransactions": [
    {
      "transaction": "<string>",
      "signatures": [
        {
          "format": "<string>",
          "signature": "<string>",
          "signedBy": "<string>",
          "signingAlgorithmSpec": "<string>"
        }
      ]
    }
  ],
  "multiHashSignatures": [
    {
      "format": "<string>",
      "signature": "<string>",
      "signedBy": "<string>",
      "signingAlgorithmSpec": "<string>"
    }
  ],
  "identityProviderId": "<string>",
  "waitForAllocation": false,
  "userId": "<string>"
}`))
  req.Header.Set("Authorization", "Bearer <token>")
  req.Header.Set("Content-Type", "application/json")
  response, _ := http.DefaultClient.Do(req)
  defer response.Body.Close()
  body, _ := io.ReadAll(response.Body)
  fmt.Println(string(body))
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

var request = HttpRequest.newBuilder()
    .uri(URI.create("http://localhost:7575/v2/parties/external/allocate"))
    .header("Authorization", "Bearer <token>")
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("""
{
  "synchronizer": "<string>",
  "onboardingTransactions": [
    {
      "transaction": "<string>",
      "signatures": [
        {
          "format": "<string>",
          "signature": "<string>",
          "signedBy": "<string>",
          "signingAlgorithmSpec": "<string>"
        }
      ]
    }
  ],
  "multiHashSignatures": [
    {
      "format": "<string>",
      "signature": "<string>",
      "signedBy": "<string>",
      "signingAlgorithmSpec": "<string>"
    }
  ],
  "identityProviderId": "<string>",
  "waitForAllocation": false,
  "userId": "<string>"
}
"""))
    .build();
var response = HttpClient.newHttpClient().send(
    request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

require 'net/http'
require 'uri'

uri = URI('http://localhost:7575/v2/parties/external/allocate')
request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer <token>'
request['Content-Type'] = 'application/json'
request.body = <<~JSON
{
  "synchronizer": "<string>",
  "onboardingTransactions": [
    {
      "transaction": "<string>",
      "signatures": [
        {
          "format": "<string>",
          "signature": "<string>",
          "signedBy": "<string>",
          "signingAlgorithmSpec": "<string>"
        }
      ]
    }
  ],
  "multiHashSignatures": [
    {
      "format": "<string>",
      "signature": "<string>",
      "signedBy": "<string>",
      "signingAlgorithmSpec": "<string>"
    }
  ],
  "identityProviderId": "<string>",
  "waitForAllocation": false,
  "userId": "<string>"
}
JSON
response = Net::HTTP.start(uri.hostname, uri.port) do |http|
  http.request(request)
end
puts response.body

{
  "partyId": "<string>"
}

<string>

{
  "code": "<string>",
  "cause": "<string>",
  "correlationId": "<string>",
  "traceId": "<string>",
  "context": {},
  "resources": [
    [
      "<string>"
    ]
  ],
  "errorCategory": 123,
  "grpcCodeValue": 123,
  "retryInfo": "<string>",
  "definiteAnswer": false
}

POST /v2/parties/external/allocate

The external party must be hosted (at least) on this node with either confirmation or observation permissions It can optionally be hosted on other nodes (then called a multi-hosted party). If hosted on additional nodes, explicit authorization of the hosting relationship must be performed on those nodes before the party can be used. Decentralized namespaces are supported but must be provided fully authorized by their owners.

POST

parties

external

allocate

curl --request POST \
  --url 'http://localhost:7575/v2/parties/external/allocate' \
  --header 'Authorization: Bearer $TOKEN' \
  --header 'Content-Type: application/json' \
  --data '{
  "synchronizer": "<string>",
  "onboardingTransactions": [
    {
      "transaction": "<string>",
      "signatures": [
        {
          "format": "<string>",
          "signature": "<string>",
          "signedBy": "<string>",
          "signingAlgorithmSpec": "<string>"
        }
      ]
    }
  ],
  "multiHashSignatures": [
    {
      "format": "<string>",
      "signature": "<string>",
      "signedBy": "<string>",
      "signingAlgorithmSpec": "<string>"
    }
  ],
  "identityProviderId": "<string>",
  "waitForAllocation": false,
  "userId": "<string>"
}'

import json
import requests

url = "http://localhost:7575/v2/parties/external/allocate"
headers = {'Authorization': 'Bearer <token>', 'Content-Type': 'application/json'}
payload = json.loads(r'''{
  "synchronizer": "<string>",
  "onboardingTransactions": [
    {
      "transaction": "<string>",
      "signatures": [
        {
          "format": "<string>",
          "signature": "<string>",
          "signedBy": "<string>",
          "signingAlgorithmSpec": "<string>"
        }
      ]
    }
  ],
  "multiHashSignatures": [
    {
      "format": "<string>",
      "signature": "<string>",
      "signedBy": "<string>",
      "signingAlgorithmSpec": "<string>"
    }
  ],
  "identityProviderId": "<string>",
  "waitForAllocation": false,
  "userId": "<string>"
}''')
response = requests.request(
    "POST", url, headers=headers, json=payload
)

print(response.text)

const response = await fetch('http://localhost:7575/v2/parties/external/allocate', {
  method: 'POST',
  headers: {
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
},
  body: JSON.stringify({
  "synchronizer": "<string>",
  "onboardingTransactions": [
    {
      "transaction": "<string>",
      "signatures": [
        {
          "format": "<string>",
          "signature": "<string>",
          "signedBy": "<string>",
          "signingAlgorithmSpec": "<string>"
        }
      ]
    }
  ],
  "multiHashSignatures": [
    {
      "format": "<string>",
      "signature": "<string>",
      "signedBy": "<string>",
      "signingAlgorithmSpec": "<string>"
    }
  ],
  "identityProviderId": "<string>",
  "waitForAllocation": false,
  "userId": "<string>"
}),
});

console.log(await response.text());

<?php
$curl = curl_init();

curl_setopt_array($curl, [
    CURLOPT_URL => 'http://localhost:7575/v2/parties/external/allocate',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_POSTFIELDS => <<<'JSON'
{
  "synchronizer": "<string>",
  "onboardingTransactions": [
    {
      "transaction": "<string>",
      "signatures": [
        {
          "format": "<string>",
          "signature": "<string>",
          "signedBy": "<string>",
          "signingAlgorithmSpec": "<string>"
        }
      ]
    }
  ],
  "multiHashSignatures": [
    {
      "format": "<string>",
      "signature": "<string>",
      "signedBy": "<string>",
      "signingAlgorithmSpec": "<string>"
    }
  ],
  "identityProviderId": "<string>",
  "waitForAllocation": false,
  "userId": "<string>"
}
JSON,
    CURLOPT_HTTPHEADER => [
        "Authorization: Bearer <token>",
        "Content-Type: application/json"
    ],
]);

$response = curl_exec($curl);
echo $response;

package main

import (
  "bytes"
  "fmt"
  "io"
  "net/http"
)

func main() {
  req, _ := http.NewRequest("POST", "http://localhost:7575/v2/parties/external/allocate", bytes.NewBufferString(`{
  "synchronizer": "<string>",
  "onboardingTransactions": [
    {
      "transaction": "<string>",
      "signatures": [
        {
          "format": "<string>",
          "signature": "<string>",
          "signedBy": "<string>",
          "signingAlgorithmSpec": "<string>"
        }
      ]
    }
  ],
  "multiHashSignatures": [
    {
      "format": "<string>",
      "signature": "<string>",
      "signedBy": "<string>",
      "signingAlgorithmSpec": "<string>"
    }
  ],
  "identityProviderId": "<string>",
  "waitForAllocation": false,
  "userId": "<string>"
}`))
  req.Header.Set("Authorization", "Bearer <token>")
  req.Header.Set("Content-Type", "application/json")
  response, _ := http.DefaultClient.Do(req)
  defer response.Body.Close()
  body, _ := io.ReadAll(response.Body)
  fmt.Println(string(body))
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

var request = HttpRequest.newBuilder()
    .uri(URI.create("http://localhost:7575/v2/parties/external/allocate"))
    .header("Authorization", "Bearer <token>")
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("""
{
  "synchronizer": "<string>",
  "onboardingTransactions": [
    {
      "transaction": "<string>",
      "signatures": [
        {
          "format": "<string>",
          "signature": "<string>",
          "signedBy": "<string>",
          "signingAlgorithmSpec": "<string>"
        }
      ]
    }
  ],
  "multiHashSignatures": [
    {
      "format": "<string>",
      "signature": "<string>",
      "signedBy": "<string>",
      "signingAlgorithmSpec": "<string>"
    }
  ],
  "identityProviderId": "<string>",
  "waitForAllocation": false,
  "userId": "<string>"
}
"""))
    .build();
var response = HttpClient.newHttpClient().send(
    request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

require 'net/http'
require 'uri'

uri = URI('http://localhost:7575/v2/parties/external/allocate')
request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer <token>'
request['Content-Type'] = 'application/json'
request.body = <<~JSON
{
  "synchronizer": "<string>",
  "onboardingTransactions": [
    {
      "transaction": "<string>",
      "signatures": [
        {
          "format": "<string>",
          "signature": "<string>",
          "signedBy": "<string>",
          "signingAlgorithmSpec": "<string>"
        }
      ]
    }
  ],
  "multiHashSignatures": [
    {
      "format": "<string>",
      "signature": "<string>",
      "signedBy": "<string>",
      "signingAlgorithmSpec": "<string>"
    }
  ],
  "identityProviderId": "<string>",
  "waitForAllocation": false,
  "userId": "<string>"
}
JSON
response = Net::HTTP.start(uri.hostname, uri.port) do |http|
  http.request(request)
end
puts response.body

{
  "partyId": "<string>"
}

<string>

{
  "code": "<string>",
  "cause": "<string>",
  "correlationId": "<string>",
  "traceId": "<string>",
  "context": {},
  "resources": [
    [
      "<string>"
    ]
  ],
  "errorCategory": 123,
  "grpcCodeValue": 123,
  "retryInfo": "<string>",
  "definiteAnswer": false
}

OpenAPIUpdated 3.5 Added 3.4

curl --request POST \
  --url 'http://localhost:7575/v2/parties/external/allocate' \
  --header 'Authorization: Bearer $TOKEN' \
  --header 'Content-Type: application/json' \
  --data '{
  "synchronizer": "<string>",
  "onboardingTransactions": [
    {
      "transaction": "<string>",
      "signatures": [
        {
          "format": "<string>",
          "signature": "<string>",
          "signedBy": "<string>",
          "signingAlgorithmSpec": "<string>"
        }
      ]
    }
  ],
  "multiHashSignatures": [
    {
      "format": "<string>",
      "signature": "<string>",
      "signedBy": "<string>",
      "signingAlgorithmSpec": "<string>"
    }
  ],
  "identityProviderId": "<string>",
  "waitForAllocation": false,
  "userId": "<string>"
}'

import json
import requests

url = "http://localhost:7575/v2/parties/external/allocate"
headers = {'Authorization': 'Bearer <token>', 'Content-Type': 'application/json'}
payload = json.loads(r'''{
  "synchronizer": "<string>",
  "onboardingTransactions": [
    {
      "transaction": "<string>",
      "signatures": [
        {
          "format": "<string>",
          "signature": "<string>",
          "signedBy": "<string>",
          "signingAlgorithmSpec": "<string>"
        }
      ]
    }
  ],
  "multiHashSignatures": [
    {
      "format": "<string>",
      "signature": "<string>",
      "signedBy": "<string>",
      "signingAlgorithmSpec": "<string>"
    }
  ],
  "identityProviderId": "<string>",
  "waitForAllocation": false,
  "userId": "<string>"
}''')
response = requests.request(
    "POST", url, headers=headers, json=payload
)

print(response.text)

const response = await fetch('http://localhost:7575/v2/parties/external/allocate', {
  method: 'POST',
  headers: {
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
},
  body: JSON.stringify({
  "synchronizer": "<string>",
  "onboardingTransactions": [
    {
      "transaction": "<string>",
      "signatures": [
        {
          "format": "<string>",
          "signature": "<string>",
          "signedBy": "<string>",
          "signingAlgorithmSpec": "<string>"
        }
      ]
    }
  ],
  "multiHashSignatures": [
    {
      "format": "<string>",
      "signature": "<string>",
      "signedBy": "<string>",
      "signingAlgorithmSpec": "<string>"
    }
  ],
  "identityProviderId": "<string>",
  "waitForAllocation": false,
  "userId": "<string>"
}),
});

console.log(await response.text());

<?php
$curl = curl_init();

curl_setopt_array($curl, [
    CURLOPT_URL => 'http://localhost:7575/v2/parties/external/allocate',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_POSTFIELDS => <<<'JSON'
{
  "synchronizer": "<string>",
  "onboardingTransactions": [
    {
      "transaction": "<string>",
      "signatures": [
        {
          "format": "<string>",
          "signature": "<string>",
          "signedBy": "<string>",
          "signingAlgorithmSpec": "<string>"
        }
      ]
    }
  ],
  "multiHashSignatures": [
    {
      "format": "<string>",
      "signature": "<string>",
      "signedBy": "<string>",
      "signingAlgorithmSpec": "<string>"
    }
  ],
  "identityProviderId": "<string>",
  "waitForAllocation": false,
  "userId": "<string>"
}
JSON,
    CURLOPT_HTTPHEADER => [
        "Authorization: Bearer <token>",
        "Content-Type: application/json"
    ],
]);

$response = curl_exec($curl);
echo $response;

package main

import (
  "bytes"
  "fmt"
  "io"
  "net/http"
)

func main() {
  req, _ := http.NewRequest("POST", "http://localhost:7575/v2/parties/external/allocate", bytes.NewBufferString(`{
  "synchronizer": "<string>",
  "onboardingTransactions": [
    {
      "transaction": "<string>",
      "signatures": [
        {
          "format": "<string>",
          "signature": "<string>",
          "signedBy": "<string>",
          "signingAlgorithmSpec": "<string>"
        }
      ]
    }
  ],
  "multiHashSignatures": [
    {
      "format": "<string>",
      "signature": "<string>",
      "signedBy": "<string>",
      "signingAlgorithmSpec": "<string>"
    }
  ],
  "identityProviderId": "<string>",
  "waitForAllocation": false,
  "userId": "<string>"
}`))
  req.Header.Set("Authorization", "Bearer <token>")
  req.Header.Set("Content-Type", "application/json")
  response, _ := http.DefaultClient.Do(req)
  defer response.Body.Close()
  body, _ := io.ReadAll(response.Body)
  fmt.Println(string(body))
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

var request = HttpRequest.newBuilder()
    .uri(URI.create("http://localhost:7575/v2/parties/external/allocate"))
    .header("Authorization", "Bearer <token>")
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("""
{
  "synchronizer": "<string>",
  "onboardingTransactions": [
    {
      "transaction": "<string>",
      "signatures": [
        {
          "format": "<string>",
          "signature": "<string>",
          "signedBy": "<string>",
          "signingAlgorithmSpec": "<string>"
        }
      ]
    }
  ],
  "multiHashSignatures": [
    {
      "format": "<string>",
      "signature": "<string>",
      "signedBy": "<string>",
      "signingAlgorithmSpec": "<string>"
    }
  ],
  "identityProviderId": "<string>",
  "waitForAllocation": false,
  "userId": "<string>"
}
"""))
    .build();
var response = HttpClient.newHttpClient().send(
    request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

require 'net/http'
require 'uri'

uri = URI('http://localhost:7575/v2/parties/external/allocate')
request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer <token>'
request['Content-Type'] = 'application/json'
request.body = <<~JSON
{
  "synchronizer": "<string>",
  "onboardingTransactions": [
    {
      "transaction": "<string>",
      "signatures": [
        {
          "format": "<string>",
          "signature": "<string>",
          "signedBy": "<string>",
          "signingAlgorithmSpec": "<string>"
        }
      ]
    }
  ],
  "multiHashSignatures": [
    {
      "format": "<string>",
      "signature": "<string>",
      "signedBy": "<string>",
      "signingAlgorithmSpec": "<string>"
    }
  ],
  "identityProviderId": "<string>",
  "waitForAllocation": false,
  "userId": "<string>"
}
JSON
response = Net::HTTP.start(uri.hostname, uri.port) do |http|
  http.request(request)
end
puts response.body

{
  "partyId": "<string>"
}

<string>

{
  "code": "<string>",
  "cause": "<string>",
  "correlationId": "<string>",
  "traceId": "<string>",
  "context": {},
  "resources": [
    [
      "<string>"
    ]
  ],
  "errorCategory": 123,
  "grpcCodeValue": 123,
  "retryInfo": "<string>",
  "definiteAnswer": false
}

Authorizations

httpAuth

string

required

HTTP bearer authentication. Send the token as Authorization: Bearer <token>. Ledger API standard JWT token

apiKeyAuth

string

required

API key authentication in the header. Ledger API standard JWT token (websocket)

Body

application/json

string

required

Synchronizer ID on which to onboard the party Required

object[]

required

OpenAPI type: SignedTransaction[].TopologyTransactions to onboard the external party Can contain: - A namespace for the party. This can be either a single NamespaceDelegation, or DecentralizedNamespaceDefinition along with its authorized namespace owners in the form of NamespaceDelegations. May be provided, if so it must be fully authorized by the signatures in this request combined with the existing topology state. - A PartyToParticipant to register the hosting relationship of the party, and the party’s signing keys and threshold. Must be provided. Required: must be non-empty

Show child attributes

string

required

The serialized TopologyTransaction Required: must be non-empty

object[]

OpenAPI type: Signature[].Additional signatures for this transaction specifically Use for transactions that require additional signatures beyond the namespace key signatures e.g: PartyToParticipant must be signed by all registered keys Optional: can be empty

Show child attributes

string

required

Required

string

required

Required: must be non-empty

string

required

The fingerprint/id of the keypair used to create this signature and needed to verify. Required

string

required

The signing algorithm specification used to produce this signature Required

object[]

OpenAPI type: Signature[].Optional signatures of the combined hash of all onboarding_transactions This may be used instead of providing signatures on each individual transaction Optional: can be empty

Show child attributes

string

required

Required

string

required

Required: must be non-empty

string

required

The fingerprint/id of the keypair used to create this signature and needed to verify. Required

string

required

The signing algorithm specification used to produce this signature Required

string

The id of the Identity Provider If not set, assume the party is managed by the default identity provider. Optional

boolean

When true, this RPC will attempt to wait for the party to be allocated on the synchronizer before returning. When false, the allocation will happen asynchronously. This is a best effort only as this synchronization is only possible for non decentralized parties (single hosting node). For decentralized parties, this flag is ignored. Defaults to true. Optional

string

The user who will get the act_as rights to the newly allocated party. If set to an empty string (the default), no user will get rights to the party. Optional

Responses

200

application/json

string

required

The allocated party id Required

400

Invalid value, Invalid value for: body

text/plain

string

required

default

application/json

string

required

string

required

string

Map_String

required

Tuple2_String_String[]

integer (int32)

required

integer (int32)

string

boolean

History

Updated3.5

The POST /v2/parties/external/allocate operation was updated in this snapshot.

Added3.4

Ledger API

Daml Standard Library

Daml Script

TypeScript

dApp API

Wallet Gateway

Splice APIs

Admin API

POST /v2/parties/external/allocate

Authorizations

httpAuth

apiKeyAuth

Body

Responses

200

400

default

History

​Authorizations

​httpAuth

​apiKeyAuth

​Body

​Responses

​200

​400

​default

​History

Authorizations

httpAuth

apiKeyAuth

Body

Responses

200

400

default

History