Updated on by Susanna Fagerholm
Effective integrations often need a reliable place to store data, whether temporarily within a single Cycle or persistently across multiple Cycles. Cyclr offers four data storage connectors for that need: Global Data Storage, Global Object Storage, Cycle Data Storage, and Cycle Object Storage. They’re built for structure, speed, and flexibility, helping businesses manage the internal logic of their integration workflows without relying on external systems.
These utility connectors are lightweight, easy to install, and can boost integrations by storing values directly in Cyclr. Each one offers its own strengths depending on how and where the data needs to be stored.
Storage Connectors in Context
There are a few common needs that the Data Storage Connectors can help with:
- Holding state between steps in a Cycle
- Persisting data between multiple Cycles within an Account
- Avoiding redundant API calls by caching intermediate results
- Creating internal reference points, such as tracking the last processed item
- Temporarily storing structured data objects mid-cycle
All four connectors organize information in key/value pairs. Keys can be up to 128 characters, values up to 50,000 characters, and every installed instance can hold up to 1 million items.
Global vs. Cycle Storage: Choosing the Right Scope
The most effective way to decide between these four connectors is to consider two factors: the scope of access needed and the structure of the data that will be stored.
To determine which storage connector to go with, answer these two quick questions:
- Where is the data needed?
- One Cycle → choose a Cycle-scoped connector.
- Any Cycle in the account → choose a Global-scoped connector.
- How many properties are needed behind each key?
- Exactly one → choose a Data Storage connector.
- Multiple related properties → choose an Object Storage connector.
For example, when storing a single value that multiple integrations rely on, Global Data Storage is the simplest and most efficient choice. However, when capturing structured configuration or user data that will be referenced across integrations, Global Object Storage is a better match.
Similarly, for temporary storage of a single value within one Cycle, Cycle Data Storage works well. But when moving structured objects around within a Cycle, Cycle Object Storage provides more control and clarity.
| Connector | Scope | Data Model |
|---|---|---|
| Global Data Storage | Account | Single value |
| Global Object Storage | Account | Multi-field object |
| Cycle Data Storage | Single Cycle | Single value |
| Cycle Object Storage | Single Cycle | Multi-field object |
Global Data Storage: Persistent Key/Value Pairs Across Cycles
Global Data Storage keeps simple key/value pairs for as long as is needed, across Cycles and across time. Because it sits at the account level, any Cycle in the same account can read or modify the data, making it ideal for managing small but important pieces of information across multiple workflows.
Common uses include tracking a last sync timestamp, storing configuration flags or tokens that multiple integrations rely on, and caching static reference data that changes infrequently.
Global Object Storage: Persisting Structured Data Across Cycles
The Global Object Storage connector is a better fit for scenarios that require more than a single value per entry. It allows users to save structured data in the form of JSON objects, using a unique key to associate multiple fields (like a name, email address, and timestamp) with a single record.
Global Object Storage is often used to store complex data sets that need to be accessed across multiple Cycles. It can reduce reliance on external systems for reusable reference data. So instead of pulling the same information repeatedly from an API, the object can be stored and accessed quickly from within Cyclr.
Cycle Data Storage: Temporary Key/Value Pairs for In-Cycle Use
Some integrations only need to hold onto data briefly, just long enough to use it again in the same Cycle. The Cycle Data Storage allows users to save temporary values during a Cycle run. The data is stored and remains accessible by the Cycle until it’s deleted using the available methods.
Common use cases for the Cycle Data Storage Connector include holding a value returned by an API, reusing a calculated result later in the flow, or performing quick comparisons without making another call. For instance, tracking temporary IDs or checking for duplicate entries mid-flow.
Data written to the Cycle Data Storage Connector is visible only to the Cycle that created it; other Cycles never see or overwrite it. Once the Cycle finishes, the values still exist, but only that Cycle can reach them on its next run.
Cycle Object Storage: In-Cycle Temporary Storage for Structured Data
The Cycle Object Storage connector provides a more structured solution for situations where temporary data includes multiple fields per entry. It works similarly to the Global Object Storage connector but limits the scope to the current Cycle run. All stored data remains accessible by the Cycle until it’s deleted using the available methods.
This connector is particularly useful for holding structured responses from an API, transforming them, and referencing the transformed data later in the same flow. It also helps reduce redundancy by storing interim results or objects so that they do not need to be fetched or calculated more than once. In the same fashion as with the global version, the Cycle Object Storage can be used to define and later modify a list of fields, and store each set of values under a unique key.
Because it mirrors the features of Global Object Storage, this connector is well-suited for more advanced logic inside complex Cycles, especially when branching paths all rely on the same base data.
Shared Capabilities
All four connectors share a common set of operations:
- Set a Value or Add/Update Entry (upsert behavior)
- Get a Value or Get All Entries
- Append to a Value (simple Key/Value only)
- Delete a Key
- Delete All Keys/Entries
The only constraint to keep in mind is the item limit. Each connector instance can store up to 1,000,000 items, whether that’s keys or objects. Obviously, for Cycle-level storage, this limit is per Cycle; for Global storage, it’s per Connector instance across the Account.
Best Practices
When using storage connectors in Cyclr, a few best practices can help maintain clarity and avoid data sprawl.
- Name every instance clearly. Builder displays the instance name in mapping dialogs. Labels such as “Cycle Scratchpad” or “Global Currency Rates” reduce confusion during maintenance.
- Watch count limits, and plan for cleanup. Each connector instance tops out at one million records. For high-volume integrations, plan periodic clean-ups with Delete All Keys, or design logic that rolls keys forward to new instances.
- Use Append Value sparingly. Long concatenated strings can approach the 50,000-character limit surprisingly quickly. For heavy accumulation, consider storing an array in JSON form instead.
Want to see Cyclr in action?
Book a demo with one of our integration experts to see Cyclr in action and how you could use our embedded iPaaS to enhance your commerce stack!
Use Case: Building a Composable Commerce Integration Stack
Our Technical Advocate Wilson put the Global Object Storage Connector to use in a recent demo focused on building a composable commerce stack.
Wilson uses the Global Object Storage to store filtered customer data pulled from Oracle NetSuite, forming the basis for a dynamic promotion list. This list powered targeted email and CRM campaigns via ActiveCampaign and HubSpot, with structured storage enabling segmentation, cleanup automation, and behavior-based triggers.
Conclusion
Cyclr’s Data Storage connectors offer a powerful toolset for managing state, caching, and controlling data flow within and across integrations.
They allow users to keep a simple value available for future Cycles, manage a complex data structure within a single run, or centralize reusable settings, all without relying on external systems. Choosing the right connector for each scenario helps keep integrations tidy, reliable, and easy to update as requirements evolve.
