Third Party Integrations

Purpose: Connect LegalServer to the other tools that you need to enable your staff to work more efficiently, report more effectively, and improve their day.

Cost: Dependent on the Module.

Resources

LegalServer wants you to be able to make the best use of your site. If you have issues enabling any of these integrations or modifying them for your organization, please reach out to LegalServer Support at support@legalserver.org. Some things can be handled quickly by email. Others may require purchasing a block of support hours for 1 on 1 support. If there is something that you want to integrate with that isn't available, please reach out to let us know. We can look to add it to our feature wishlist or give you a development quote to get it out sooner.Additionally, there is a separate email list for API Integrations with LegalServer. Email api_integration+subscribe@legalserver.org to get added to the list.


If you are considering a new integration with LegalServer, please reach out to support@legalserver.org. We really want to support you in using purpose built tools to make everything easier. A couple of things to consider in your project:

  • We don't want to be the gatekeepers of authentication for your third-party partners. You've got control of that for your Demo and Live sites. While we can help get the framework setup, providing access/logins to the third-party vendors is up to you.
  • Scope creep can be really difficult to manage. If we're customizing an API endpoint, we need to know all the relevant fields at the onset to avoid double work. If custom fields are involved, they need to be created before work begins. Aim for a Minimum Viable Product and then build off of it. Start small like with Henrik Kniberg's example of how to scale a project:

  • Who will be maintaining and supporting this long term? LegalServer's support typically stops at your LegalServer site. While we will look at LegalServer logs and troubleshoot a few example API calls, we're not going to be building the external pieces of the integration or maintain them over time for security upgrades or refinements.

Built-in Integrations

Accounting and Payroll Export Reports

Please see our documentation for the Accounting and Payroll Export Module.

Calendar Rules

Please see our documentation for the Calendar Rules.

Docassemble

Please see our documentation for the Docassemble Integration. There are also other methods to integrate described below.

Dropbox

Please see our documentation for the Dropbox Module.

Gavel (formerly Documate)

Please see our documentation for the Gavel Module.

Google Shared Drive

Please see our documentation for the Google Shared Drive Module.

HotDocs and LawHelp Interactive

Please see our documentation for the Hotdocs and LHI Module.

iFrame

Using an iFrame, you can embed any other existing site. This method has become more disfavored by browsers, so it may not work with everything. Some good examples of this can be embedding videos, Google Documents/Sheets/Calendars, Calendly calendars, or key resources like JustFix.NYC's Who Owns It.

Instructions with HTML

Microsoft Office for the Web

See Microsoft Office for the Web Integration.

Instruction elements on a page can also contain HTML and are another way to utilize iFrames or links.

SharePoint

Please see our documentation for the Sharepoint Module. There is more that can be done by leveraging Power Automate and other Microsoft tools. For example, you can enable automatic RTF to DOC/DOCX conversion to allow convenient editing in Word Online from documents generated by LegalServer. Or you can automatically create subfolders in any Sharepoint Case folder. Some examples are included in our Sharepoint documentation.

Twilio (SMS)

Please see our documentation for the SMS Module. Twilio allows for much more than LegalServer's integration of sending SMS/MMS messages to clients. An example of using Twilio Studio and LegalServer's APIs is available from an Integrations Community Call.

Pro Bono Opportunities API/Pro Bono Matters API

Please see our documentation about Pro Bono Opportunities API.

Custom Integrations

Getting Data Out of LegalServer

To get data out of LegalServer, consider where the request is coming from. If it is coming from an external site to pull data from LegalServer, look at the Reports API which turns any report into an API endpoint, complete with potential filters. Or you can look at our existing suite of APIs which include a wide number that can return information about cases or clients.If the request to get data out of LegalServer should initiate from within LegalServer on an as needed basis, look at the Generic Outgoing API or the Guided Navigation API options.

Getting Data Into LegalServer

Here's where our APIs really help. Please explore them at https://apidocs.legalserver.org. We've got APIs that let you create an Online Intake from another platform or create case notes on existing cases. There are a myriad of possibilities and w're interested in supporting you further.

Working Through LegalServer APIs from Outside LegalServer

Examples

Caller ID

LegalServer APIs can be called to return details for a Caller ID system. In this example, the Softphone app is configured to automatically open a webpage with the relevant information:

ClicData

Using the Reports API, ClicData can consume the information for Dashboard and visualizations.

Create a Case Note from any Process

If you want to log case notes automatically when a user does something specific, (e.g., "Documents Reviewed" or "Services Requested") you can put the Generic Outgoing API block on the process using the Create Case Note API.

The API authenticates with the API user and so you can easily add a case note in the background to any process or form being completed. The GOAPI block isn't visible on the front end, so you can put it wherever you like. You can pass a data structure for the note instead, but then the note text is a JSON string instead of something more legible. On the other hand, if you use a data structure, you can put various variables into the notes.

Docassemble

There is a Native Docassemble Integration as of October 2023. That has a separate help page.


Using Docassemble's New Interview Session API and Set Variables in an Interview API, you can start an interaction with Docassemble to process an interview from Guided Navigation. These two API calls would need to be on successive segments of a Guided Navigation Dialogue, but from the first API call, you can capture the Secret and Session parameters to then pass on for the second API call. Depending on your Docassemble Interview, you could then have it process in the background, send a completed document to LegalServer, or do something else. Utilizing jq to parse the API responses, you can set various fields within LegalServer as a result.


If two API calls is too complex, there's a new Docassemble Github Repository that will merge the two API endpoints into one designed to speed up initiating an interview from LegalServer.


Alternatively, there are a number of Github repositories that can also extend Docassemble to LegalServer. Consider Docassemble-GBLS which transforms an instruction into a list of Docassemble Interviews or Docassemble-LSLettersEmails, which offers a different method of form letter generation. These repositories are offered as examples and will require individuals with experience in configuring Docassemble.

Documint

Documint is a document template automation platform. All of the documents generated are PDF files. Once you've created a template in Documint (see the basic example below), you can utilize an API call from LegalServer to populate the document. The sample template here just shows the client and attorney names in two variables shown within the sets of {{ and }}.

You can then use Documint's REST API to POST and generate a template. When configuring the template, you can select the integrations link in the corner and get an example of the REST API call. The cURL version is probably the easiest to parse into the LegalServer fields:

From there, you can take that information and populate the Guided Navigation API features (API key below is example only).

The last step is to select all the variables in the parameter selection. Each selected variable from Documint needs the variable name to match in the parameters section.

The final step is to identify where to get the file. You can either store the response as a casenote and select url as a JSON parameter to pluck out (thereby storing the url cleanly in the case notes), or you can pick a field on the case to store the url of the response using jq. The example below has both options displayed. In actuality, only one would need to be selected. Unfortunately, as of testing (November 2022), Documint does not offer a way to push the document to Legalserver.

Dropbox Sign (formerly Hellosign) via API

There are two ways to utilize Dropbox Sign. You can purchase API licenses and use it with a directly coded integration between LegalServer and Dropbox Sign. API licenses are more expensive then standard user licenses.

In the example above, the following fields are passed:

  • Message: this is the message in the email to the recipients.
  • Test_mode: this is required for API testing. In live situations, you would exclude this parameter.
  • Signing_redirect_url: this redirects you when you finish completing the form.
  • Template_id: this is the UUID from the template itself
  • Subject: this is the subject of the email.
  • signers[Attorney][email_address]
  • signers[Attorney][name]
  • signers[Client][email_address]
  • signers[Client][name]
  • custom_fields[Forum]: sample custom field on the form. Please note that this is the deprecated version on the HelloSign endpoint since we can't pass a list within an array.
  • custom_fields[Problem]
  • ccs[CaseFile][email_address]: the case email to receive a copy once it has been completely signed

The template had three roles created -- Client, Attorney, and CaseFile. CaseFile is just for a copy of the completed document, while the other two are required signatures. You'll also need to include the Authorization token or header in the HTTP headers section.


To use this feature, you'll need an API license for Dropbox Sign. API licenses limit the number of signature requests and the number of available templates based on the level of the license.

Dropbox Sign via Users

Some groups will utilize Dropbox Sign User licenses and tie it into a Document Integration. You can tie Dropbox Sign into SharePoint, Dropbox, or other Integrations. As the configuration here is strictly within Dropbox Sign and the other platform, setting these up is beyond LegalServer Support assistance. 

Frontline SMS

Frontline SMS is designed for Text Message Surveys. Unfortunately, Frontline SMS has stopped hosting services. Using a combination of the Guided Navigation with an API call to get information to Frontline SMS, and then APIs to get the information returned, Cleveland Legal Aid has an integration described in the following video:

The API used by Frontline SMS to update the case in LegalServer was Create Multiple Case Notes.

Google Data Studio

Using the Reports API as indicated above, you can pull data into the Google Data Studio for dashboard reporting. Here is an example:

Integromat

Integromat is an automation platform where you can connect multiple sources of data and make various transformations to it. It has been updated to Make.com. It can be used to send emails or text messages, copy files, read API calls and more. Integromat has a reasonable Privacy Policy and that should be reviewed before creating the integration. For one client, LegalServer tested a workflow that read from a Reports API call and transformed it into a CSV file to then email or store via SFTP.

In the example above, an API call is made using the HTTP module. This is configured with basic user credentials and the query strings to call the appropriate Report and parse that data. The Flow Control Iterator is set up to go through all of the values of the Reports API call (configured with an array of "1. data: report: row[]"). Without the Iterator the CSV module would only work with the first row in the Reports API call instead of all of them. Then the CSV module then parses that iterated data into a CSV file. In setting up the CSV file, you will have to define the specific columns/structure of the destination CSV file. The Router feature is optional. In the example, the CSV file is then set to go to both Gmail (as an attachment) and an SFTP location. Gmail was configured for testing purposes, as the goal was to post the CSV file in an SFTP space, so one option could be turned off in a live setting. Additional details regarding error handling could also be configured.

Microsoft PowerAutomate

There are multiple ways you can use PowerAutomate with LegalServer. 


One example is to use it for browser automation:


Using the Reports API as indicated above, you can pull data into the desktop version of PowerAutomate to then automate various forms and processes. PowerAutomate can automate your browser to make it simple to fill out various forms.

Another example is to push data to it for SharePoint Lists:

This example uses the GN API or the Generic Outgoing API Block to push specific data to a SharePoint list that can then be automated in some other fashion.

Some notes from the above example:


A Sample Payload:


This is what Power Automate is looking for with the "Sample payload to generate schema": 


{
     "ClientName": "Test Test",
     "ClientStreet": "Test Street",
     "ClientCity": "Test City",
     "ClientZip": "99999",
     "ClientHomephone": "222-222-2222",
     "ClientEmail": "emailaddress@domain.com",
     "Gender": "Male"
}

It is fairly easy, if a little tedious, to generate this manually. 


Note 1: You only need the field name and some placeholder text.  "emailaddress@domain.com" is functionally equivalent to "abcde".


Note 2: Power Automate appears to set fields in the generated schema as "string" regardless of what you put in that placeholder text. (The above example will classify ClientZip as a string even though it's an integer because it is in quotes.)  Adjust the generated schema as necessary.


If you are using httpbin.org/anything, find the portion of the output that roughly matches the above. Depending on whether you send a GET or POST request to that site, it may be right near the beginning after "args" or it might be in the "data" section. Note, do NOT include the " {"args": " part, DO include the curly brackets before and after, do NOT include the comma at the end. There should be an equal number of opening and closing brackets. 

Sample Schema:

This is a sample Schema, if you want to manually create (or need to manually edit) it.  This should be broad enough to cover most common situations. 

        {
            "type": "object",
            "properties": {
                "ClientName": {
                    "type": "string"
                },
                "ClientStreet": {
                    "type": "string"
                },
                "ClientEmail": {
                    "anyOf": [
                        {
                            "type": "string"
                        },
                        {
                            "type": "null"
                        }
                    ]
                },
                "HouseholdSize": {
                    "type": "integer"
                },
                "Disabled": {
                    "type": "boolean"
                }
            }
        }

Note that this is slightly different from what was discussed on the call. After the call it was identified that using the anyOf object to hold an array of types instead of types to hold the array means that PowerAutomate generates the dynamic content variables for you. 

HTTP Header

Copy the following text exactly as written into the "HTTP Headers:" box in the LegalServer blocks. It needs to be explicitly sent. 

Content-Type: application/json

A third way to use PowerAutomate is in conjunction with the LegalServer SharePoint integration. Examples for creating subfolders in SharePoint, Moving Folders from one SharePoint Library to another, and converting files can be found in the LegalServer SharePoint help page. 


A fourth way could employ LegalServer Scheduled Reports to then check for Warrants and send out an email:

Microsoft Power BI

Using the Reports API as indicated above, you can pull data into Microsoft Power BI for dashboard reporting.

2021 Integrations call:

2023 Integrations Call:

For Microsoft Power BI, you will need the Desktop version to build the reports that integrate with LegalServer. From the Get Data screen, you'll want to select "Web":

Then it depends on how you want to Authenticate. If you want to use Basic Authentication (Username and Password), you can select Basic and put in the URL from the Reports API:

If you want to user Bearer Token authentication, you can select Advanced and add that as a custom Header:

In either case, be sure to include the load and api_key url parameters in the Reports API link.

If you selected a Bearer Token, you can then say that the Authentication is Anonymous:

If you are planning to use Basic Authentication, be sure to add in your Username and Password for the API account.

When building the Power BI report, one commen suggestion is to add a Last Refreshed Date and Time to the report.

If every column says "Table" for every row, you can solve that by Goign to the Power Query Editor -> Click the filter button for the column -> Click OK:

As to Licensing, LegalServer is not an expert in Microsoft Licensing models. The Free Fabric License was sufficient to test the integration. The paid Power BI Pro License is typically required to view Power BI Reports in Microsoft Teams or elsewhere.

Microsoft Teams

Posting in a Microsoft Teams channel is exactly like the Slack integration outlined below with a custom webhook. The only difference is that instead of using Slack's documentation to create a webhook, you should use Microsoft's documentation. 

New York City Housing APIs

There are public APIs available in New York City to make housing work easier. This video shows how to use the JQ features of GN API Calls to set both case variables and many to one service records.

Paladin

Paladin can be used for Pro Bono Opportunity Placement. See the Paladin Integration page for details

Quality Assurance Checks

Using the Reports API, you can automate regular quality checks. 

Qualtrics

Using the Generic Outgoing API Block, you can kick off various surveys from Qualtrics.

R and RStudio

Automated Annual Reports with multiple data sources and other APIs.

Remote Legal Connect

Using Guided Navigation APIs, you can tie LegalServer into ProBono.net's Remote Legal Connect tool.

Salesforce

Salesforce can be configured to utilize the Online Intake Import to then create a new Electronic Case Transfer pending case.


Through a combination of Reports using the Reports API to update Salesforce, and a variety of our user APIs to update users, organizations can use Salesforce to update and interact with their volunteers. There are quite a number of potential APIs to use with this. The key endpoints are:

These combined with the Reports API (which can now filter reports based on the UUID, name, or email address) should allow you to integrate with any other volunteer/attorney management platforms.

Slack

Using the Guided Navigation API or the Generic Outgoing API block you can configure LegalServer to post a specific message into a fixed Slack channel using Slack's webhooks. See Slack's documentation on setting up webhooks to get Slack configured. Once you have an custom webhook, it should look like: 

<a href="https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX">https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX</a><br>

This can then get used as the API url in either the Guided Navigation API or the Generic Outgoing API. In a simple setup, you can only configure one outbound parameter. It could be the case number, a literal string or any custom variable. Since there is no response to a webhook, asking LegalServer to store the response in a note will have no result.

A more advanced integration might use the Guided Navigation API in two segments. The first segment might reach out to an API testing service that you control. One public example is HTTPBin.org which is free but makes no warranties.


N.B.: Reflector sites have no security, so do not send any client Personal Identifiable Information like names, addresses, social security numbers, etc.


Those will respond with the exact parameters that were passed along. Your first API call could be something like this:

Make sure that you're making a JSON api call. For ease of testing, you can specify that the response be stored in a casenote, but the key feature here will be to use JQ to parse the response into a new custom text field. I also strongly recommend checking the option to Perform request synchonously. This will prevent the continue button from showing until the API call has been completed. 


For example, the response to the above API call could look something like: 

        {
                "GET": [],
                "POST": [],
                "HEADERS": {
                        "Content-Length": "157",
                        "Content-Type": "application/json",
                        "User-Agent": "GuzzleHttp/7",
                        "Host": "api_reflector_server_name_here"
                },
                "JSON": {
                        "casenum": "22-0000034",
                        "url": "https://your_site_here.legalserver.org/matter/dynamic-profile/view/34",
                        "database_id": 34,
                        "intake_user": "Legalserver Staff"
                }
        }

You can then setup a JQ query of something like: 

.JSON.casenum + " needs a waiver approval. Goto https://your_site_here.legalserver.org/matter/process/dynamic_16/form_loader:39/edit/" + (.JSON.database_id | tostring ) + " to approve."<br>

Take advantage of a service like JSON Editor Online to make the JSON response you stored in a case note pretty and readable. Then plug it in to a service like JQPlay to test out your JQ filter. JQ is case sensitive, so if you used HTTPBin.org, it returns the json parameter as lowercase. Then you'd have to use .json.casenum instead of .JSON.casenum in the example above. Once you've got your JQ filter identified, update the API call in the first segment of the Guided Navigation to Update the Case:

Then there will be a second segment of the Guided Navigation that is going to send the custom matter text field `Slack Message` as the `text` parameter to the Slack webhook instead of using a Literal Value like in the initial example. Slack will recognize the URL and automatically convert it to a clickable link. 

Did this answer your question? Thanks for the feedback There was a problem submitting your feedback. Please try again later.

Still need help? Contact Us Contact Us

Related Articles