Variables & Tokens Reference

A Pactly template is a Word document marked up with tokens. When someone generates a contract, Pactly reads each token, looks up its value, and writes the result into the document. This page is the reference for that markup language, PCTL (Pactly Contract Templating Language): every token type, what it resolves to, and the rules that decide where each one can go.

You write these tokens while authoring a template in the Pactly Word add-in. The people who later generate contracts never see them. If you are building or fixing a template, keep this page open.

Every token type at a glance. The sections below add the detail each one needs.

A variable is the most common token. It substitutes a single value, usually one a requester typed or selected on the intake form.

The total contract value is {{ContractValue}}.

A variable draws its value from the contract property it is mapped to. Three formatting options are set on the variable definition, not in the token:

• Uppercase renders the value in capitals.
• Currency prepends the contract’s currency symbol.
• Number format controls how numbers print: a plain number (1234.56), thousands with separators (1,234,567.89), or spelled-out as a string (one thousand two hundred thirty-four).

A value map turns a dropdown choice into document text. The choice the requester picks has a hidden label and a visible replacement value; the token prints the replacement.

This is a {{vm AgreementType}} agreement.

If a value map allows multiple selections, address a specific one by index with #N:

Primary service: {{vm Services #1}}
Secondary service: {{vm Services #2}}

Value maps are also what let one template serve several variants. A single template can render an NDA, a service agreement, or a license from the same document, with the value map and a few rules deciding the wording, rather than three near-identical templates.

A global is a system value, the same for every contract, so it has no property to map.

Globals are commonly paired with a variable, for example {{@currency}}{{ContractValue}} to print a symbol and amount together.

A computed value runs a small math expression over other values and prints the result. You define the expression (such as BaseAmount + TaxAmount) on the template, then reference it by name.

Total payable: {{#TotalCost}}

Supported operators are +, -, *, /, ||, and &&. Computed values are an advanced feature; most templates never need them.

A conditional shows or hides content based on a true/false value. Add ! before the name to invert it.

{{if hasRenewal}}
This agreement renews automatically at the end of each term.
{{/if}}

{{if !isExempt}}
Standard compliance requirements apply.
{{/if}}

Conditionals can test a party attribute too, which is how a template branches between an organization and an individual:

{{if party1.isEntity}}
Executed by an authorized representative of {{party1.entityName}}.
{{/if}}
{{if !party1.isEntity}}
Executed by {{party1.firstName}} {{party1.lastName}}.
{{/if}}

A rule is a named condition you define on the template, then reference to switch a clause on or off. Use a rule when the condition has a meaning worth naming (Sanctioned, Preferred, HighValue) or combines several inputs.

{{rule Sanctioned}}
This party is subject to additional sanctions-compliance requirements.
{{/rule}}

Prefix the name with ! to show the clause when the rule is false:

{{rule !Exempt}}
Standard terms apply to this agreement.
{{/rule}}

When a clause depends on more than one condition, write the boolean expression inline with {{rules ...}}. Combine flags with && (and), || (or), ! (not), and parentheses.

{{rules isCommercial && hasApproval}}
This commercial agreement has received the necessary approvals.
{{/rules}}

{{rules (Sanctioned || SensitiveEntity) && isCommercial}}
Enhanced due diligence requirements apply.
{{/rules}}

PCTL cannot nest one conditional inside another. To cover every combination of two flags, write four separate {{rules}} blocks instead of nesting:

{{rules A && B}}Text when both A and B are true{{/rules}}
{{rules A && !B}}Text when A is true but B is false{{/rules}}
{{rules !A && B}}Text when B is true but A is false{{/rules}}
{{rules !A && !B}}Text when neither is true{{/rules}}

This flattening pattern replaces nesting everywhere. It is verbose but reliable. For a fuller walk through rules, complex expressions, and party-type branching, see Conditional Logic and Rules.

A party field prints an attribute of a party on the contract. The number addresses which party (party1, party2); the attribute follows the dot.

{{party1.entityName}}
{{party1.firstName}} {{party1.lastName}}
{{party1.email}}

Common built-in attributes:

Custom party attributes are addressed by their key in the flat form, one level deep, for example {{party1.department}}. The nested {{party1.customAttributes.department}} form does not resolve in generated documents.

Auto fields use a different wrapper, {%...%}, and are filled automatically when the document is generated, with no property to map.

When a token has no value to resolve, Pactly does not fail the generation and does not leave the raw token in place. It writes a bullet-in-circle placeholder, a black dot in a circle, where the value would have gone.

That marker is your signal that something upstream is wrong. The usual causes:

• The token name is misspelled, so it matches no variable ({{ContractVlaue}}).
• The variable is not mapped to a contract property.
• The form field that feeds the property was left blank.
• A custom party attribute did not resolve (see Party fields above).

There is no validation before generation. A typo in a token or a broken rule name stays invisible until you generate a document and see the marker. When reviewing a new template, always generate a test contract and scan the output for these dots.

PCTL distinguishes between tokens that wrap whole paragraphs (block) and tokens that sit inside a line of text (inline). Getting this wrong is the most common reason a clause silently fails to appear.

A block token must occupy its own paragraph. The opening tag, the content, and the closing tag each sit on their own lines. Block mode is what lets a condition remove an entire section.

{{if hasRenewal}}
RENEWAL. This agreement renews automatically...
...further renewal terms...
{{/if}}

An inline token sits within a sentence and cannot span multiple lines.

The status is {{if isActive}}active{{/if}}.

This table shows where each token type is allowed:

A handful of constraints catch almost every template author:

• No nesting. You cannot put {{if}} inside another {{if}}. Use a combined {{rules A && B}} instead.
• A variable inside an inline rule does not work. If a {{rule}} block contains a variable, the rule must be in block mode (its own paragraphs), not inline.
• A value map inside an inline rule does not work. Put the {{vm ...}} on its own paragraph inside a block rule.
• No line breaks inside an inline token. An inline token must stay on one line.
• Template edits affect new contracts only. Changing a template does not update contracts already generated from it; regenerate them to apply the change.

• Templates Overview
• Create a Template: where these tokens are written and configured
• Conditional Logic and Rules: the deeper guide to rules and party-type branching
• Mappings: Forms, Properties, and Template Tokens: how form answers reach a token
• Field Mappings and Naming: connecting form fields to contract properties