ead-enterprise-suite

Lists a notification's recipients with their individual delivery state. Returns per recipient: id, firstName, lastName, email, phonePrefix/phoneNumber, status (INVALID, READY_TO_SEND, SENT, READ, ANSWERED, ERROR), statusUpdatedAt, `answer` once they respond, emailBounced, and validationError (TAKEN, IS_DEFINED, IS_INVALID) for a rejected address. Worth calling before notification_request_send to see whether any address came back INVALID, and after sending to see who read or answered. Also the way to recover a receiverId for notification_certificate_get. Paginated; filterable by id.

Corrects a recipient's details: firstName, lastName, email, phonePrefix, phoneNumber. Requires receiverId, notificationRequestId and caseFileId. Use this to fix a mistyped address rather than deleting and re-adding, which would lose the receiverId. phonePrefix must include the + (for example +34). A phone number is required if the recipient is to receive the RCS/SMS link (sendSmsUrl), the WhatsApp link (sendWaUrl), or an OTP challenge (otpRequired).

Moves a notification to a different case file. Note the two caseFileId values: the one in the path is where the notification is NOW, and the one in the body is the destination. Notifications are grouped by case file, and this is the only way to change that grouping without duplicating.

Creates a certified notification request. Requires: case_file_create → caseFileId. Generate a UUID v4 for `id`. Set language to en_GB or es_ES. Returns notificationRequestId. Add at least one receiver with notification_receiver_add before sending. IMPORTANT: The `content` field must be valid HTML — plain text without HTML tags will not render on the recipient landing page. Only the following HTML formats are supported: paragraphs (<p>), bold (<strong>), italic (<em>), unordered lists (<ul><li>), ordered lists (<ol><li>). Do not use other HTML tags or CSS. Avoid special typographic characters (em dashes, smart quotes) in `subject`; use standard ASCII equivalents (hyphen, straight quotes) instead.

Deletes a notification. Requires notificationRequestId and caseFileId. There is no undo. TESTED: once the notification has been sent the API rejects this with 403 Forbidden — a sent notification is delivery evidence and cannot be removed. If you only want it filed elsewhere, use notification_request_case_file_move instead.

Creates a new DRAFT notification from an existing one, copying its content, its recipients and its attachments. Works whatever state the original is in, so this is how you resend to the same people or reuse a sent notification as a template. Generate a UUID v4 for `id` and supply a new `subject`; pass `caseFileId` in the body to place the copy in a different case file, or omit it to keep it alongside the original. THE COPY IS BUILT ASYNCHRONOUSLY: it starts in CREATING with zero recipients and zero documents, and fills in afterwards, so reading it immediately shows an empty notification that is not empty. Poll notification_request_status until the status is DRAFT before inspecting or sending it. Because recipients ARE copied, review them with notification_receiver_list before calling notification_request_send — otherwise you will send to the original list again.

Lists the certified notifications visible to a user. Requires userId (from session_login, session_info or profile_get) — this listing is user-scoped, not case-file-scoped, so it spans every case file unless you filter. Use this to recover a notificationRequestId you no longer have; it is the only way to find one. Returns per notification: id, code, subject, status, type, sentAt, receiverStats and the owning caseFile. Filter by `status` or `statuses` (CREATING, DRAFT, IN_PROCESS, SENT, PARTIALLY_READ, FULLY_READ, PARTIALLY_ANSWERED, FULLY_ANSWERED), by `caseFileIds`, by `search` over the subject, or by `receiversSearch` to find the notification sent to a given recipient. Paginated.

Trigger delivery of a certified notification to all added recipients. Returns immediately — delivery is async. Poll notification_request_status until status is DELIVERED before retrieving certificates.

Checks the delivery status of a certified notification. Requires: notificationRequestId, caseFileId. Returns status (CREATING|DRAFT|IN_PROCESS|SENT|PARTIALLY_READ|FULLY_READ|PARTIALLY_ANSWERED|FULLY_ANSWERED). Poll until status is SENT or beyond. Do not call notification_certificate_get while status is CREATING, DRAFT, or IN_PROCESS.

Edits a notification that has not been sent: subject, content, type and language. Requires notificationRequestId and caseFileId. `content` must be valid HTML — plain text is accepted by the API but does NOT render on the recipient landing page. Supported tags only: <p>, <strong>, <em>, <ul><li>, <ol><li>; no other tags and no CSS. Keep `subject` to plain ASCII (no em dashes, no smart quotes), 100 characters maximum. TESTED: once the notification has been sent the API rejects this with 403 Forbidden, so editing only works before the send. To change which case file it belongs to use notification_request_case_file_move — this tool does not move it.

Sends a certified notification to one or more recipients in a single call: creates the notification request, adds every recipient, and sends it. Generates every UUID itself — do not pass any id. Requires case_file_create → caseFileId. `content` MUST be HTML: plain text is accepted by the API and reports SENT but does not render on the recipient's landing page. Supported tags only: <p>, <strong>, <em>, <ul><li>, <ol><li> — no other tags, no CSS. Keep `subject` to plain ASCII, 100 characters maximum. Delivery is always by email; per recipient you can additionally set sendWaUrl (WhatsApp), sendSmsUrl (RCS or SMS depending on the handset) and otpRequired (one-time code), each of which needs phonePrefix with the + and phoneNumber. The maximum number of recipients is a per-subscription setting, not a fixed limit, so none is enforced here — the API rejects an oversized batch. This tool does NOT attach files; use notification_send_with_attachments for that, because attachments must be registered before recipients are added. PARTIAL SUCCESS IS REPORTED, NOT THROWN: if the request was created but a recipient or the send failed, the result still carries notificationRequestId together with recipientsAdded, recipientsFailed and sent:false, so you can finish with notification_receiver_add and notification_request_send instead of abandoning a draft. An INVALID recipient blocks the send, so this tool checks for one before sending and reports invalidRecipients rather than attempting a send that cannot succeed. If the initial create fails the tool raises an error instead: common causes are a caseFileId that does not exist, a subject over 100 characters, and an exhausted contracted notification plan, which no retry will fix. If that error is a timeout rather than a rejection, check notification_request_list before retrying — the request may have been created anyway. Poll notification_request_status for delivery progress, then notification_certificate_get per recipient.

Sends a certified notification WITH one or more attached documents to one or more recipients, in a single call. Use notification_send instead when there are no attachments. This tool exists separately because attachments impose an ordering rule the API enforces and does not forgive: documents must be registered and fully uploaded BEFORE any recipient is added, and every document must reach READY_TO_SEND before the notification is sent — otherwise the send fails with 409/404 NOTIFICATION_NOT_FOUND. The tool performs that whole sequence for you: create → register and upload each document → wait for READY_TO_SEND → add recipients → send. Each attachment takes a local file path, base64 content, an HTTPS URL, or an n8n binary reference; the hash and the upload are handled internally. Generates every UUID itself — do not pass any id. Requires case_file_create → caseFileId. `content` MUST be HTML: plain text is accepted by the API and reports SENT but does not render on the recipient's landing page. Supported tags only: <p>, <strong>, <em>, <ul><li>, <ol><li>. Keep `subject` to plain ASCII, 100 characters maximum. Delivery is always by email; per recipient you can additionally set sendWaUrl (WhatsApp), sendSmsUrl (RCS or SMS depending on the handset) and otpRequired (one-time code), each of which needs phonePrefix with the + and phoneNumber. The maximum number of attachments and of recipients are per-subscription settings, not fixed limits, so neither is enforced here. IF AN ATTACHMENT FAILS THE RUN STOPS BEFORE RECIPIENTS ARE ADDED, on purpose: once recipients exist the API will not accept further documents, so continuing would produce a notification that can never carry the missing file. The result reports the draft's notificationRequestId so you can retry or delete it. An INVALID recipient blocks the send, so the tool checks for one before sending and reports invalidRecipients instead of attempting a doomed send. If the initial create fails the tool raises an error instead: common causes are a caseFileId that does not exist, a subject over 100 characters, and an exhausted contracted notification plan, which no retry will fix. If that error is a timeout rather than a rejection, check notification_request_list before retrying — the request may have been created anyway. Certificates can bundle the attachments — see notification_certificate_package_url.

Returns the authenticated user's own profile. It identifies the caller from the session token alone — no email or any other input needed — so it works on every deployment, including a per-request Bearer one. Its `id` field IS your userId (UUID): the value required by case_file_list and every /users/{userId}/... operation. Prefer this over session_info when you need the userId: it is the canonical source. Also returns companyId (needed to subscribe to the notifications SSE stream) and defaultCaseFileId. Also returns `permit`, a set of booleans — { evidences, idVerifications, notifications, chats, signatures } — that says which tool families this account may use at all: a false entry means every tool in that family returns 403 regardless of inputs, and no retry or different argument will help. Read it before calling into a family for the first time; on the integration deployment checked on 2026-09-07, permit.idVerifications was false and every identity tool returned 403 NoIdVerificationsPermit. No parameters.

Returns the authenticated user's session info. `type` is how this MCP session authenticated — always 'UserKey', the server's only auth flow. `accountLoginType` is a different fact: how the underlying EAD Enterprise Suite account itself signs in ('Password' or 'OpenId'), reported from GET /profile, null if the API omits it. Use this to retrieve the userId (UUID) required by case_file_list and other user-scoped operations, or to verify who is authenticated. profile_get is the canonical way to obtain the userId and returns more of the profile. Prerequisites: a valid session (call session_login first if needed). Example: session_info() → { userId: '...uuid...', type: 'UserKey', accountLoginType: 'Password' }

Force the EAD Enterprise Suite MCP server to re-authenticate. Takes no parameters and accepts no credentials: the server re-exchanges the user key it was configured with (MCP_AUTH_USER_KEY) for a fresh session token, and this tool reports the resulting userId and expiry. The server manages authentication automatically — call this only to force a re-login or after a 401.

Retrieves the signed document certificate PDF. Requires: activate_signature_request (document fully SIGNED), signature_request_add_document → documentId, signature_request_create → requestId, case_file_create → caseFileId. Returns documentUrl (signed PDF certificate). ASYNC: poll until documentUrl is available.

Sets the visual position of the signature field on a PDF document page. Required for PDF documents before activation, for both INTERPOSITION and ADVANCED signatures. Requires: signature_participant_create → signatoryId, signature_request_add_document → documentId, signature_request_create → requestId, case_file_create → caseFileId. Provide coordinates as array of {page (1-based), x (points from left), y (points from bottom)}. Set coordinates after the document has been uploaded and before activate_signature_request.

Lists the documents of a signature request with a document-level status and per-document statistics. Requires: signature_request_create → requestId, case_file_create → caseFileId. Items are { id, requestId, groupId, status, title, fileName, fileSize, convertToPdf, participantStats, signatoryStatusStats, signatoryCoordinatesStats } — for example status PARTIALLY_SIGNED with signatoryStatusStats { pending: 0, readyToSign: 1, signed: 1, rejected: 0 } and signatoryCoordinatesStats { defined: 2, missing: 0 } (live-read on INT 2026-09-07). signatoryCoordinatesStats.missing === 0 is the direct check that every required signatory has coordinates before activate_signature_request. Whether this status also reports upload processing for a freshly added document is NOT verified — keep using signature_request_get for that. For the signatories of one document use signature_document_signatory_list.

Lists the OBSERVERS of one document in a signature request — participants created with role OBSERVER, who receive a copy but never sign. Requires: signature_request_add_document → documentId, signature_request_create → requestId, case_file_create → caseFileId. Items carry only { id, email, firstName, lastName }: there is deliberately no status field, because an observer has nothing to complete. For the signers of the same document use signature_document_signatory_list.

Lists the SIGNATORIES of one document in a signature request, with each signatory's status on that document. Requires: signature_request_add_document → documentId, signature_request_create → requestId, case_file_create → caseFileId. Items are { id, groupId, email, firstName, lastName, status, coordinates, uniqueValidator, phonePrefix, phoneNumber, participantStats } and status is PENDING, READY_TO_SIGN, VALIDATING, SIGNED or REJECTED. Each `id` is a signatoryId. To check whether the DOCUMENT itself reached READY_TO_SIGN before activate_signature_request, use signature_request_get; after activation poll here until every signatory is SIGNED before signature_certificate_get.

Creates a signing order group for a CONFIGURABLE signature request. Types: 'Document' (groups documents into signing rounds — use its id as groupId in signature_request_add_document), 'Signatory' (groups signatories into signing rounds — use its id as groupId in signature_participant_create), 'DocumentSignatory' (links a specific document to a signing round, requires documentId). IMPORTANT — avoid empty groups: when a CONFIGURABLE request is created, the API automatically pre-creates one Document group and one Signatory group both at index:1. Always use these pre-existing index:1 groups for your first document and first signatory (retrieve their IDs with signature_group_list immediately after creating the request). Only call signature_group_create for the ADDITIONAL groups (index:2, 3…). Add participants with linkToAllDocuments:true so DocumentSignatory groups are auto-generated at the correct index. Adding participants without linkToAllDocuments leaves them unlinked to documents and signature_coordinate_set will fail with 'Signatory not found'.

Lists all signing order groups of a CONFIGURABLE signature request. Returns id, type (Document/Signatory/DocumentSignatory), index, and documentId for each group. Call immediately after signature_request_create to retrieve the pre-created index:1 group IDs before adding documents or participants.

Adds many participants to a DRAFT signature request in one call instead of one signature_participant_create per person. Requires: signature_request_create → requestId, case_file_create → caseFileId, and a `participants` array whose entries take the same fields as signature_participant_create, including the `id` and `role` you generate for each. Mixed roles in one call are allowed. Returns HTTP 201 with NO body, so keep the ids you minted and re-read the result with signature_participant_list.

Adds one participant to a DRAFT signature request. This is the ONLY participant create endpoint: `role` selects SIGNATORY (must sign), OBSERVER (receives a read-only copy) or VALIDATOR (must approve before its signatory can sign). Requires: signature_request_create → requestId, case_file_create → caseFileId, plus role, firstName, lastName and email. YOU generate `id` (UUID v4) and the call returns HTTP 201 with NO body, so nothing is handed back — the id you generated IS the participantId, and it is the signatoryId if you passed role SIGNATORY or the validatorId if you passed role VALIDATOR. Keep it. For ADVANCED signatures phonePrefix and phoneNumber are mandatory because the signer receives the OTP there, and WhatsApp delivery is NOT supported for ADVANCED; for INTERPOSITION phone is optional and WhatsApp is available when the platform is configured for it. Add at least one SIGNATORY before activating. For role VALIDATOR do NOT include groupId or linkToAllDocuments — link it afterwards with assign_validator_to_signatory. Use signature_participant_add_bulk to add many at once, and signature_participant_list to re-read what exists.

Removes one participant from a signature request. Requires: signature_participant_create → participantId, signature_request_create → requestId, case_file_create → caseFileId. Use it to drop someone added by mistake, or to change a role (delete, then create again with the new role, since role is not updatable). Returns no body; confirm with signature_participant_list. To drop every invalid participant at once use signature_participant_invalid_purge instead.

Removes every participant of a signature request that the platform has marked invalid, in one call. Requires: signature_request_create → requestId, case_file_create → caseFileId. signature_participant_list identifies them via `valid: false` and `validationError` — typically an undeliverable email or a malformed phone number. Returns no body; confirm with signature_participant_list. Prefer signature_participant_update when the detail can be repaired rather than the person dropped.

Lists every participant of a signature request with the role each was created under — SIGNATORY, OBSERVER or VALIDATOR — plus contact details and validity. Requires: signature_request_create → requestId, case_file_create → caseFileId. Items are { id, requestId, groupId, role, firstName, lastName, email, phonePrefix, phoneNumber, createdAt, editable, emailBounced, valid, validationError, participantStats, documentStats }. This is the tool that resolves ids: an item's `id` is the participantId, and it is also the signatoryId when role is SIGNATORY and the validatorId when role is VALIDATOR. Supports filter, order and page.

Corrects a participant's details before the signature request is activated. Requires: signature_participant_create → participantId, signature_request_create → requestId, case_file_create → caseFileId. Any of groupId, firstName, lastName, email, phonePrefix and phoneNumber may be sent. The role CANNOT be changed, so to turn a signatory into an observer, delete it and create it again. Use this to repair a bounced or mistyped email — signature_participant_list reports emailBounced and validationError. Returns no body; confirm with signature_participant_list.

Adds a document to a DRAFT signature request. Requires: signature_request_create → requestId, case_file_create → caseFileId. Provide a string `id` for the document. Compute SHA-256 hex hash of the PDF before calling. Optional: pass `fileUrl` (a publicly accessible URL) to have the tool download and upload the file to S3 automatically — no separate PUT needed. If fileUrl is omitted, returns url (presigned S3 upload URL) for manual PUT. Cannot add documents after activate_signature_request is called. For CONFIGURABLE sequence: `groupId` must reference a Document type group (not Signatory or DocumentSignatory) — passing a wrong group type returns 'Signature group not found'.

Cancels an active signature request. Requires: activate_signature_request (ACTIVE status), requestId, caseFileId. Transitions to CANCELLED. Cannot be undone.

Creates a new signature request in DRAFT status. Requires: case_file_create → caseFileId. Generate a UUID v4 for `id`. Set deadline as ISO 8601 datetime (max ~30 days ahead). Returns requestId. Add documents with signature_request_add_document and participants with signature_participant_create before activating.

Retrieves full details of a signature request. Requires: signature_request_create → requestId, case_file_create → caseFileId. Returns status, documents, participants, deadline, and history. Use to check overall process state.

Lists the documents assigned to ONE signatory of a signature request, with that signatory's progress on each. Requires: caseFileId, requestId and signatoryId. The signatoryId is the `id` of a participant whose role is SIGNATORY — read it from signature_participant_list or signature_document_signatory_list. Passing a participant id whose role is not SIGNATORY returns 404 'Signatory not found' — observed on INT 2026-09-07 with a VALIDATOR id; it is one id space, but the signatory-scoped endpoints accept only the ids of SIGNATORY participants. Returns { data, meta.totalElements } with items { id, fileName, fileSize, status }, where status is PENDING, READY_TO_SIGN, SIGNED or REJECTED.

Lists the validators currently linked to ONE signatory of a signature request. Requires: signature_participant_create (signatory) → signatoryId, signature_request_create → requestId, case_file_create → caseFileId. Items carry { id, email, firstName, lastName }, where each `id` is a validatorId. Note the two-step model: creating a participant with role VALIDATOR does not attach it to anyone, so a validator can exist on the request and not appear here until assign_validator_to_signatory links it — an empty list means nothing is linked yet, not that no validator exists.

Unlinks one validator from one signatory, reversing assign_validator_to_signatory. Requires: signature_validator_list → validatorId, signature_participant_create (signatory) → signatoryId, signature_request_create → requestId, case_file_create → caseFileId. This removes the LINK only: the validator remains a participant of the request, so use signature_participant_delete to remove the person entirely. Returns no body; confirm with signature_validator_list.

Lists available use cases for the account. Use cases define the allowed signature workflows and document types. Returns useCaseId values needed for signature_request_create.