Meet ScriptRunner Connect

Companies have a lot of products in their toolstack, each with unique features that help different parts of the business run smoothly. Having so many services can create problems with visibility, workflows, and communication.

Setting up integrations between tools helps teams share data and manage their work across different services. Data can move automatically from one service to another, keeping all systems in sync.

Integration 101

Several actions happen when data flows between services.

Let’s look at an example: an integration set up between Jira and monday.com.

When an item is created on a Jira board, that item should be created on a monday.com board.

Service Generates an Event: When a Jira issue is created in a specific project, an event is generated.
Event Listener Captures and Processes the Event: A custom-built event listener monitors Jira. When an issue is created in the specified project, the event listener captures this event and processes it, parsing the event data and determining the necessary actions to take.
Data Actioning: The script processes and transforms the event data into monday.com’s required format and sends it to monday.com.
Target Service Processes the Data: monday.com receives the data and creates a corresponding item on a specific board.

(This is a simplified example - there are actions that take place after the item is created, such as responding and logging.)

API connections

To connect with services, the script interacts with the service’s API - a set of rules and protocols that allows different software applications to communicate with each other.

The script includes code to establish a connection with the service’s API endpoints.

Each API has its own unique access requirements, which may include different authentication methods, permissions, and data formats.

Using Middleware

Tools like Make or Zapier make integration less complex, and accessible to every user.

Middleware tools provide pre-configured elements, allowing users to automate tasks without any scripting experience. Users can select components using dropdown menus and create integrations using If / Then logic.

These tools often lack the customization options needed for complex use cases. For advanced scripts, developers are on their own.

Solving the Pain Points

ScriptRunner Connect addresses several major challenges for developers - including the complexities of API setup and authentication.

API Configuration: When working with APIs, developers must navigate their unique specifications, which requires a deep understanding of each service's documentation. Services frequently update their APIs, introducing new features, deprecating old ones, or modifying existing functionalities. Developers need to monitor and adjust the code to maintain compatibility and functionality.

Authentication: Hardcoding credentials within scripts is not an ideal practice, as it poses significant security risks and makes maintenance more challenging.

Every update to APIs or credentials requires altering every script that uses them.

These factors can make creating and maintaining integrations difficult and labor-intensive.

The best of both worlds

Scriptrunner Connect provides some of the benefits of middleware while still allowing for complex scripting.

It isolates key components from a script into specific elements that can be configured and reused across scripts.
It also provides managed APIs to help developers create and update scripts more quickly.

How it works

ScriptRunner Connect integrations always involve a connector, a trigger, and a script.

Connectors

Instead of hard-coding your API details into your script, you can set up a connector.

You can use this connector to import all the API details into any script using that connector.

Authentication details are isolated within the connector, so you can update them in one place.

Triggers

Similar to connectors, you can set up triggers as separate components. Isolating event-handling logic can make scripts cleaner and easier to maintain.

Scripts

Separating the connectors and triggers makes the code cleaner and quicker to update. Developers can focus on the core logic without worrying about the underlying connection details.

Managed APIs

ScriptRunner Connect simplifies integrating and automating workflows by providing Managed APIs—predefined API endpoints you can access and utilize within your scripts and automation.

Streamlined connection

Managed APIs simplify the connection and authentication process.

Instead of sifting through extensive documentation, managed connectors guide you through the authentication process step by step.
The product team at ScriptRunner Connect keeps these managed APIs up-to-date, ensuring they align with any changes in service requirements.

Quicker development

Managed APIs contain the common actions and endpoints for a service, simplifying the integration process by providing predefined, reusable components.

When you set up a trigger, you'll have options for common use cases, making it easier to set up your workflows.
When you’re creating a script, the code editor will provide helpful suggestions specific to the options available for each service.

While the benefits of Managed APIs are great, if the service you’re trying to connect to doesn’t have a Managed API available, ScriptRunner Connect still offers flexible solutions.

To sum up…

ScriptRunner Connect makes it easier for developers to create and maintain custom scripts by addressing the complexities of API setup and authentication. By leveraging its elements and managed APIs, businesses can streamline their integration processes and ensure that all systems remain in sync and operate smoothly.