What a month! This was one of the busiest months we’ve had here in DocuSign in a long time. First, we had Dreamforce, with major new announcements about DocuSign products and also some new tools for developers. If you didn’t have the chance to attend Dreamforce this year, check out some of our stories about it on our blog. This month we also enabled support for Smart Sections for the Developer Sandbox, which paves the way for many new app ideas for you all. My latest blog series for common API tasks will help you use DocuSign features to add expiration and reminders to envelopes and Geoff Pfander wrote an excellent article about how to use composite templates. Did you even know we had such a thing called composite templates?


But wait, there’s more… we've just released an API Success Story about up-and-coming Copper CRM and how they are using DocuSign and yeah, I also wrote a blog post about recipient authentication, when you need a bit more oomph trust in your recipients’ identities. Lastly, we have a special treat this month for our developer spotlight. Igor Uzhakov is not only a Chief Technology Officer (CTO), which is a first for us, but also, he and his team built integrations with one of our newest APIs: the DocuSign Rooms API. Read all about it in our December Developer Newsletter!

From all of us here at DocuSign - Happy Holidays to you and your families!

Have a topic you’d like to see covered in this newsletter? Take our short survey and share your thoughts!

Inbar Gazit Thanks for reading,
Inbar Gazit DocuSign signature
Lead Developer Content Manager
In the News
Leveling up our Trailhead presence at Dreamforce 2019
Leveling up our Trailhead presence at Dreamforce 2019
The DocuSign API team hit the big time at Dreamforce 2019! Not only did we present how to integrate DocuSign with Salesforce using DocuSign's Apex Toolkit, we conducted a Mini Hack, answered loads of questions from developers, raffled off prizes, hosted a packed DocuSign After Dark, and gave away swag, but we also live-streamed the event! Get the gist from our Developer Blog post.
DocuSign Agreement Cloud APIs Shine at CalHacks 2019
CalHacks 2019, held October 25-27, saw DocuSign's eSignature and Click APIs shine with many innovative solutions presented by hackers at the world's largest collegiate hackathon. DocuSign's team of engineers and developer support specialists presented the fundamentals of the APIs, walked through a sample application, and helped attendees with technical challenges as they developed their apps. Prizes were awarded for best use of both eSignature and Click. Read all about it in our Developer Blog post.
The DocuSign dev team at CalHacks 2019
New Tools and Content for Developers
Smart Sections are Now Available in the Developer Sandbox!
Smart Sections
This new addition to Developer Sandbox functionality extends the capabilities of Responsive Signing, enabling developers to provide their customers an optimized mobile experience in their DocuSign integrations. Read our blog post to find out how to add Smart Sections to an envelope, and watch the video as lead DocuSign engineer David Miller walks you through the process.
Deep Dive Discussions: Apex Toolkit
This episode of Developer Deep Dive features Fred Wade, Director of Engineering, as he talks with Developer Salesforce Evangelist Lauren Dunne about the Apex Toolkit. The Apex Toolkit is a client library for Salesforce that makes it possible to interface with Salesforce from your DocuSign integrations. Watch the video as Fred and Lauren show you the power and potential of the Apex Toolkit to streamline and simplify your Salesforce workflows. In the blog post Neel Kumar also includes a code example of how to create a Change Request (CR) using DocuSign and Apex.
Fred Wade and Lauren Dunne
Developer Center and Best Practices
Common API Tasks🐈: Adding Reminders and Expiration to an Envelope
Common API Tasks🐈
Reminding your user in a timely fashion that they need to sign an envelope and setting appropriate expiration for that envelope are vital to your eSignature workflows. In the case of envelopes sent through the DocuSign eSignature REST API, you need to be able to add reminders and set expirations programmatically. Lead Developer Content Manager Inbar Gazit, in his fourth entry in the Common API Tasks🐈 series, walks you through the process and gives you code examples you can plug directly into your integrations.
Implementing DocuSign Recipient Authentication
How do you make sure the person signing your electronic document is the person you intended to have sign it? That's where two-factor authentication comes in, and DocuSign supports several ways to do just that. In this Developer Blog post, Lead Developer Content Manager Inbar Gazit introduces you to DocuSign's recipient authentication methods: by SMS, phone, access code, knowledge-based, and our latest, ID verification, wherein DocuSign can actually recognize and authenticate the user based on a government-issued ID.
Recipient Authentication
API Success Story
Copper CRM Introduces DocuSign eSignature Integration

Copper logoCopper, an innovative cloud-based CRM fully integrated with Google G-Suite, needed to integrate an eSignature solution into their CRM offering. After considering the available vendors, they felt DocuSign was the obvious choice, especially with its support of the DocuSign API through the Ruby SDK.

Starting from existing Ruby code examples, Copper lead developer Daniel Quimper and his team were easily able to develop an integration that plants DocuSign eSignature workflows directly into Copper, enabling Copper customers to send documents for eSignature directly while filling in customer contact information and other details automatically. The integration lets users track the status of the signing process and easily download completed documents. Quimper's team used DocuSign Connect webhook technology to optimize data exchange between Copper and DocuSign to keep their users instantly updated with status changes.

Check out the full text of our API Success Story on the DocuSign Resource Center.

Developer Spotlight
Igor Uzhakov

Igor UzhakovIgor Uzhakov originally hails from Bakhmut, Ukraine. A graduate of Kharkiv National University of Radio-electronics with a master’s degree in Cyber Security, Igor has been working in the IT field for over 10 years, for companies all over the globe. His journey began as a junior developer and has included time as an instructor and now, since 2018, Chief Technical Officer of API Nation. His focus throughout his career has been projects that can greatly improve business processes using advanced tech.

As the CTO of API Nation, Igor leads an international team of developers building integrations between cloud-based enterprise applications and platforms to help businesses and professionals use their favorite apps together in harmony. His team at API Nation has built many integrations with DocuSign’s APIs. Their most recent DocuSign integration creates DocuSign Rooms for Real Estate workflows using BoomTown CRM. This integration instantly creates a Room and adds in all the relevant data from BoomTown, greatly improving accuracy and saving agents hours of manual entry every transaction. Igor and his team have also created DocuSign Rooms integrations for Google Calendar, Google Sheets, Updater, and BrokerSumo.

When he’s not creating new integrations, Igor will pick up a bass, sip some coffee and continue pursuing his newest hobby of sailing. Igor is always glad to connect on LinkedIn.

Release Notes Roundup
December 2019 Release Notes 
Release type — Monthly release
Release date — November 15, 2019
Platform(s) affected — Demo (Sandbox)
Release notes detail — Click here

Summary: 
  • New Org Admin UI — The Organization Admin user experience has been updated to make it easier to switch among admins, quickly find admin functions, create new orgs, and manage users.
  • New DocuSign Payments integrations — New integrations with Zuora and Cyberforce offer improved management of client payment options with Salesforce as well as a new payment gateway.
  • Various bug fixes
November 2019 Release Notes 
Release type — Monthly release
Release date — November 1, 2019
Platform(s) affected — Production
Release notes detail — Click here

Summary: 
  • New ID Verification setting — Admins can now require or disable the need for repeating the identification process once a recipient's role is completed.
  • Terminology updates — Several significant changes in terminology have been implemented in DocuSign Admin and in Org Admin.
  • various bug fixes
From the Trenches
Composite Templates
There is an unlimited variety of use cases for sending envelopes using the DocuSign eSignature REST API. The composite template is one of the most powerful tools in a developer’s toolkit for creating envelopes using the API, and along with that power comes a good deal of complexity. In this article I will describe a common use case and give JSON and C# (using our SDK) examples of how to use composite templates to code a solution. Composite templates give you more power when creating an envelope, including the ability to:
  1. Apply multiple templates to a single envelope.
  2. Replace the documents on your saved DocuSign server templates when creating the envelope, but still have the server template apply all the tabs to the recipients in your envelope.
  3. Write values at run time into the text tabs and other data fields on the server template.
  4. Add additional tabs at run time.
  5. Transform PDF fields into DocuSign tabs and assign them to recipients.
Let’s take as an example a Statement of Work where the description of the work provided varies and the hourly rate varies depending on the work provided. A DocuSign template could be created that includes all the tabs for a customer to initial and sign the document defined by auto-place text, or as we say in the eSignature API, anchorStrings. One of these tabs would be labeled HourlyRate. At run time we want to use our saved template, but swap in a new document, define a new customer and set the value of hourly rate.

To do this, we add an array of compositeTemplates to our envelope. In that array we define one composite template. We add a document to the composite template to replace the document saved on the server template. We also add a serverTemplates array consisting of one server template. This is the template you have saved in your DocuSign account. And finally, we add the inlineTemplates array, consisting of one inline template to provide the runtime information about recipients and tabs. Notice that to write a value to the HourlyRate tab, I only needed to match the tabLabel on the template to identify the tab, set the value and set the tab to locked. In JSON the complete envelope definition would look like the code below. There are only three envelope properties: compositeTemplates, emailSubject, and status.
{
  "compositeTemplates": [
    {
      "compositeTemplateId": "1",
      "document": {
        "documentBase64": "PDF Bytes",
        "documentId": "1",
        "fileExtension": "pdf",
        "name": "Statement of Work"
      },
      "inlineTemplates": [
        {
          "recipients": {
            "signers": [
              {
                "email": "g...test@example.com",
                "name": "Geoff Test",
                "recipientId": "1",
                "roleName": "Customer",
                "routingOrder": "1",
                "tabs": {
                  "textTabs": [
                    {
                      "tabLabel": "HourlyRate",
                      "value": "$180.00",
                      "locked": "true"
                    }
                  ]
                }
              }
            ]
          },
          "sequence": "2"
        }
      ],
      "serverTemplates": [
        {
          "sequence": "1",
          "templateId": "57fd4752-xxxx-xxxx-xxxx-ecbfc7a43bef"
        }
      ]
    }
  ],
  "emailSubject": "CompositeTemplate Example",
  "status": "sent"
}
                                          
To generate this JSON using the C# SDK, the code would look like this:
public static string CompositeTemplateExample()
{
    // Instantiate ApiClient and configure authentication. Method not not shown.
    string accountId = GetAPIandAuthenticate();     
    EnvelopesApi api = new EnvelopesApi(Configuration.Default);
  
    // Create a list of composite templates
    List<CompositeTemplate> CompoTemplateList = new List<CompositeTemplate>();
    // Create one Composite Templates
    CompositeTemplate compoTemplate = new CompositeTemplate();
    // Create a document
    var documents = new List<Document>();
    byte[] fileBytes = null;
    Document doc = new Document();
 
    fileBytes = File.ReadAllBytes(@"C:\temp\SOW1.pdf");
    doc.Name = "Statement of Work";
 
    doc.DocumentBase64 = System.Convert.ToBase64String(fileBytes);
    doc.DocumentId = "1";
    doc.FileExtension = "pdf";
    // Add to Composite template
    compoTemplate.Document = doc;
    // Create Envelope recipients, including them in the first template
    List<Signer> signers = new List<Signer>();
    // Create the tab for hourly rate
    Tabs tabs = new Tabs();
    Text textBox = new Text();
    textBox.TabLabel = "HourlyRate";
    textBox.Value = "$180.00";
    textBox.Locked = "true";
    tabs.TextTabs = new List<Text>();
    tabs.TextTabs.Add(textBox);
    //Create the signer and add the tabs to pick up the HourlyRate
    Signer newRecipient = new Signer
    {
        Email = "g...test@example.com",
        Name = "Geoff Test",
        RecipientId = "1",
        RoleName = "Customer",
        RoutingOrder = "1",
        Tabs = tabs,
    };
    signers.Add(newRecipient);
    //Create first list for InlineTemplates
    List<InlineTemplate> inlineTemplateList = new List<InlineTemplate>();
    InlineTemplate inlineTemplate = new InlineTemplate();
    inlineTemplate.Sequence = "2";
    inlineTemplate.Recipients = new Recipients();
    inlineTemplate.Recipients.Signers = signers;
    // Add it to the inlineTemplatesList
       inlineTemplateList.Add(inlineTemplate);            
    // Create the reference to the template housed on your DocuSign account
    ServerTemplate serverTemplate = new ServerTemplate()
    {
        Sequence = "1",
        TemplateId = "ce839909-xxxx-xxxx-xxxx-a05dbd8c7217" // Statement of Work
    };            
    List<ServerTemplate> serverTemplateList = new List<ServerTemplate>();
    // Add it to the templates List
    serverTemplateList.Add(serverTemplate);    
    // Create the composite template, add the server / inline template lists.
    compoTemplate.CompositeTemplateId = "1";
    compoTemplate.ServerTemplates = serverTemplateList;
    compoTemplate.InlineTemplates = inlineTemplateList;
    // Take the Composite Template list, add both
    List<CompositeTemplate> compositList = new List<CompositeTemplate>();
    compositList.Add(compoTemplate);
    // Create the definition for the envelope
    EnvelopeDefinition envDefinition = new EnvelopeDefinition();
    //Add the Composite Template list
    envDefinition.CompositeTemplates = compositList;
    envDefinition.EmailSubject = "CompositeTemplate Example";
    envDefinition.Status = "sent";
    EnvelopesApi.CreateEnvelopeOptions options = null; //No query parameters
    // Create the envelope
    EnvelopeSummary Response = api.CreateEnvelope(accountId, envDefinition, options);
    string envelopeId = Response.EnvelopeId;
    Console.WriteLine(envelopeId);
    Console.ReadLine();
    return envelopeId;
}


Thanks to Geoff Pfander on our developer support team for providing this tip on integrating wet-signing documents into your esignature workflows.
Geoff Pfander
Top Trending Topics
Here are some of the latest popular questions that the DocuSign developers community asked on Stack Overflow in the month of November 2019. You too can ask questions by using the tag docusignapi in Stack Overflow.

Thread: C# DocuSign API: How to prefill form field data

Summary: The developer created an integration using the DocuSign eSignature C# SDK that is sending an envelope using a template. The developer wants to be able to fill data in some of the tabs that are in the template using the integration and is not sure how to do that.

Answer: The TemplatesRole object that the developer is already using in their code has a Tabs object that can be used to modify tabs when sending an envelope from a template. This is the C# code snippet to do that:
var tabs = new  Tabs(); 
var textTab1 = new  Text(); 
textTab1.Value = "test"; 
tabs.TextTabs = new List(); 
tabs.TextTabs.Add(textTab1); 
trole1.Tabs = tabs;




Thread: DocuSign Remote Signing vs Echosign

Summary: The developer is asking if it’s possible to use remote signing to obtain a URL that can then be used to send in an email to the recipient. The developer is trying to send the emails for signature themselves, but embedded signing URLs expire very quickly, and the developer is not sure how to do that using DocuSign.

Answer: Embedded signing and remote signing are different concepts. In remote signing, the DocuSign system sends the email to the recipients that are specified in the envelope. In embedded signing, a URL is produced by DocuSign using eSignature API calls to enable the app developer to embed this URL inside their application for real-time signing. This URL should not be used via an email as it expires very quickly (about two minutes) for security reasons. The developer is interested in sending their own emails. If the reason is that they want them to look different, they should consider using the DocuSign branding templates to modify the appearance of the emails sent by the system.

If there’s another requirement to send the emails from a different system, the developer can build a mechanism wherein the URL in the email goes to their own application. The application, in turn, would generate an embedded signing URL to be used only when the recipient is ready to sign, and redirect the recipient to that URL immediately. This approach would enable the developer to have URLs that they can send in emails that in theory do not expire and can be used to send invitations to sign using DocuSign.



Thread: DocuSign: How to receive the signature in the header?

Summary: The developer is building an application and is using Connect webhooks to get event notifications from DocuSign. The developer is trying to make his app more secure by using HMAC values that should be included in the header of the HTTP call made by DocuSign Connect. These values are not showing and the developer is not sure why.

Answer: The DocuSign system enables two types of Connect configurations. One type is a global account configuration that applies to every envelope in the account and has to be set up by an account administrator. The second type is a unique per-envelope request to add Connect to a specific envelope. The latter can only be applied using the eSignature API. The developer in this case was using the second, envelope-specific Connect configuration, and it did not include the HMAC value in the header because it was set in the global Connect configuration. By removing the request for a custom Connect configuration, the envelope that the developer was sending from their app was using the global (account-wide) Connect configuration, and at that point it included the HMAC value in the header.



If you’d like to contribute to the community or ask a question, please visit us on Stack Overflow. Don’t forget to visit our Developer Center for complete documentation on how to use the DocuSign eSignature API.
Upcoming Events
API Office Hours: DocuSign Apex Toolkit—December 5, 2019
If you have questions about the DocuSign eSignature API and how to integrate with Salesforce, then we have the event for you. Join us for a live Q&A session with some of our API experts, where you'll learn how to leverage our developer platform and begin integrating with the DocuSign Apex Toolkit. Register to attend the free session.




API Office Hours: Live Q&A with our API Experts—December 10, 2019
Join us for a live Q&A session with our API experts, where you will learn how you can leverage our developer platform and begin integrating with the DocuSign APIs (or with one of our popular SDKs). Our API and SDK experts will be on hand to answer all of your technical questions, including (but not limited to): authentication, go-live process, best practices, developer resources, and more. Register to attend the free session.
Share Your Feedback

We want to make sure that this newsletter is as useful as possible. Here is a link to a very short survey – please take a minute to give us feedback.
Go to the survey
Other Resources