Hello everyone,
I have several integrations, developed as an app. Some are just actions, others are just recipes I have created. They are connected on different boards, my aim is to be able to duplicate these integrations via API, with the configuration already set, in many boards. It seems to me that via API you can’t retrieve them (with configuration included). Is there a way to do this? Thank you
Based on the current information, including recent discussions in the monday.com community:
The Core Problem:
- You generally cannot directly retrieve the configuration of an existing monday com integration via the API. The API allows you to interact with boards, items, columns, users, and even manage some app-related aspects, but it doesn’t provide a direct way to “read” the detailed setup of an integration recipe (e.g., which columns are mapped, specific values used in the recipe, etc.).
- When you duplicate a board, built-in automations and some integrations might get copied, but often in a “ghost” state or without full configuration. Integrations from apps are even less likely to carry over with their full, pre-configured settings, especially if they require external authentication or specific URLs. This is because integrations are often tied to the specific Board ID.
Why this is the case:
- Integrations, especially those developed as apps with custom recipes, involve specific connections and configurations that can be complex. Exposing all these details via a generic API for retrieval and duplication isn’t straightforward and could have security or architectural implications.
- The setup often involves third-party authentication or specific mappings that are dynamic and board-dependent.
Is there a way to do this? (Workarounds and Considerations)
Given the limitations of directly duplicating fully configured integrations via the API, here are some potential approaches, ranging from less dog whistles
ideal to more programmatic, depending on the complexity of your integrations:
- Manual Re-configuration (Least Ideal for Many Boards):
- If the number of boards is manageable, the most straightforward (though manual) approach is to duplicate the board and then manually re-configure the integrations on each new board. This is likely what you’re trying to avoid.
- Board Templates with Manual “Re-activation”:
- monday.com’s board templates do copy over some automations and built-in integrations, but as mentioned, they might be in a “ghost” state or require re-adding/re-authorizing. This can reduce some of the manual work, but won’t eliminate it entirely for complex app integrations.
- Programmatic Creation of Integrations (More Complex, but Powerful):
- This is likely your best bet for true “duplication with configuration” via API, but it requires you to re-create the integration from scratch using API calls rather than simply copying an existing one.
- How it works:
- Identify the Integration Recipe: You’ll need to know the specific recipe ID or the logic of the integration you want to create (e.g., “When status changes to X, create an item in board Y with Z columns mapped”).
- Use the monday com API to create new integration recipes: The monday com API allows you to create automations and potentially some integration recipes programmatically. You would need to use mutations like
create_automation_recipe or similar calls relevant to your app’s integrations.
- Store Configuration Data: Since you can’t retrieve the configuration, you would need to store the configuration details of your integrations outside of monday com (e.g., in a database, a JSON file, or even hardcoded in your application). This configuration would include:
- Board IDs involved (source and destination)
- Column IDs involved
- Specific values or conditions (e.g., status labels, text to insert)
- Any third-party authentication details (if your custom app integrations require them). Be extremely careful with storing sensitive data.
- Loop through Boards: For each new board you create (or existing board you want to add the integration to), your script would iterate and use the stored configuration data to make the necessary API calls to set up the integration on that specific board.
- Custom Apps and Webhooks: If your integrations are developed as monday com apps with custom triggers/actions/recipes, you’ll be using your app’s backend to handle the logic. When a new board is created, you might have a process that tells your app to “activate” or create the necessary integration recipes on that board, passing in the relevant board and column IDs. You can leverage the monday com API’s ability to create webhooks to trigger actions in your external system when certain events occur on a board.
Key API Calls to Look Into (Conceptual):
create_automation_recipe: While primarily for automations, some integrations are built upon this. You’d need to explore the specific syntax for your integration types.- Your App’s API: If these are integrations you developed as a monday com app, your app’s backend would be responsible for receiving requests (e.g., from a new board being created) and then using the monday com API to register or activate your custom integration recipes on that board. This would involve knowing the recipe structure your app provides.
Challenges with Programmatic Creation:
- Complexity: This approach is significantly more complex than simple duplication, as you are essentially building a system to manage and deploy your integrations.
- Maintaining Configuration: You need a robust way to store and manage the configuration for each integration type.
- Error Handling: You’ll need to handle potential errors during API calls (e.g., rate limits, invalid IDs).
- Authentication: If your integrations involve third-party services, you’ll need to manage their authentication within your programmatic flow.
Recommendation:
If your integrations are custom apps you’ve developed:
- Focus on your app’s ability to provision or activate these integrations on new boards. When a new board is created, consider a mechanism (e.g., a webhook from monday com to your app, or a user action within your app) that triggers your app to set up the necessary integration recipes on that board using monday com’s API.
- Design your app’s recipes to be configurable with Board and Column IDs as parameters. This way, your app can generate the correct API calls for each new board.
Unfortunately, a simple “duplicate integration with configuration” API endpoint doesn’t seem to exist. The path forward involves either manual re-creation or building a more sophisticated programmatic solution to deploy your integrations based on their defined configurations.
Hi Alison, thanks for your response. Could you link me the documentation for the create_automation_recipe mutation?