# Get a node contract

> operationId: `getNodeType`


## Request

Gets a node contract. nodeType is a type, not a nodeId inside a template. Inputs are first completed with NodeContract.defaults for missing fields, then overridden by bindings with references resolved, and finally checked against the conditional branch rules. x-editor-default is only an initial UI value. For offline design, see the [58 static node contracts](/browser-rpa/nodes). If they differ from the live instance, refresh the contracts first, and don't mix catalog revisions. outputVariants determines which outputs can be referenced. fieldPolicies constrains both inputs and bindings. The example comes from an instance that supports this node. Actual availability depends on what the current instance returns. When documentationComplete=false, don't guess the missing rules.

- **Prerequisites**: nodeType comes from the node type list, for example browser_waitTime.
- **Authentication**: Same as the rest of the Local API; see [Authentication](/api-reference/getting-started/authentication). Resources belong to the current account/team data scope.
- **Side effects**: None. This call doesn't write business data.
- **Completion signal**: 200 returns the node's inputs, outputs, references, conditions, and field policies.
- **Retries**: Read-only calls can be retried. On 429 or 503, back off as indicated by Retry-After.


### Endpoint

```http
GET /api/rpa/browser/v1/node-types/{nodeType}
```

Local API: `http://127.0.0.1:<port>/api/rpa/browser/v1/node-types/{nodeType}`. Use the port configured in the client.

### Headers

| Parameter | Type | Required | Description and constraints |
|  --- | --- | --- | --- |
| `Authorization` | string | When Local API authentication is enabled | See [Authentication](/api-reference/getting-started/authentication). |


### Path parameters

| Parameter | Type | Required | Description and constraints |
|  --- | --- | --- | --- |
| `nodeType` | string | Yes | Actual type ID, for example browser_waitTime. It isn't a node instance ID. Min length 1; max length 128 |


### Query parameters

None.

### Request body

No request body.

### Request example

This is a documentation example; it was not sent to a live client. Set `RPA_BASE_URL` as described in [API conventions](/browser-rpa/api/common). Resource variables, the catalog revision, and ETags come from actual responses.

```bash
curl -i -X GET "${RPA_BASE_URL}/node-types/${RPA_NODE_TYPE}"
```

## Response

### 200

200 returns the node's inputs, outputs, references, conditions, and field policies.

Body: `application/json`. The top-level `data` uses the model below. For `meta`, see [Metadata](/browser-rpa/api/data-types#metadata).

| Field | Type | Required | Description and constraints |
|  --- | --- | --- | --- |
| `id` | string | Yes | Unique ID of the resource or node. Take it from a previous response; don't guess it. Min length 1; max length 128. |
| `action` | string or null | Yes | Executor action name. It is null for structure nodes. |
| `nodeVersion` | integer | Yes | Contract version of this node type. It isn't a lock on a single node in a template. Minimum 1. |
| `category` | string | Yes | Node category. Filter by the actual catalog values. |
| `title` | string | Yes | Display name of the node type. |
| `description` | string | Yes | Description of the node's behavior and semantic rules. |
| `authorable` | boolean | Yes | Whether this type can be used in public authoring. Its fields are still subject to fieldPolicies. |
| `runtimeSupported` | boolean | Yes | Whether the internal executor supports it. |
| `externalRunnable` | boolean | Yes | Whether the current instance can run this node through the Local API. It is true once the action is registered. A run validation is still required. |
| `documentationComplete` | boolean | Yes | Whether the complete executable rules have been published. |
| `unavailableReasons` | array<string> | Yes | List of reasons the node is unavailable. An empty array means there is no known reason. |
| `inputSchema` | [JsonObject](/browser-rpa/api/data-types#jsonobject) | Yes | JSON Schema of the action inputs. For structure types, it validates the complete node. |
| `outputVariants` | array<object> | Yes | Output schema branches, selected by mode. |
| `referenceRules` | array<object> | Yes | Allowed value forms and reference scope for each field. |
| `conditionalRules` | array<object> | Yes | Conditional rules checked after defaults and bindings take effect. |
| `fieldPolicies` | array<object> | Yes | Per-field sensitivity and authoring restrictions. They also apply to bindings. |
| `defaults` | [JsonObject](/browser-rpa/api/data-types#jsonobject) | Yes | Normalized safe execution defaults, merged into omitted fields. x-editor-default isn't used during execution. |
| `examples` | array<object> | Yes | Array of samples with inputs and illustrative outputs for this node. |
| `sideEffects` | array<`browser` / `read` / `write` / `file` / `script` / `credential` / `environment`> | Yes | Categories of side effects that running the node can cause. |
| `docUrl` | string | Yes | URL of the detailed documentation for this node. |


**`outputVariants[]` fields**

| Field | Type | Required | Description and constraints |
|  --- | --- | --- | --- |
| `outputVariants[].when` | [ConditionRule](/browser-rpa/api/data-types#conditionrule) | Yes | Declarative condition. Only the operations in ConditionRule are supported. |
| `outputVariants[].schema` | [JsonObject](/browser-rpa/api/data-types#jsonobject) | Yes | JSON Schema of node.data under this condition. It isn't a documentation URL. |
| `outputVariants[].publicProjection` | string | Yes | Describes how data in run records differs from the executor output (no redaction; only handles can't be serialized). |


**`referenceRules[]` fields**

| Field | Type | Required | Description and constraints |
|  --- | --- | --- | --- |
| `referenceRules[].field` | string | Yes | The corresponding node input field or rule field. |
| `referenceRules[].allow` | array<`literal` / `reference` / `template` / `numericExpression`> | Yes | Which of the literal/reference/template/numericExpression forms are allowed. |
| `referenceRules[].expectedType` | string | Yes | Target type after the reference is resolved. |
| `referenceRules[].scope` | string | Yes | Scope in which references are visible. |


**`conditionalRules[]` fields**

| Field | Type | Required | Description and constraints |
|  --- | --- | --- | --- |
| `conditionalRules[].when` | [ConditionRule](/browser-rpa/api/data-types#conditionrule) | Yes | Declarative condition. Only the operations in ConditionRule are supported. |
| `conditionalRules[].requiredFields` | array<string> | Yes | Fields that are required under this condition. |
| `conditionalRules[].forbiddenFields` | array<string> | Yes | Fields that are forbidden under this condition. |
| `conditionalRules[].constraints` | array<string> | Yes | Constraint descriptions. Before publication, each one must map to an executable validation rule. |
| `conditionalRules[].issueCode` | string | Yes | Issue code returned when the condition is violated. |


**`fieldPolicies[]` fields**

| Field | Type | Required | Description and constraints |
|  --- | --- | --- | --- |
| `fieldPolicies[].field` | string | Yes | The corresponding node input field or rule field. |
| `fieldPolicies[].sensitivity` | `public` / `secret` / `credential` / `localPath` / `inlineFile` / `sourceCode` | Yes | Data sensitivity category of the field. |
| `fieldPolicies[].authoringPolicy` | `allowed` / `privateReferenceOnly` / `restricted` | Yes | Always `allowed` in the current version: the field accepts a literal or a reference. The other two values are kept only for compatibility with earlier versions. |
| `fieldPolicies[].when` | [ConditionRule](/browser-rpa/api/data-types#conditionrule) | Yes | Declarative condition. Only the operations in ConditionRule are supported. |


**`examples[]` fields**

| Field | Type | Required | Description and constraints |
|  --- | --- | --- | --- |
| `examples[].id` | string | Yes | Unique ID of the resource or node. Take it from a previous response; don't guess it. Min length 1; max length 128. |
| `examples[].input` | [JsonObject](/browser-rpa/api/data-types#jsonobject) | Yes | Sample input. |
| `examples[].expectedOutput` | [JsonValue](/browser-rpa/api/data-types#jsonvalue) | Yes | Illustrative output value. The actual value comes from a run. |
| `examples[].requirements` | array<string> | Yes | Prerequisites for the sample. |


### Response example

All IDs, timestamps, hashes, and run results are sample data. They don't indicate that the sample was executed.

```json
{
  "data": {
    "id": "browser_waitTime",
    "action": "waitTime",
    "nodeVersion": 1,
    "category": "browser",
    "title": "Wait",
    "description": "**Branch rules:** For fixed, timeout defaults to 1000 ms. For randomInterval, the default is [1000,3000] ms, with timeoutMin ≤ timeoutMax.",
    "authorable": true,
    "runtimeSupported": true,
    "externalRunnable": true,
    "documentationComplete": true,
    "unavailableReasons": [],
    "inputSchema": {
      "$ref": "/api/rpa/browser/v1/docs/api/workflow.schema.json#/$defs/waitTimeInputs"
    },
    "outputVariants": [
      {
        "when": {
          "op": "always"
        },
        "schema": {
          "type": "object",
          "properties": {
            "waitedMs": {
              "type": "number"
            },
            "requestedMs": {
              "type": "number"
            }
          },
          "required": [
            "waitedMs",
            "requestedMs"
          ],
          "additionalProperties": false,
          "$schema": "https://json-schema.org/draft/2020-12/schema"
        },
        "publicProjection": "The data of a successful node. Reference it with ${nodeId.data.<field>}. Run records store the actual values as is (including credentials, cookies, values derived from private parameters, and local paths), without redaction. Only element and frame handles appear as {kind,available:false}."
      }
    ],
    "referenceRules": [
      {
        "field": "timeoutType",
        "allow": [
          "literal",
          "reference",
          "template"
        ],
        "expectedType": "See the matching field in inputSchema (it must still match after the reference is resolved)",
        "scope": "Initial variables of the same workflow, currently visible previous nodes, custom variables, and published system fields. No references to future nodes or sibling branches."
      },
      {
        "field": "timeout",
        "allow": [
          "literal",
          "numericExpression"
        ],
        "expectedType": "number",
        "scope": "Initial variables of the same workflow, currently visible previous nodes, custom variables, and published system fields. No references to future nodes or sibling branches."
      },
      {
        "field": "timeoutMin",
        "allow": [
          "literal",
          "numericExpression"
        ],
        "expectedType": "number",
        "scope": "Initial variables of the same workflow, currently visible previous nodes, custom variables, and published system fields. No references to future nodes or sibling branches."
      },
      {
        "field": "timeoutMax",
        "allow": [
          "literal",
          "numericExpression"
        ],
        "expectedType": "number",
        "scope": "Initial variables of the same workflow, currently visible previous nodes, custom variables, and published system fields. No references to future nodes or sibling branches."
      }
    ],
    "conditionalRules": [
      {
        "when": {
          "op": "eq",
          "field": "timeoutType",
          "value": "fixed"
        },
        "requiredFields": [],
        "forbiddenFields": [],
        "constraints": [
          "After resolution, timeout is a finite number from 0 to 2147483647, in milliseconds."
        ],
        "issueCode": "RPA_NODE_INPUT_INVALID"
      },
      {
        "when": {
          "op": "eq",
          "field": "timeoutType",
          "value": "randomInterval"
        },
        "requiredFields": [],
        "forbiddenFields": [],
        "constraints": [
          "timeoutMin/timeoutMax are numbers from 0 to 2147483647 and can be decimals. timeoutMin <= timeoutMax. The wait is timeoutMin + floor(random × (timeoutMax − timeoutMin + 1)). When both ends are integers, the result is a uniformly random integer in the closed interval. With decimals, the step is 1, and the result can exceed timeoutMax by less than 1 millisecond."
        ],
        "issueCode": "RPA_NODE_INPUT_INVALID"
      },
      {
        "when": {
          "op": "always"
        },
        "requiredFields": [],
        "forbiddenFields": [],
        "constraints": [
          "**Branch rules:** For fixed, timeout defaults to 1000 ms. For randomInterval, the default is [1000,3000] ms, with timeoutMin ≤ timeoutMax."
        ],
        "issueCode": "RPA_NODE_INPUT_INVALID"
      }
    ],
    "fieldPolicies": [
      {
        "field": "timeoutType",
        "sensitivity": "public",
        "authoringPolicy": "allowed",
        "when": {
          "op": "always"
        }
      },
      {
        "field": "timeout",
        "sensitivity": "public",
        "authoringPolicy": "allowed",
        "when": {
          "op": "always"
        }
      },
      {
        "field": "timeoutMin",
        "sensitivity": "public",
        "authoringPolicy": "allowed",
        "when": {
          "op": "always"
        }
      },
      {
        "field": "timeoutMax",
        "sensitivity": "public",
        "authoringPolicy": "allowed",
        "when": {
          "op": "always"
        }
      }
    ],
    "defaults": {
      "timeoutType": "fixed",
      "timeout": 1000,
      "timeoutMin": 1000,
      "timeoutMax": 3000
    },
    "examples": [
      {
        "id": "fixed",
        "input": {
          "timeoutType": "fixed",
          "timeout": 1200
        },
        "expectedOutput": {
          "requestedMs": 1200,
          "waitedMs": 1202
        },
        "requirements": [
          "waitedMs is the measured time. Don't assume that it exactly equals requestedMs."
        ]
      }
    ],
    "sideEffects": [
      "browser"
    ],
    "docUrl": "/api/rpa/browser/v1/docs/api/nodes/browser_waitTime.md"
  },
  "meta": {
    "requestId": "7d498f20-7bab-4e59-9b05-88daf51230e9",
    "catalogRevision": "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
  }
}
```

### Error responses

For common 400/401/403/404/429/5xx errors and failure fields, see [Errors and recovery](/browser-rpa/api/common#errors-and-recovery). Error response example (403):

```json
{
  "error": {
    "code": "RPA_PERMISSION_DENIED",
    "message": "The request Host or Origin is not allowed, or the current identity can't access the target environment",
    "retryable": false,
    "issues": [],
    "details": null
  },
  "meta": {
    "requestId": "7d498f20-7bab-4e59-9b05-88daf51230e9",
    "catalogRevision": "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
  }
}
```

## Related

[Local API reference](/browser-rpa/local-api) · [API conventions](/browser-rpa/api/common) · [Data models](/browser-rpa/api/data-types) · [Workflow structure](/browser-rpa/api/workflow) · [Quickstart](/browser-rpa/quickstart)