How to integrate AI APIs in Make (formerly Integromat) using CometAPI?

One of the most effective ways to bring AI capabilities into everyday business processes is by integrating AI APIs into workflow automation platforms. Make (formerly Integromat) is one such platform, offering a powerful, no-code environment for building complex automation scenarios. When paired with CometAPI, a pre-built Make app designed to simplify AI API usage, businesses can harness AI without dealing with complex API management overhead. We are excited to announce that CometAPI is now available on the no-code platform Make (formerly Integromat).

This article provides a detailed, step-by-step guide on integrating AI APIs into Make using CometAPI, complete with explanations, use cases, and code examples for advanced scenarios.

What is Make (formerly Integromat)?

Make is a visual automation and integration platform (formerly Integromat) that lets you create “scenarios” — drag-and-drop workflows made of triggers and modules — to move data between apps, call APIs, and automate business processes. It supports thousands of pre-built apps and provides HTTP / API modules, scheduling, error handling, multi-branch logic, and built-in AI tooling (Make AI Apps and Agents). Make is designed for non-developers while retaining advanced capabilities for technical teams (JSON mapping, iterators, routers, and webhooks).

Which Make features are most useful when integrating AI?

• Scenario Builder & visual flow editor — design and test multi-step flows visually.
• Pre-built app modules — e.g., CometAPI appears as a first-class app with actions like Create a Chat, Generate text, Analyze image, and Create an API Call.
• HTTP / Create API Call module — when no pre-built action exists, use it to call any REST API.
• Mapping, filters, and iterators — map outputs from AI calls into downstream systems (Sheets, CRMs, ticketing).
• Security & governance — enterprise features like SSO, SOC2/GDPR compliance, and centralized connection management.

What is CometAPI and why use it as your unified AI endpoint?

CometAPI is an API aggregation layer that exposes many (500+ advertised) AI models behind a single, OpenAI-style interface. Instead of writing custom code for each provider (OpenAI, Google Gemini, Anthropic, Suno, etc.), you call CometAPI and choose the model you want in a single request. That simplifies model switching, billing, and key management. CometAPI’s docs explicitly recommend using an OpenAI-compatible format and a custom base_url (https://api.cometapi.com) for easy migration.

What CometAPI provides, in short:

• Unified single API key and unified billing across multiple underlying model providers.
• An OpenAI-compatible request pattern (so many OpenAI client libraries work with only a base_url change).
• A model catalog (text, image, video, audio, etc.) so you can pick specialized models for each job.

This makes CometAPI especially convenient when you’re wiring AI into Make: you can use either the CometAPI pre-built Make app (no coding) or Make’s HTTP module to call CometAPI directly with JSON.

To obtain your CometAPI key—which you’ll need to use CometAPI modules in Make (formerly Integromat)—follow these steps:

---

How to Get a CometAPI Key

To obtain your CometAPI key—which you’ll need to use CometAPI modules in Make (formerly Integromat)—follow these steps:

1. Sign Up or Log In to CometAPI

• Visit cometapi.com and sign up for an account (many users mention you can get a key instantly) .
• If you already have an account, simply log in to proceed.

2. Navigate to Your API Token Section

• After logging in, access your Personal Center or dashboard.
• Look for the API token section. There should be an “Add Token” button or similar option to generate a new key.

3. Generate and Copy the Key

• Click “Add Token” to create a token. The key typically appears in a format like sk-xxxxx.
• Copy this key to your clipboard—it will serve as your CometAPI authentication token .

4. Use the Key in Make or Your Application

• In Make, use this API key when configuring the CometAPI module (e.g., Create a Chat, Create an API Call).
• If you’re writing code (e.g., in Python), you might do something like:

client = OpenAI(
    base_url="https://api.cometapi.com/v1",
    api_key="sk-xxxxx",  # Replace with your actual API key
)

How to Use the CometAPI prebuilt module in Make?

Make provides pre-built CometAPI app modules (e.g., Create a Chat, Create an API Call, List Models, Upload File) that you can drop into your scenario. Your supplied steps are a great baseline; After loging Make.com, here’s a refined, production-oriented version:

Quick refined steps

1. Select Create scenario.
2. Click + to add a module and search for CometAPI (it’s a verified Make app).
3. Choose the appropriate module , Create an API Calland click Add.
4. Authorize your CometAPI key in the connection dialog (paste your CometAPI Bearer key from the CometAPI dashboard). Make stores this securely for the scenario.
5. Configure the action fields: choose a model, set prompt or messages, tune temperature, max_tokens or other provider-specific fields. For file/image generation, upload files first and then reference them.
6. Add error-handling: use Make’s error handlers and route for retry/backoff or fallback model calls if the first model fails.

Below we expand each step, show picture guide, and explain practical mapping inside Make.

Now let’s walk step-by-step through integrating AI APIs into Make using CometAPI.

---

Step 1: Set Up Your Make Account

1. Go to Make.com and create a free account.
2. Once logged in, create a new scenario.

Step 2: Add CometAPI to Your Scenario

1. In your scenario, click the + button to add a new module.
2. Search for CometAPI in the app directory.
3. Select the CometAPI module relevant to your use case (e.g., Text Completion, Sentiment Analysis, or Custom API Call).

Step 3: Configure CometAPI Module

Each CometAPI module requires basic configuration:

• API Key: Create an API call, then enter the key you obtained from cometapi and click Save.
• Fill in the endpoint you want to use as shown in the image, such as /v1/chat/completions, choose POST as the method; and enter your parameters in the following format.
• Finally, click Save and Run once to successfully test.

If the call is successful, you will receive a corresponding translation reply; if it fails, check if the configuration is correct or contact cometapi online customer service.

Make maps your form fields into {{Form.field_question}} style tokens; the CometAPI module handles authorization and returns a standard JSON response you can map onward.

What Are Some Example Scenarios?

Let’s explore some scenarios with context-specific code examples where CometAPI is used in Make.

---

Scenario 1: Summarizing Emails and Sending Alerts

Goal: Automatically summarize new emails in Gmail and send the summaries to Slack.

Workflow Steps

1. Gmail: Watch for new emails.
2. CometAPI: Summarize email content.
3. Slack: Send the summary to a channel.

Example Configuration in CometAPI

{
  "task": "summarize",
  "input": "Dear Support, I am facing an issue with my account login. I tried resetting my password but still cannot access my dashboard. Can you assist?",
  "max_length": 100
}

Output:
“Customer reports login issue despite password reset. Requests support assistance.”

---

Scenario 2: Classifying Customer Feedback

Goal: Classify incoming feedback from a Google Form into categories (Positive, Negative, Neutral) using AI.

Workflow Steps

1. Google Forms/Sheets: Watch new form responses.
2. CometAPI: Run sentiment analysis.
3. Google Sheets: Append the classification result.

Example Configuration in CometAPI

{
  "task": "sentiment-analysis",
  "input": "The checkout process was smooth, but delivery was late."
}

Output:

{
  "sentiment": "Mixed",
  "confidence": 0.87
}

---

Scenario 3: AI-Generated Social Media Posts

Goal: Create AI-generated posts based on blog titles and schedule them automatically.

Workflow Steps

1. RSS Feed: Watch for new blog posts.
2. CometAPI: Generate a LinkedIn post draft.
3. Buffer / Social Scheduler: Publish the post.

Example Configuration in CometAPI

{
  "task": "generate",
  "prompt": "Write a professional LinkedIn post about the blog title: '5 Ways AI is Transforming Healthcare'. Limit to 200 words."
}

Output (AI-generated post):
“AI is revolutionizing healthcare by improving diagnostics, enhancing patient care, and enabling predictive analytics. Here are 5 ways it’s reshaping the industry…”

What are best practices when using CometAPI in Make?

How do you manage costs, model selection, and performance?

• Model tiers: Use smaller models for trivial tasks (e.g., gpt-5-nano), larger models for heavy reasoning. CometAPI’s unified naming makes switching models a configuration change. Consider fallback/ensemble logic for reliability.
• Token and cost budgeting: Monitor token usage (CometAPI returns usage) and set max_tokens conservatively. Use temperature and deterministic decoding for repeatable results.
• Caching & deduplication: Cache repeated prompts (e.g., identical FAQs) to avoid repeated calls.
• Retry and backoff: Implement exponential backoff in Make with error handlers (Make supports error handlers and scenario scheduling).

How to enforce security, privacy, and governance?

• Secrets management: Store CometAPI keys in Make connections (not in plain text). Use enterprise SSO and central connection control.
• Data filtering: Redact PII before sending to third-party models unless you have DPA/contractual language covering data processing.
• Logging & observability: Log request/response IDs (CometAPI provides request ids) and store them in a secure audit log. Use Make’s execution logs for troubleshooting.

How do you handle rate limits and multi-provider fallbacks?

• Rate limit awareness: CometAPI may inherit provider rate limits; use Make’s throttling and queueing patterns or split requests across models.
• Fallbacks: Build a router in Make: primary call to openai/gpt-5, if fails switch to gpt-5-mini or Anthropic via CometAPI. This pattern keeps user experience smooth when a single model is throttled.

How Does CometAPI Compare to Using HTTP Modules in Make?

You could integrate AI APIs directly with Make’s HTTP module. However, that requires:

• Manually setting up headers and authentication.
• Structuring JSON payloads and parsing responses.
• Handling rate limits and retries manually.

CometAPI simplifies this by offering pre-built modules with AI functionality, saving time and reducing complexity. For teams without in-depth API knowledge, CometAPI is the more practical choice.

Conclusion

Combining Make’s visual automation with CometAPI’s multi-model gateway gives teams a fast, flexible, and future-proof integration path. Make minimizes engineering overhead for orchestration, and CometAPI simplifies model selection, vendor switching, and billing. Together they let you experiment quickly with the latest models (Gemini, OpenAI, Suno, etc.) while keeping production controls in place. As model offerings continue to evolve (recent model releases and policy shifts demonstrate this), designing integrations around a single, adaptable API is a pragmatic approach.

Getting Started

CometAPI is a unified API platform that aggregates over 500 AI models from leading providers—such as OpenAI’s GPT series, Google’s Gemini, Anthropic’s Claude, Midjourney, Suno, and more—into a single, developer-friendly interface. By offering consistent authentication, request formatting, and response handling, CometAPI dramatically simplifies the integration of AI capabilities into your applications. Whether you’re building chatbots, image generators, music composers, or data‐driven analytics pipelines, CometAPI lets you iterate faster, control costs, and remain vendor-agnostic—all while tapping into the latest breakthroughs across the AI ecosystem.

To begin, explore the model’s capabilities in the Playground and consult the API guide for detailed instructions. Before accessing, please make sure you have logged in to CometAPI and obtained the API key. CometAPI offer a price far lower than the official price to help you integrate.

Ready to Go?→ Sign up for CometAPI today !