While I was poking around the DocuSign API getting it set up for an application, I noticed recipients have two separate ID's, one being a recipientId and the other recipientIdGuid.
The first value recipientId appears to be plain numbers, whereas the other value looks to be a UUID or hash of some kind.
I'm assuming the recipientId fields are unique to the envelope, whereas the recipientIdGuid version is unique across the service? I'm trying to get the Docusign Connect service set up currently, so I'm wondering what I should be storing locally in our own DB.
RecipientGUID is the GUID for a particular recipient on a particular envelope. No two recipients will ever have the same recipientGUID.
RecipientId is a local reference integer, used for mapping recipient to other objects, such as mapping the recipient in the envelope to tabs assigned to them in that envelope. The Sender sets these values. No two recipients in the same envelope will have the same ID, but across envelopes there is no uniqueness requirement.
Related
I'm evaluating DocuSign esignature API (c# SDK) for an e-signature solution.
Our scenario is easy:
single PDF
multiple signers
each signer has its own signature form field defined in the PDF
Is there a way to map specific signature form field inside PDF to specific signer?
What we already tried:
Anchor text is working but it is cumbersome for our clients to position anchor text, changed its color so it is invisible. Also it is error-prone
TransformPdfFields somewhat working but as I understand it is all or nothing it transforms all form fields and all signature fields are mapped to single signer (am I wrong here?)
Thanks.
With DocuSign, each field (SignHere fields, text input fields, etc) is owned by a specific signer or other recipient type. Fields are called tabs in the API.
At a schematic level, the object hierarchy is:
There are multiple ways to map signHere tabs to different signers and locations in your documents:
Use a template. You or your business person can create a template using the DocuSign web tool. Then your app can use the template id to create and send an envelope.
The different signers are referred to as roles in the template. Eg customer signer 1, internal signer etc. Your app assigns specific names / emails to the roles when it creates the envelope.
Assign the tabs (fields) to signers using the API. The tabs can be positioned using absolute locations or via anchor strings.
Use an HTML document as your source documents. You can specify the tab locations in the HTML. See docs.
Use a PDF Form as your source document. If you name the form's fields consistently then you can use the DocuSign composite templates feature to have the form's fields belong to different recipients/signers. I do not recommend this approach if you have control over the source documents. But if you are give PDF Forms as your source documents, you can make use of them.
We've set up our template to include signature blocks and we're able to send the recipient's name and email address with the envelope. These recipients appear in the recipient list and when you sign in to DocuSign you're able to select one of the recipients from the list and position it appropriately.
We're looking at removing this manual step so that we can say, for example, the first signature we send across in the envelope corresponds to signature block one in our template and the second to the second as so on.
When we create the signature blocks in our template we can assign roles and the DocuSign documentation suggests that if we send a role across with the envelope we should be able to achieve the automatic positioning that we're after.
What we're wondering is whether we can also do this with the recipient id rather than the role?
There are multiple ways to position tabs (signature blocks) for recipients.
One approach is to specific x/y coordinates where the tab should be located inside the document (also specify page #)
Another approach is to use AnchorTags which is specific text that the tab (or tag) would be located in. This can be used with white-on-white text in the document, that could be invisible to the signer but allows the tag to be placed there. This can also be a real part of the document (like 'Date:') and you can specify an offset to improve your positioning.
Read more how to use AnchorTags in the API here - https://developers.docusign.com/esign-soap-api/reference/sending-group/using-anchor-tags
I am using the most current DocuSign.eSign.dll NuGet package for C#/.NET.
I have a single Signer, who needs to sign two different documents (PDFs). I want the signer to sign both the documents together, in the same session.
So, I created a new envelope that has TWO documents (base 64 encoded) and EACH of those documents has the same SINGLE signer, but get back an error saying that the envelope has DUPLICATE RECIPIENTS.
How else am I supposed to construct this API call/envelope, in order for the signer to sign both the documents together, in the same session on the DocuSign website?
Your envelope should have one recipient (signer) and two documents.
The documents field in the envelopeDefinition object takes an array of document objects.
Create one document object for each of your documents and you should be all set.
As stated by, Lary K, it needs to be an array. I just posted an example here: How to send multiple documents for signature DocuSign for Salesforce
I need to do this use case:
create a Docusign envelope with one signer
let the signer sign the document through embedded signing
add another signer to the document, and let the other signer sign it too
Reason: it might take some time for the 2nd company to sign the document, and the exact person to sign it might not be known at the beginning yet.
There's at least two ways to solve for this but possibly others too.
The first method is using one of the pre-built Recipient Types such as Agent or Editors or Intermediaries. These recipient types have varying capabilities (i.e. some can add tabs, docs, etc. to the envelopes) but the one thing they all have in common is that they can edit recipient information such as Name and Email address for recipients that come later in the routing order.
Another method for handling this which is a slight hack but still doable is to add two recipients with routing orders 1 and 2 to the envelope at the start, the first one is the recipient whose information you already know but for the second recipient you add a fake name and a fake email address. Once the first recipient signs the request technically gets sent to the "dummy" recipient but since it's a fake email it never gets sent to anyone. THEN, once you finally know who the second recipient is you can do an Envelope Correction and replace the dummy recipient with the real name and email.
This is continuation to the following post
insert a page into document while sending envelope using DOCUSIGN
I have rephrased my question due to poor explanation before.
Any help is greatly appreciated.
I am not successful in finding a documentation about the following scenario.
I am trying to find whether is it possible to "dynamically" insert table in a PDF while creating an envelope out of Template. Assume that you have created a template with one signature and you want to give an option to insert other rows for multiple sinature.
No information found so far. Thats why i am trying to see if there is a way which i am not aware of.
Any reference to online material is greatly appreciated!!!
One option to facilitate your use case might be to create multiple Templates in DocuSign -- one for each possible number of signers, and then have your application logic determine which Template to use during Envelope creation based upon some logic within your application. For example, let's assume the following scenario:
Your application is an online loan processing application that collects information from the borrower, and then uses DocuSign to present the loan documents for signature.
If there IS NOT a co-borrower, then you only need signature from one person (the borrower).
If there IS a co-borrower, then you need signatures from two people (the borrower AND the co-borrower).
In DocuSign, you create two (nearly identical) templates:
Loan Docs - 1 signer : This template defines a single recipient role (Borrower) and the document(s) in the template only contain space for the Borrower's signature.
Loan Docs - 2 signers : This template defines two recipient roles (Borrower and Co-borrower) and the document(s) in the template contain spaces for both the Borrower's signature and the Co-borrower's signature.
If your application determines there is no co-borrower, then it creates the Envelope using the first template (Loan Docs - 1 signer). If your application determines there IS a co-borrower, then it creates the Envelope using the second template (Loan Docs - 2 signers).
So, that's one way of handling it. Another way of handling things would be the following:
Create a single template that defines Recipient Roles (and corresponding tags in the document(s)) for the maximum number of Signers you'd ever have.
When you make the "Create Envelope" API call using that template, only supply recipient information for the number of signers that are required for that specific Envelope.
For example, let's say that your template defines 2 recipient roles (Borrower and Co-borrower), and contains signature tags for each recipient.
If your application determines that there are 2 signers, you supply information for both signers in the "Create Envelope" API call.
If your application determines that there is just 1 signer, you supply information for only the Borrower in the "Create Envelope" API call.
DocuSign will simply drop/ignore any tags belonging to recipient roles that you did not supply information for in the "Create Envelope" API call. So, in the latter case (info supplied for only one signer), the space(s) in the document(s) where the second signer's signature would have appeared still exists -- it'll just be empty/blank (because there is no second signer for the Envelope).