make

Original source / Raw SKILL.md

---
name: make
description: "Make (formerly Integromat) automation platform — manage scenarios, trigger runs, monitor executions, manage connections, and handle data stores via the Make API. Build and manage visual automations, monitor execution logs, manage team resources, and trigger workflows. Built for AI agents — Python stdlib only, zero dependencies. Use for visual workflow automation, scenario management, execution monitoring, integration management, and no-code automation."
homepage: https://www.agxntsix.ai
license: MIT
compatibility: Python 3.10+ (stdlib only — no dependencies)
metadata: {"openclaw": {"emoji": "🔧", "requires": {"env": ["MAKE_API_KEY", "MAKE_ZONE"]}, "primaryEnv": "MAKE_API_KEY", "homepage": "https://www.agxntsix.ai"}}
---

# 🔧 Make (Integromat)

Make (formerly Integromat) automation platform — manage scenarios, trigger runs, monitor executions, manage connections, and handle data stores via the Make API.

## Features

- **Scenario management** — list, activate, deactivate scenarios
- **Trigger runs** — execute scenarios on demand
- **Execution logs** — monitor run history and status
- **Connection management** — view and manage app connections
- **Data store operations** — CRUD on data stores
- **Webhook management** — create and manage webhooks
- **Organization management** — teams and users
- **Template browsing** — discover scenario templates
- **Blueprint export** — export scenario definitions
- **Usage monitoring** — operations and data transfer stats

## Requirements

| Variable | Required | Description |
|----------|----------|-------------|
| `MAKE_API_KEY` | ✅ | API key/token for Make (Integromat) |
| `MAKE_ZONE` | ❌ | API zone (default: us1.make.com) |

## Quick Start

```bash
# List scenarios
python3 {baseDir}/scripts/make.py scenarios --limit 20
```

```bash
# Get scenario details
python3 {baseDir}/scripts/make.py scenario-get 12345
```

```bash
# Trigger a scenario run
python3 {baseDir}/scripts/make.py scenario-run 12345
```

```bash
# Activate a scenario
python3 {baseDir}/scripts/make.py scenario-activate 12345
```



## Commands

### `scenarios`
List scenarios.
```bash
python3 {baseDir}/scripts/make.py scenarios --limit 20
```

### `scenario-get`
Get scenario details.
```bash
python3 {baseDir}/scripts/make.py scenario-get 12345
```

### `scenario-run`
Trigger a scenario run.
```bash
python3 {baseDir}/scripts/make.py scenario-run 12345
```

### `scenario-activate`
Activate a scenario.
```bash
python3 {baseDir}/scripts/make.py scenario-activate 12345
```

### `scenario-deactivate`
Deactivate a scenario.
```bash
python3 {baseDir}/scripts/make.py scenario-deactivate 12345
```

### `executions`
List execution logs.
```bash
python3 {baseDir}/scripts/make.py executions --scenario 12345 --limit 20
```

### `execution-get`
Get execution details.
```bash
python3 {baseDir}/scripts/make.py execution-get exec_abc
```

### `connections`
List connections.
```bash
python3 {baseDir}/scripts/make.py connections --limit 20
```

### `data-stores`
List data stores.
```bash
python3 {baseDir}/scripts/make.py data-stores
```

### `data-store-records`
List data store records.
```bash
python3 {baseDir}/scripts/make.py data-store-records 789 --limit 50
```

### `webhooks`
List webhooks.
```bash
python3 {baseDir}/scripts/make.py webhooks
```

### `webhook-create`
Create a webhook.
```bash
python3 {baseDir}/scripts/make.py webhook-create '{"name":"My Hook"}'
```

### `organizations`
List organizations.
```bash
python3 {baseDir}/scripts/make.py organizations
```

### `users`
List team users.
```bash
python3 {baseDir}/scripts/make.py users
```

### `usage`
Get usage stats.
```bash
python3 {baseDir}/scripts/make.py usage
```


## Output Format

All commands output JSON by default. Add `--human` for readable formatted output.

```bash
# JSON (default, for programmatic use)
python3 {baseDir}/scripts/make.py scenarios --limit 5

# Human-readable
python3 {baseDir}/scripts/make.py scenarios --limit 5 --human
```

## Script Reference

| Script | Description |
|--------|-------------|
| `{baseDir}/scripts/make.py` | Main CLI — all Make (Integromat) operations |

## Data Policy

This skill **never stores data locally**. All requests go directly to the Make (Integromat) API and results are returned to stdout. Your data stays on Make (Integromat) servers.

## Credits
---
Built by [M. Abidi](https://www.linkedin.com/in/mohammad-ali-abidi) | [agxntsix.ai](https://www.agxntsix.ai)
[YouTube](https://youtube.com/@aiwithabidi) | [GitHub](https://github.com/aiwithabidi)
Part of the **AgxntSix Skill Suite** for OpenClaw agents.

📅 **Need help setting up OpenClaw for your business?** [Book a free consultation](https://cal.com/agxntsix/abidi-openclaw)


---

## Skill Companion Files

> Additional files collected from the skill directory layout.

### _meta.json

```json
{
  "owner": "aiwithabidi",
  "slug": "make",
  "displayName": "Make",
  "latest": {
    "version": "1.0.0",
    "publishedAt": 1772686354015,
    "commit": "https://github.com/openclaw/skills/commit/12cc10918ebf8615a004c9b90f61e6dc6108442d"
  },
  "history": []
}

```

### scripts/make.py

```python
#!/usr/bin/env python3
"""Make (Integromat) CLI — comprehensive API integration for AI agents.

Full CRUD operations, search, reporting, and automation.
Zero dependencies beyond Python stdlib.
"""

import argparse
import json
import os
import sys
import urllib.request
import urllib.error
import urllib.parse
from datetime import datetime, timezone

API_BASE = "https://{zone}.make.com/api/v2"


def get_token():
    """Get API token from environment."""
    token = os.environ.get("MAKE_API_KEY", "")
    if not token:
        env_path = os.path.join(
            os.environ.get("WORKSPACE", os.path.expanduser("~/.openclaw/workspace")),
            ".env"
        )
        if os.path.exists(env_path):
            with open(env_path) as f:
                for line in f:
                    line = line.strip()
                    if line.startswith("MAKE_API_KEY="):
                        token = line.split("=", 1)[1].strip().strip('"').strip("'")
                        break
    if not token:
        print(f"Error: MAKE_API_KEY not set", file=sys.stderr)
        sys.exit(1)
    return token


def api(method, path, data=None, params=None):
    """Make an API request."""
    token = get_token()
    url = f"{API_BASE}{path}"
    if params:
        qs = urllib.parse.urlencode({k: v for k, v in params.items() if v is not None})
        if qs:
            url = f"{url}?{qs}"
    body = json.dumps(data).encode() if data else None
    req = urllib.request.Request(url, data=body, method=method)
    req.add_header("Authorization", f"Bearer {token}")
    req.add_header("Content-Type", "application/json")
    req.add_header("Accept", "application/json")
    try:
        resp = urllib.request.urlopen(req, timeout=30)
        raw = resp.read().decode()
        return json.loads(raw) if raw.strip() else {"ok": True}
    except urllib.error.HTTPError as e:
        err_body = e.read().decode()
        print(json.dumps({"error": True, "code": e.code, "message": err_body}), file=sys.stderr)
        sys.exit(1)


def output(data, human=False):
    """Output data as JSON or human-readable."""
    if human and isinstance(data, list):
        for item in data:
            if isinstance(item, dict):
                for k, v in item.items():
                    print(f"  {k}: {v}")
                print()
            else:
                print(item)
    elif human and isinstance(data, dict):
        for k, v in data.items():
            print(f"  {k}: {v}")
    else:
        print(json.dumps(data, indent=2, default=str))


def cmd_scenarios(args):
    """List scenarios."""
    params = {}
    if hasattr(args, 'limit') and args.limit:
        params["limit"] = args.limit
    if hasattr(args, 'id') and args.id:
        data = api("GET", f"/scenarios/{args.id}")
    else:
        data = api("GET", "/scenarios", params=params)
    output(data, getattr(args, 'human', False))

def cmd_scenario_get(args):
    """Get scenario details."""
    params = {}
    if hasattr(args, 'limit') and args.limit:
        params["limit"] = args.limit
    if hasattr(args, 'id') and args.id:
        data = api("GET", f"/scenario/{args.id}")
    else:
        data = api("GET", "/scenario/get", params=params)
    output(data, getattr(args, 'human', False))

def cmd_scenario_run(args):
    """Trigger a scenario run."""
    params = {}
    if hasattr(args, 'limit') and args.limit:
        params["limit"] = args.limit
    if hasattr(args, 'id') and args.id:
        data = api("GET", f"/scenario/{args.id}")
    else:
        data = api("GET", "/scenario/run", params=params)
    output(data, getattr(args, 'human', False))

def cmd_scenario_activate(args):
    """Activate a scenario."""
    params = {}
    if hasattr(args, 'limit') and args.limit:
        params["limit"] = args.limit
    if hasattr(args, 'id') and args.id:
        data = api("PUT", f"/scenario/{args.id}")
    else:
        data = api("PUT", "/scenario/activate", params=params)
    output(data, getattr(args, 'human', False))

def cmd_scenario_deactivate(args):
    """Deactivate a scenario."""
    params = {}
    if hasattr(args, 'limit') and args.limit:
        params["limit"] = args.limit
    if hasattr(args, 'id') and args.id:
        data = api("PUT", f"/scenario/{args.id}")
    else:
        data = api("PUT", "/scenario/deactivate", params=params)
    output(data, getattr(args, 'human', False))

def cmd_executions(args):
    """List execution logs."""
    params = {}
    if hasattr(args, 'limit') and args.limit:
        params["limit"] = args.limit
    if hasattr(args, 'id') and args.id:
        data = api("GET", f"/executions/{args.id}")
    else:
        data = api("GET", "/executions", params=params)
    output(data, getattr(args, 'human', False))

def cmd_execution_get(args):
    """Get execution details."""
    params = {}
    if hasattr(args, 'limit') and args.limit:
        params["limit"] = args.limit
    if hasattr(args, 'id') and args.id:
        data = api("GET", f"/execution/{args.id}")
    else:
        data = api("GET", "/execution/get", params=params)
    output(data, getattr(args, 'human', False))

def cmd_connections(args):
    """List connections."""
    params = {}
    if hasattr(args, 'limit') and args.limit:
        params["limit"] = args.limit
    if hasattr(args, 'id') and args.id:
        data = api("GET", f"/connections/{args.id}")
    else:
        data = api("GET", "/connections", params=params)
    output(data, getattr(args, 'human', False))

def cmd_data_stores(args):
    """List data stores."""
    params = {}
    if hasattr(args, 'limit') and args.limit:
        params["limit"] = args.limit
    if hasattr(args, 'id') and args.id:
        data = api("GET", f"/data/{args.id}")
    else:
        data = api("GET", "/data/stores", params=params)
    output(data, getattr(args, 'human', False))

def cmd_data_store_records(args):
    """List data store records."""
    params = {}
    if hasattr(args, 'limit') and args.limit:
        params["limit"] = args.limit
    if hasattr(args, 'id') and args.id:
        data = api("GET", f"/data/{args.id}")
    else:
        data = api("GET", "/data/store/records", params=params)
    output(data, getattr(args, 'human', False))

def cmd_webhooks(args):
    """List webhooks."""
    params = {}
    if hasattr(args, 'limit') and args.limit:
        params["limit"] = args.limit
    if hasattr(args, 'id') and args.id:
        data = api("GET", f"/webhooks/{args.id}")
    else:
        data = api("GET", "/webhooks", params=params)
    output(data, getattr(args, 'human', False))

def cmd_webhook_create(args):
    """Create a webhook."""
    params = {}
    if hasattr(args, 'limit') and args.limit:
        params["limit"] = args.limit
    if hasattr(args, 'id') and args.id:
        data = api("POST", f"/webhook/{args.id}")
    else:
        data = api("POST", "/webhook/create", params=params)
    output(data, getattr(args, 'human', False))

def cmd_organizations(args):
    """List organizations."""
    params = {}
    if hasattr(args, 'limit') and args.limit:
        params["limit"] = args.limit
    if hasattr(args, 'id') and args.id:
        data = api("GET", f"/organizations/{args.id}")
    else:
        data = api("GET", "/organizations", params=params)
    output(data, getattr(args, 'human', False))

def cmd_users(args):
    """List team users."""
    params = {}
    if hasattr(args, 'limit') and args.limit:
        params["limit"] = args.limit
    if hasattr(args, 'id') and args.id:
        data = api("GET", f"/users/{args.id}")
    else:
        data = api("GET", "/users", params=params)
    output(data, getattr(args, 'human', False))

def cmd_usage(args):
    """Get usage stats."""
    params = {}
    if hasattr(args, 'limit') and args.limit:
        params["limit"] = args.limit
    if hasattr(args, 'id') and args.id:
        data = api("GET", f"/usage/{args.id}")
    else:
        data = api("GET", "/usage", params=params)
    output(data, getattr(args, 'human', False))


COMMANDS = {
    "scenarios": cmd_scenarios,
    "scenario-get": cmd_scenario_get,
    "scenario-run": cmd_scenario_run,
    "scenario-activate": cmd_scenario_activate,
    "scenario-deactivate": cmd_scenario_deactivate,
    "executions": cmd_executions,
    "execution-get": cmd_execution_get,
    "connections": cmd_connections,
    "data-stores": cmd_data_stores,
    "data-store-records": cmd_data_store_records,
    "webhooks": cmd_webhooks,
    "webhook-create": cmd_webhook_create,
    "organizations": cmd_organizations,
    "users": cmd_users,
    "usage": cmd_usage,
}


def main():
    parser = argparse.ArgumentParser(
        description="Make (Integromat) CLI — AI agent integration",
        formatter_class=argparse.RawDescriptionHelpFormatter,
    )
    parser.add_argument("command", choices=list(COMMANDS.keys()), help="Command to run")
    parser.add_argument("args", nargs="*", help="Command arguments")
    parser.add_argument("--human", action="store_true", help="Human-readable output")
    parser.add_argument("--limit", type=int, help="Limit results")
    parser.add_argument("--id", help="Resource ID")
    parser.add_argument("--from", dest="from_date", help="Start date")
    parser.add_argument("--to", dest="to_date", help="End date")
    parser.add_argument("--status", help="Filter by status")
    parser.add_argument("--sort", help="Sort field")
    parser.add_argument("--query", help="Search query")

    parsed = parser.parse_args()
    cmd_func = COMMANDS[parsed.command]
    cmd_func(parsed)


if __name__ == "__main__":
    main()

```