Integrations

DRAGOPS provides two ways to integrate with external services. Integration packs offer pre-built nodes that handle authentication, request formatting, and response parsing automatically. Manual integrations use HTTP Request and JSON nodes for full control over every detail. Both approaches produce the same result at execution time — pack nodes generate the same HTTP calls you would wire by hand.

How integrations work

In DRAGOPS, every integration is a pattern. Whether you use a pre-built pack node or wire HTTP Request nodes manually, the execution engine makes standard HTTP calls to external APIs. This design gives you four advantages:

• Full visibility. Open any integration and see exactly what API calls it makes, what headers it sends, and how it handles errors.
• Full control. Modify any part of the integration to fit your exact use case. Add custom headers, change retry logic, transform payloads differently, or combine multiple API calls into a single pattern.
• No update lag. When a service adds a new API endpoint, you can use it immediately. You do not need to wait for an update.
• Pre-built convenience. For services with an integration pack, you get ready-to-use nodes that eliminate repetitive wiring. One node replaces five.

Integration packs

Integration packs provide pre-built nodes for popular services. Each pack bundles authentication configuration, typed action nodes, and response mapping into a single portable package. You configure a connection for the service, then drag pack nodes onto the canvas.

For example, the VirusTotal pack provides a Get IP Report node. Instead of wiring Get Secret + Set Property + Format URL + HTTP Request + Get Property, you place one node, wire an IP address to its input, and read the report from its output.

To learn how packs work under the hood, see Integration packs in the concepts section.

Choose your approach

Manual integration building blocks

For services without a pack, or when you need full control, build integrations manually with these core nodes:

With these nodes, you can integrate with any service that exposes an HTTP API.

Build a manual integration

The general approach for any manual integration follows two patterns: sending data out and receiving data in.

Sending data to an external service

1. Build the request headers using Set Property nodes (authentication, content type).
2. Build the request body using Set Property and JSON Stringify nodes.
3. Use HTTP Request to call the service's API endpoint.
4. Parse the response with JSON Parse and extract the fields you need with Get Property.
5. Use Branch to check the status code and handle success and failure paths.

Receiving events from an external service

1. Add an On Webhook trigger to your pattern. DRAGOPS assigns a stable webhook URL immediately.
2. Register that URL in the external service's webhook settings.
3. Use Get Property to extract fields from the incoming payload.
4. Process the event and take action — call APIs, send messages, update data.
5. Optionally use Respond To Webhook to return a custom response.

Storing credentials safely

Use connections to store API keys, OAuth tokens, and other credentials securely. Connections encrypt credentials at rest and inject them automatically when your pattern executes. See Connect external services for setup instructions.

For services without a built-in connection type, use secrets to store API keys and reference them in your patterns.

Service-specific guides

These guides walk through complete integration examples for popular services:

Related

• Integration packs -- how packs work, what they contain, and when to use them
• Use integration pack nodes -- step-by-step guide for using pack nodes
• Make HTTP requests -- outbound HTTP calls with authentication and response handling
• Webhooks -- webhook URLs, tap mode, and HMAC validation
• Work with JSON -- parse, extract, and build JSON data
• Connect external services -- credential storage and the connections system
• Send custom webhook responses -- return data to webhook callers