> For the complete documentation index, see [llms.txt](https://docs.getint.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.getint.io/getting-started-with-the-platform/about-getint-concepts/what-are-runs.md).

# What are Runs?

In the Getint platform, a "Run" is a critical operation in the synchronization process between connected tools. Here's an extended explanation, including how each Run is recorded and logged.

### Initiating Synchronization:

A Run occurs when Getint sends API requests to connected collaboration tools. These requests aim to gather data on all newly created items and their respective fields, as well as any recent updates, as defined in the integration setup.

### How Run Intervals Affect Your Integration

Integrations execute sequentially, meaning each one must finish before the next can begin. This sequence is essential for understanding how often integrations can run.

For example, Jira Cloud users can set a minimum run interval of 3 minutes, while Data Center customers have a range between 60 to 120 seconds (primarily 120 seconds). However, On-Premise users can set run intervals starting from 0 seconds.

When setting an interval for integration (like every 15 seconds), remember that this doesn't guarantee the integration will occur exactly at that interval. The actual frequency depends on various factors, such as the total number of integrations and the time each one takes to complete.

### Detection and Integration of Changes:

Getint actively searches for new items or changes in existing items during a Run. Detection is based on the **last modified time** of each item. When Getint queries both applications, it asks for items whose last modified time is newer than the previous Run, and it fetches and processes those items.

This has a direct consequence: a Run only picks up items that carry a newer last modified time. If nothing in the item changed, the item is not fetched, even if it was part of a previous Run.

### Handling Concurrent Changes:

The last modified time also decides the outcome when the same item changes on both sides between Runs. Getint compares the last modified time of the item and its counterpart, and the more recently modified one becomes the trigger. Its values are then written to the counterpart.

In practice, this means the latest change wins. In a bidirectional integration, if two teams edit the same item or the same field before Getint picks the change up, the later edit is applied, and the earlier one is replaced.

To avoid overwriting work, consider the following:

* **Align the teams involved**: agree on which tool owns which fields, so the same field is not being edited on both sides at the same time.
* **Use integration filters**: restrict which items enter the integration, so edits made outside the agreed scope never reach the counterpart. See [Filtering Items for Integration in Getint](https://docs.getint.io/getintio-platform/workflows/filtering-items-for-integration-in-getint).
* **Use one-way field mappings**: for fields that should only ever travel in one direction, map them one-way instead of two-way, so changes on the receiving side are never sent back.

### Recording and Logging of Runs:

Every Run is meticulously recorded and logged within Getint. This means that users have the ability to review and analyze the actions taken during each Run.

The logs provide valuable insights into the outcomes of each synchronization process. They are an essential tool for users to easily identify and understand any errors or discrepancies that may occur. When a value is not what you expected, the logs show which side was modified later and which item was used as the trigger for that update.

### Maintaining Data Integrity and Continuity:

Regular Runs are essential for maintaining data integrity and continuity across different platforms. They keep all integrated systems reflecting the latest and most accurate data.

In summary, a Run in Getint is not only a process of querying and integrating data but also involves a comprehensive recording and logging mechanism. This feature allows users to monitor, analyze, and troubleshoot the synchronization process, with full transparency and control over data integration across their collaboration tools.

<figure><img src="https://4106311246-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MR6Z9V8zLATPQPOGSDf%2Fuploads%2F9OSEDBl869gRue9mQAwv%2FGetint%20Yellow%20Banner.png?alt=media&amp;token=9cc42142-6e48-4931-8fd5-cbf7dcf4cdc1" alt=""><figcaption><p><a href="https://calendly.com/d/cpws-jb2-8xx/demo-call-all-team
">Start your integration journey. Schedule a free consultation with our Getint Integration Expert today!</a></p></figcaption></figure>


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.getint.io/getting-started-with-the-platform/about-getint-concepts/what-are-runs.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
