Mankomail

MyNotary ​

Reads and feeds MyNotary cases, records, contracts and documents. No signature can be started through the API: it stays a human action.

The MyNotary node reads and feeds the cases, records, contracts and documents of a notary office or a real-estate agency in MyNotary. Typical uses: create the record of a new client from an email, drop the documents they sent into the case drive, follow who has not signed yet, and fetch the signed deed to send it by email.

No signature can be started through the MyNotary API: sending a contract for signature stays a human action in MyNotary. The workflow prepares (case, records, contract, documents), a person sends for signature, and the MyNotary — event trigger reacts when the signature is complete.

It works with a MyNotary API key stored once in Connections; the connection also sets the environment (pre-production or production). See MyNotary to create it. Most operations first ask for the Firm (organization): one key can see several firms, and the API refuses any request without one.

At a glance ​

  • Type: mynotary.api · version 1
  • Category: Data
  • Kind: Step — one stage of a run
  • Effect: Writes outside (external_write) — writes outside Mankomail; described instead of performed during a test run
  • Needs a carrier email: No
  • Connection: MyNotary
  • Inputs: main
  • Outputs: main

Connection ​

This node needs a MyNotary connection.

Parameters ​

connection ​

MyNotary connection — The MyNotary connection to use. Create it once in Connections; its key never appears in the workflow.

  • Type: Connection (credential)
  • Required: Yes
  • Default: "" (empty)

resource ​

Resource

  • Type: One choice (options)
  • Required: Yes
  • Default: operation
  • Options:
    • operation — Case: The whole transaction. Every contract of one deal lives in it.
    • contract — Contract: Mandate, offer, sale agreement, lease — and how far its signature got.
    • record — Record: A person, a company, a property, a lot — reusable across cases.
    • file — Document: A case drive: drop an email attachment in it, list it, or get a file back.
    • user — User: The firm’s members. Every creation requires one.
    • webhook — Webhook: The event subscription, managed through the API — no third-party screen to open.

operationOp ​

Operation

  • Type: One choice (options)
  • Required: Yes
  • Default: list
  • Options:
    • list — List cases
    • get — Get a case
    • create — Create a case: MyNotary offers no idempotency: search before creating, or a retry makes a duplicate.
    • addRecords — Add a party to the case: Attaches records to a case role (seller, buyer, sold property…).
  • Shown when: resource is operation

contractOp ​

Operation

  • Type: One choice (options)
  • Required: Yes
  • Default: list
  • Options:
    • list — List the contracts of a case
    • get — Get a contract
    • create — Create a contract from a model
    • signature — Track the signature: Who signed, who has not signed yet, and the signed documents.
  • Shown when: resource is contract

recordOp ​

Operation

  • Type: One choice (options)
  • Required: Yes
  • Default: search
  • Options:
    • search — Search records: The guard against duplicates: search before you create.
    • get — Get a record
    • create — Create a record
    • update — Update a record
  • Shown when: resource is record

fileOp ​

Operation

  • Type: One choice (options)
  • Required: Yes
  • Default: list
  • Options:
    • list — List a case drive
    • link — Get a download link: Valid for seven days, with no authentication: treat it as a secret.
    • download — Fetch a file as an attachment: Fetches the file (a signed deed, a drive document) into the run’s attachments: a “Compose an email” can then attach it by its position.
    • upload — Drop an attachment into the drive
  • Shown when: resource is file

webhookOp ​

Operation

  • Type: One choice (options)
  • Required: Yes
  • Default: list
  • Options:
    • list — List webhooks
    • create — Create a webhook
    • delete — Delete a webhook
  • Shown when: resource is webhook

organization ​

Firm — The MyNotary firm to work in. One application key sees several, and the API refuses any request without it.

  • Type: Remote resource (resourceLocator)
  • Required: Yes
  • Ways to choose: pick from a list, type an ID (mynotary.organization)
  • Listed with the connection in: connection
  • Shown when: resource is one of operation, contract, record, file, user

operationRef ​

Case

  • Type: Remote resource (resourceLocator)
  • Required: Yes
  • Ways to choose: pick from a list, type an ID, paste a URL (mynotary.operation)
  • Listed inside: organization
  • Listed with the connection in: connection
  • Shown when: ((resource is operation and operationOp is one of get, addRecords) or (resource is contract and contractOp is one of list, create) or (resource is file and fileOp is one of list, upload))

operationType ​

Case type — Resale, residential lease, off-plan sale… The firm’s custom types show up too.

  • Type: Remote resource (resourceLocator)
  • Required: No
  • Ways to choose: pick from a list, type an ID (mynotary.operationType)
  • Listed inside: organization
  • Listed with the connection in: connection
  • Shown when: ((resource is operation and operationOp is one of list, create) or (resource is contract and contractOp is one of create))

contractModel ​

Contract model

  • Type: Remote resource (resourceLocator)
  • Required: Yes
  • Ways to choose: pick from a list, type an ID (mynotary.contractModel)
  • Listed inside: operationType
  • Listed with the connection in: connection
  • Shown when: resource is contract and contractOp is one of create

creator ​

On behalf of — The member who creates. MyNotary has no service account: a deed is always created by someone.

  • Type: Remote resource (resourceLocator)
  • Required: Yes
  • Ways to choose: pick from a list, type an ID (mynotary.user)
  • Listed inside: organization
  • Listed with the connection in: connection
  • Shown when: ((resource is operation and operationOp is one of create) or (resource is contract and contractOp is one of create) or (resource is record and recordOp is one of create))

recordType ​

Record type

  • Type: Remote resource (resourceLocator)
  • Required: No
  • Ways to choose: pick from a list, type an ID (mynotary.recordType)
  • Listed with the connection in: connection
  • Shown when: resource is record and recordOp is one of search, create

contractId ​

Contract — The contract id, as a webhook or the contract list returns it.

  • Type: Text (string)
  • Required: Yes
  • Default: "" (empty)
  • 64 characters at most
  • Example: {{ data.mynotary.contractId }}
  • Shown when: resource is contract and contractOp is one of get, signature
  • Expressions: {{ }} accepted

recordId ​

Record

  • Type: Text (string)
  • Required: Yes
  • Default: "" (empty)
  • 64 characters at most
  • Shown when: resource is record and recordOp is one of get, update
  • Expressions: {{ }} accepted

fileId ​

File — The file id (signedFileId of a signature, fileId of the drive).

  • Type: Text (string)
  • Required: Yes
  • Default: "" (empty)
  • 128 characters at most
  • Shown when: resource is file and fileOp is one of link, download
  • Expressions: {{ }} accepted

downloadName ​

File name — Optional: the name the attachment will carry. Empty: the one MyNotary gives.

  • Type: Text (string)
  • Required: No
  • Default: "" (empty)
  • 255 characters at most
  • Shown when: resource is file and fileOp is one of download
  • Expressions: {{ }} accepted

maxDownloadMb ​

Maximum size (MB)

  • Type: Number (number)
  • Required: No
  • Default: 10
  • Whole number, from 1 to 10
  • Shown when: resource is file and fileOp is one of download

webhookId ​

Webhook

  • Type: Text (string)
  • Required: Yes
  • Default: "" (empty)
  • 64 characters at most
  • Shown when: resource is webhook and webhookOp is one of delete
  • Expressions: {{ }} accepted

label ​

Label — The name the firm will find the case or contract under. Accepts {{ }} expressions.

  • Type: Text (string)
  • Required: No
  • Default: "" (empty)
  • 200 characters at most
  • Example: 12 Lilac Street — Dupont
  • Shown when: ((resource is operation and operationOp is one of create) or (resource is contract and contractOp is one of create))
  • Expressions: {{ }} accepted

branch ​

Role — The role of the records inside the case, as MyNotary names it: VENDEUR, ACQUEREUR, BIEN_VENDU, OFFRANT… The list depends on the case type and is not enumerated by the API.

  • Type: Text (string)
  • Required: Yes
  • Default: "" (empty)
  • 64 characters at most
  • Example: VENDEUR
  • Shown when: resource is operation and operationOp is one of addRecords
  • Expressions: {{ }} accepted

recordIds ​

Records to attach — One or more record ids, separated by commas.

  • Type: Text (string)
  • Required: Yes
  • Default: "" (empty)
  • 500 characters at most
  • Shown when: resource is operation and operationOp is one of addRecords
  • Expressions: {{ }} accepted

questions ​

Fields (JSON) — The form answers, keyed by question id: {"nom":"Dupont","prenoms":"Marie"}. The ids come from GET /records/description or GET /operations/description. A date reads 2026-03-16, never with a time — MyNotary would silently ignore it.

  • Type: Long text (text)
  • Required: No
  • Default: "" (empty)
  • 20000 characters at most
  • Example: { "nom": "Dupont" }
  • Shown when: ((resource is operation and operationOp is one of create) or (resource is contract and contractOp is one of create) or (resource is record and recordOp is one of create, update))
  • Expressions: {{ }} accepted

documents ​

Documents (JSON) — The files already uploaded, keyed by document id: {"carte_identite":[{"fileId":"…"}]}. A fileId comes from an earlier upload (the “Drop an attachment” operation).

  • Type: Long text (text)
  • Required: No
  • Default: "" (empty)
  • 20000 characters at most
  • Shown when: ((resource is operation and operationOp is one of create) or (resource is contract and contractOp is one of create) or (resource is record and recordOp is one of create, update))
  • Expressions: {{ }} accepted

attachmentPosition ​

Attachment (position) — The position of the attachment to upload: one from the email (1 for the first one) or a file added by an earlier step ({{ data.<step>.attachmentPosition }}). The bytes never travel through the workflow.

  • Type: Number (number)
  • Required: No
  • Default: 1
  • Whole number, from 1 to 2000000
  • Shown when: resource is file and fileOp is one of upload

fileName ​

File name — Empty: the attachment’s own name. MyNotary checks and sanitises PDFs, and refuses what it cannot read.

  • Type: Text (string)
  • Required: No
  • Default: "" (empty)
  • 200 characters at most
  • Shown when: resource is file and fileOp is one of upload
  • Expressions: {{ }} accepted

webhookUrl ​

Callback URL — The trigger’s absolute URL, copied from the “MyNotary — event” node panel (shown once published). MyNotary will send every event of every firm there: the filtering happens on our side.

  • Type: Text (string)
  • Required: Yes
  • Default: "" (empty)
  • 500 characters at most
  • Example: https://…/hooks/wf/…
  • Shown when: resource is webhook and webhookOp is one of create
  • Expressions: {{ }} accepted

operationSearch ​

Label contains

  • Type: Text (string)
  • Required: No
  • Default: "" (empty)
  • 200 characters at most
  • Shown when: resource is operation and operationOp is one of list
  • Expressions: {{ }} accepted

Search — Case- and accent-insensitive. Every word must be found.

  • Type: Text (string)
  • Required: No
  • Default: "" (empty)
  • 200 characters at most
  • Example: dupont marie
  • Shown when: resource is record and recordOp is one of search
  • Expressions: {{ }} accepted

searchFields ​

Searched fields — Mandatory as soon as a search is typed, otherwise MyNotary answers 400. Ten ids at most: nom,prenoms,email,telephone for a person, siren,personne_morale_denomination for a company.

  • Type: Text (string)
  • Required: No
  • Default: nom,prenoms,email
  • 300 characters at most
  • Example: nom,prenoms,email
  • Shown when: resource is record and recordOp is one of search
  • Expressions: {{ }} accepted

updatedSince ​

Updated since — A 2026-09-22 date. The only incremental filter of the API: GET /operations has no equivalent.

  • Type: Text (string)
  • Required: No
  • Default: "" (empty)
  • 10 characters at most
  • Shown when: resource is record and recordOp is one of search
  • Expressions: {{ }} accepted

fetchAll ​

Fetch everything — Follows the pages up to the safety ceiling. Unchecked, only the first page is read.

  • Type: Yes / no (boolean)
  • Required: No
  • Default: false
  • Shown when: ((resource is operation and operationOp is one of list) or (resource is record and recordOp is one of search))

limit ​

Maximum count

  • Type: Number (number)
  • Required: No
  • Default: 50
  • Whole number, from 1 to 300
  • Shown when: ((resource is operation and operationOp is one of list) or (resource is record and recordOp is one of search))

Outputs ​

  • main — Taken once the MyNotary operation has succeeded. An error answer from MyNotary fails the step instead.

Data produced ​

What this node adds to the run data, and how to read it in an expression. <step> stands for the step key: the node name turned into an identifier (see Data and expressions).

  • {{ data.<step>.operations }} — array of { id, label, type, link, archived, creationTime, records, mergedFrom }. List cases only: the cases found. records maps each role of the case to its record ids (for example { "VENDEUR": [123] }), mergedFrom lists the ids of cases merged into this one, link opens the case in MyNotary.
  • {{ data.<step>.operation }} — { id, label, type, link, archived, creationTime, records, mergedFrom }. Get a case only: the case read.
  • {{ data.<step>.contracts }} — array of { id, model, label, link, status, signatureType, signatureTime, creationTime, signatureId, signed }. Get a case and List the contracts of a case: the contracts of the case. signed is true when status is SIGNATURE_COMPLETED.
  • {{ data.<step>.documents }} — object. Get a case only: the documents of the case, as file ids keyed by document id.
  • {{ data.<step>.count }} — number. The number of items concerned: cases, contracts, records, drive files, users, webhooks, or records attached by Add a party to the case.
  • {{ data.<step>.truncated }} — boolean. List cases and Search records: true when more items existed than the limit allowed.
  • {{ data.<step>.operationId }} — string. Create a case: the id of the new case (empty in a test run). Add a party to the case and Drop an email attachment into the drive: the case concerned.
  • {{ data.<step>.link }} — string. Create a case, Create a contract from a model, Create a record: the MyNotary link of the new object, empty in a test run.
  • {{ data.<step>.created }} — boolean. Create a case, Create a contract from a model, Create a record, Create a webhook: true when the object was created, false in a test run.
  • {{ data.<step>.branch }} — string. Add a party to the case only: the role used, in upper case.
  • {{ data.<step>.recordIds }} — array of string. Add a party to the case only: the record ids attached.
  • {{ data.<step>.pendingCount }} — number. List the contracts of a case only: the number of contracts whose status starts with SIGNATURE_.
  • {{ data.<step>.contract }} — { id, model, label, link, status, signatureType, signatureTime, creationTime, signatureId, signed }. Get a contract and Track the signature: the contract read.
  • {{ data.<step>.status }} — string. Get a contract and Track the signature: the status of the contract.
  • {{ data.<step>.signed }} — boolean. Get a contract only: true when the contract is signed (SIGNATURE_COMPLETED).
  • {{ data.<step>.contractId }} — string. Create a contract from a model only: the id of the new contract, empty in a test run.
  • {{ data.<step>.model }} — string. Create a contract from a model only: the contract model used.
  • {{ data.<step>.signatureStatus }} — string. Track the signature only: the status of the current signature, empty when the contract was never sent for signature.
  • {{ data.<step>.signatureTime }} — string. Track the signature only: the completion time of the signature, when there is one.
  • {{ data.<step>.signatories }} — array of { name, email, role, signedAt, signed }. Track the signature only: every signatory, with whether they have signed.
  • {{ data.<step>.pending }} — array of { name, email, role, signedAt, signed }. Track the signature only: the signatories who have not signed yet.
  • {{ data.<step>.pendingEmails }} — array of string. Track the signature only: the email addresses of the signatories who have not signed yet.
  • {{ data.<step>.signedFileIds }} — array of string. Track the signature only: the file ids of the signed documents, ready for Fetch a file as an attachment.
  • {{ data.<step>.records }} — array of { id, type, questions, documents, lastUpdate }. Search records only: the records found. questions holds the form answers keyed by question id, documents the file ids keyed by document id.
  • {{ data.<step>.found }} — boolean. Search records only: true when at least one record was found.
  • {{ data.<step>.recordId }} — string. Search records: the id of the first record found. Create a record: the id of the new record (empty in a test run). Update a record: the record updated.
  • {{ data.<step>.record }} — { id, type, questions, documents, lastUpdate }. Get a record only: the record read.
  • {{ data.<step>.associations }} — array. Get a record only: the links of the record to other records (marriage, guardianship, co-ownership…), as MyNotary returns them.
  • {{ data.<step>.type }} — string. Create a record only: the record type used.
  • {{ data.<step>.updated }} — boolean. Update a record only: true when the update was sent, false in a test run.
  • {{ data.<step>.fields }} — array of string. Update a record only: the question ids sent.
  • {{ data.<step>.files }} — array of { driveFileId, fileId, name, addedAt }. List a case drive only: the files of the case drive. fileId is what Get a download link and Fetch a file as an attachment expect.
  • {{ data.<step>.fileId }} — string. Get a download link, Fetch a file as an attachment: the file concerned. Drop an email attachment into the drive: the id of the uploaded file (empty in a test run).
  • {{ data.<step>.downloadUrl }} — string. Get a download link only: a download link that needs no authentication. Treat it as a secret.
  • {{ data.<step>.expiresInDays }} — number. Get a download link only: how long the link stays valid, always 7.
  • {{ data.<step>.attachmentPosition }} — number. Fetch a file as an attachment only: the position of the file in the run's attachments, ready for a Compose step.
  • {{ data.<step>.filename }} — string. Fetch a file as an attachment only: the name of the fetched file.
  • {{ data.<step>.mime }} — string. Fetch a file as an attachment only: the MIME type of the fetched file.
  • {{ data.<step>.size }} — number. Fetch a file as an attachment only: the size of the fetched file, in bytes.
  • {{ data.<step>.deduplicated }} — boolean. Fetch a file as an attachment only: true when an identical file was already in the run's attachments; its position is reused.
  • {{ data.<step>.driveFileId }} — string. Drop an email attachment into the drive only: the id of the file in the case drive (empty in a test run).
  • {{ data.<step>.name }} — string. Drop an email attachment into the drive only: the name of the file in the drive.
  • {{ data.<step>.position }} — number. Drop an email attachment into the drive only: the position of the attachment sent.
  • {{ data.<step>.users }} — array of { id, firstName, lastName, email, role }. User resource only: the members of the firm.
  • {{ data.<step>.webhooks }} — array of { id, url, authType }. List webhooks only: the webhook subscriptions of the key.
  • {{ data.<step>.webhookId }} — string. Create a webhook and Delete a webhook: the id of the subscription (empty in a test run for a creation).
  • {{ data.<step>.url }} — string. Create a webhook only: the callback URL registered.
  • {{ data.<step>.deleted }} — boolean. Delete a webhook only: true when the deletion was sent, false in a test run.
  • {{ data.<step>.simulated }} — boolean. true when a write was described rather than performed (test run). Reads are never simulated.
  • {{ data.<step>.summary }} — string. A one-line summary in the member's language, for example '2 records found.' (with summaryKey and summaryParams).

Operations ​

The node first asks for a Resource (resource), then for the operation of that resource.

Case (resource: operation, operation in operationOp) ​

  • List cases (list, the default). Lists the cases of the firm (GET /operations), filtered by Case type (operationType) and Label contains (operationSearch). Reads Maximum count items (limit, 1 to 300, default 50), or up to 300 with Fetch everything (fetchAll). Publishes operations, count, truncated.
  • Get a case (get). Reads the case chosen in Case (operationRef), with its contracts and documents. Publishes operation, contracts, documents, count.
  • Create a case (create). Creates a case of Case type on behalf of On behalf of (creator), with Label (label), Fields (JSON) (questions) and Documents (JSON) (documents) (POST /operations). Publishes operationId, link, created.
  • Add a party to the case (addRecords). Attaches the records listed in Records to attach (recordIds, comma-separated) to the Role (branch) of the case, for example VENDEUR or ACQUEREUR (POST /operations/{id}/records). Publishes operationId, branch, recordIds, count.

Contract (resource: contract, operation in contractOp) ​

  • List the contracts of a case (list, the default). Reads the case and returns its contracts. Publishes contracts, count, pendingCount.
  • Get a contract (get). Reads the contract whose id is in Contract (contractId). Publishes contract, status, signed.
  • Create a contract from a model (create). Creates a contract in Case from Contract model (contractModel, listed under the chosen Case type), on behalf of On behalf of, with Label, Fields (JSON) and Documents (JSON) (POST /contracts). Publishes contractId, link, model, created.
  • Track the signature (signature). Reads the contract, then, when it has been sent for signature, its signature (GET /signatures/{id}). Publishes contract, status, signatureStatus, signatureTime, signatories, pending, pendingEmails, signedFileIds. A contract never sent for signature returns empty lists and an empty signatureStatus.

Record (resource: record, operation in recordOp) ​

  • Search records (search, the default). Searches the firm's records (GET /records) with Search (search, case- and accent-insensitive, every word must be found) in Searched fields (searchFields, default nom,prenoms,email), filtered by Record type (recordType) and Updated since (updatedSince, a 2026-09-22 date). Maximum count and Fetch everything as for List cases. Publishes records, count, found, recordId, truncated.
  • Get a record (get). Reads the record in Record (recordId). Publishes record, associations.
  • Create a record (create). Creates a record of Record type on behalf of On behalf of, with Fields (JSON) and Documents (JSON) (POST /records). Publishes recordId, link, type, created.
  • Update a record (update). Sends Fields (JSON) and Documents (JSON) to the record (PUT /records/{id}). Only the answers sent change; a question sent with an empty value is erased. Publishes recordId, updated, fields.

Document (resource: file, operation in fileOp) ​

  • List a case drive (list, the default). Lists the files of the drive of Case (GET /drive-files). Publishes files, count.
  • Get a download link (link). Asks MyNotary for a fresh download link for File (fileId). Publishes fileId, downloadUrl, expiresInDays.
  • Fetch a file as an attachment (download). Gets a fresh link for File, downloads the file and adds it to the run's attachments, under File name (downloadName) or the name MyNotary gives, within Maximum size (MB) (maxDownloadMb). Publishes fileId, attachmentPosition, filename, mime, size, deduplicated.
  • Drop an attachment into the drive (upload). Sends the attachment at Attachment (position) (attachmentPosition: 1 for the email's first attachment, or {{ data.<step>.attachmentPosition }} for a file added by an earlier step) to MyNotary (POST /files, multipart), under File name (fileName) or the attachment's own name, then files it in the drive of Case (POST /drive-files). Publishes fileId, driveFileId, name, operationId, position.

User (resource: user) ​

Lists the members of the Firm (GET /users). This resource has a single operation. Publishes users, count.

Webhook (resource: webhook, operation in webhookOp) ​

  • List webhooks (list, the default). Publishes webhooks, count.
  • Create a webhook (create). Subscribes Callback URL (webhookUrl), the URL shown on the MyNotary — event trigger, to the events of the key (POST /webhooks). Publishes webhookId, url, created.
  • Delete a webhook (delete). Deletes the subscription in Webhook (webhookId). Publishes webhookId, deleted.

Every operation also publishes simulated and summary.

Example ​

When a sale agreement is fully signed, the signed deed must be emailed to the buyer's bank. The workflow starts with the MyNotary — event trigger, whose data lives under data.mynotary. A first MyNotary node, named "Signature", tracks the contract:

text
resource     contract
contractOp   signature
contractId   {{ data.mynotary.contractId }}

It publishes, among others:

json
{
  "status": "SIGNATURE_COMPLETED",
  "pending": [],
  "pendingEmails": [],
  "signedFileIds": ["f6c1d2e3-…"],
  "simulated": false
}

A second MyNotary node, named "Signed deed", fetches the file into the run:

text
resource       file
fileOp         download
fileId         {{ data.signature.signedFileIds.0 }}
downloadName   Sale agreement — {{ data.mynotary.contractId }}.pdf
maxDownloadMb  10

Its data gives {{ data.signed_deed.attachmentPosition }}, which a Compose step uses to attach the deed. The same Track the signature step, run every Monday from a Schedule trigger, gives pendingEmails for a reminder to the signatories who have not signed yet.

Tips ​

  • No idempotency: search before you create. MyNotary offers neither an idempotency key nor "create if absent". If the engine replays Create a case, Create a contract from a model or Create a record after an incident, a second object is created. Run Search records first and branch on {{ data.<step>.found }} with a Condition (If), or keep the correspondence in a table. Add a party, Drop an attachment and Create a webhook are not protected either.
  • Fields (JSON). Answers are keyed by MyNotary question id ({"nom":"Dupont","prenoms":"Marie"}), and documents by document id ({"carte_identite":[{"fileId":"…"}]}, the fileId coming from an earlier Drop an email attachment into the drive). Write a date as 2026-03-16, never with a time: MyNotary would silently ignore it. Invalid JSON, or JSON that is not an object, fails the step with node_invalid_param.
  • Searching records. Searched fields is required as soon as Search is filled (at most ten ids, such as nom,prenoms,email,telephone for a person or siren,personne_morale_denomination for a company); without it the step fails with node_invalid_param. Updated since is the only incremental filter of the API: List cases has none.
  • Download links are secrets. A link from Get a download link needs no authentication and stays valid seven days. To attach a file to an email, use Fetch a file as an attachment: the link never appears in the step data.
  • File sizes. Maximum size (MB) goes from 1 to 10, the server's real limit per downloaded file. An uploaded attachment is also capped at 10 MiB, checked before anything is sent to MyNotary (attachment.too_large). An attachment position that does not exist fails with attachment.not_found.
  • Contract models. The model list depends on Case type: changing the case type empties Contract model.
  • Webhooks. MyNotary sends every event of every firm attached to the key to the subscribed URL; the trigger sorts them. The subscription is created without authentication: the proof of origin is the secret token in the trigger URL.
  • Test runs. In test runs, every read runs for real, including Fetch a file as an attachment. Creations, updates, the drive upload and webhook changes are only described: nothing is written in MyNotary, simulated is true and no id or link is returned. In particular, Drop an email attachment into the drive stops before filing in the drive.
  • Trigger data. In a workflow started by the MyNotary trigger, the trigger's data lives under data.mynotary. Do not name this node "MyNotary" there: its data would only be reachable through the node id.
  • Errors. integration.unauthorized: the key was refused or revoked. integration.not_found: the case, contract, record or file does not exist for this key. integration.rejected: MyNotary refused the request (for example an answer or a role it does not accept). integration.rate_limited and integration.unavailable are retried automatically: requests are paced to 300 per minute per connection, and a 409, 429 or 5xx answer gets up to three attempts before the engine retries the step later. See Error handling.