# Make.com

Integrate Tensorix AI models with Make.com (formerly Integromat) to build powerful automated scenarios.

***

## Overview

[Make.com](https://www.make.com/) is a visual automation platform that connects thousands of apps. With Tensorix's OpenAI-compatible API, you can add AI capabilities to any Make scenario.

### What You Can Build

* 📧 **Email Automation** - Auto-reply, summarize, and classify emails
* 🔄 **Data Enrichment** - Enhance records with AI-generated insights
* 📱 **Social Media Bots** - Generate and schedule content
* 📊 **Report Generation** - Create summaries from data
* 🛒 **E-commerce** - Product descriptions, review analysis
* 📞 **Customer Support** - Intelligent ticket routing and responses

***

## Prerequisites

* Make.com account (Free tier works)
* Tensorix API key from [app.tensorix.ai](https://app.tensorix.ai)

***

## Method 1: OpenAI Module with Custom Endpoint

Make's OpenAI module supports custom API endpoints, making Tensorix integration simple.

### Step 1: Create OpenAI Connection

1. In Make, go to **Connections**
2. Click **Create a connection**
3. Search for **OpenAI**
4. Configure the connection:

| Field               | Value                 |
| ------------------- | --------------------- |
| **Connection Name** | `Tensorix AI`         |
| **API Key**         | Your Tensorix API key |
| **Organization ID** | Leave empty           |

### Step 2: Override the Base URL

When configuring an OpenAI module, expand **Show advanced settings**:

| Setting               | Value                        |
| --------------------- | ---------------------------- |
| **Override Base URL** | ✅ Enabled                    |
| **Base URL**          | `https://api.tensorix.ai/v1` |

### Step 3: Configure the Request

For a **Create a Chat Completion** action:

| Field           | Value                         |
| --------------- | ----------------------------- |
| **Model**       | `deepseek/deepseek-chat-v3.1` |
| **Messages**    | Add your conversation         |
| **Max Tokens**  | `1000` (adjust as needed)     |
| **Temperature** | `0.7`                         |

***

## Method 2: HTTP Module (Full Control)

For complete flexibility, use Make's HTTP module.

### Create Chat Completion

Add an **HTTP > Make a request** module:

**Configuration:**

| Field      | Value                                         |
| ---------- | --------------------------------------------- |
| **URL**    | `https://api.tensorix.ai/v1/chat/completions` |
| **Method** | `POST`                                        |

**Headers:**

| Key             | Value                 |
| --------------- | --------------------- |
| `Authorization` | `Bearer YOUR_API_KEY` |
| `Content-Type`  | `application/json`    |

**Body Type:** Raw

**Request Content:**

```json
{
  "model": "deepseek/deepseek-chat-v3.1",
  "messages": [
    {
      "role": "system",
      "content": "You are a helpful assistant."
    },
    {
      "role": "user",
      "content": "{{1.userInput}}"
    }
  ],
  "max_tokens": 1000,
  "temperature": 0.7
}
```

**Parse Response:** ✅ Yes

### Extract the AI Response

Access the response in subsequent modules:

```
{{2.choices[1].message.content}}
```

Or use a **JSON > Parse JSON** module for structured access.

***

## Method 3: Reusable HTTP Connection

Create a connection you can reuse across scenarios:

1. Go to **Connections** → **Create a connection**
2. Select **HTTP** → **Make a request**
3. Choose **API Key** authentication:

| Field                | Value                 |
| -------------------- | --------------------- |
| **API Key**          | Your Tensorix API key |
| **Add to**           | Header                |
| **Key Name**         | `Authorization`       |
| **Key Value Prefix** | `Bearer` (with space) |

4. Save as `Tensorix API`

Now use this connection in any HTTP module targeting `https://api.tensorix.ai`.

***

## Example Scenarios

### 1. Email Auto-Responder

Automatically draft responses to incoming emails:

```
Gmail (Watch Emails)
    ↓
OpenAI (Create Completion)
    ↓
Gmail (Create Draft)
```

**Prompt Template:**

```
You are an email assistant. Draft a professional response to this email:

From: {{1.from.text}}
Subject: {{1.subject}}
Body: {{1.text}}

Draft a helpful, concise response.
```

### 2. Shopify Product Description Generator

Generate SEO-optimized descriptions for new products:

```
Shopify (Watch Products)
    ↓
OpenAI (Create Completion)
    ↓
Shopify (Update Product)
```

**Prompt:**

```
Write an engaging product description for:
Product: {{1.title}}
Vendor: {{1.vendor}}
Tags: {{1.tags}}

Include benefits, features, and a call-to-action. Keep it under 200 words. Use SEO-friendly language.
```

### 3. Slack Support Bot

Respond to Slack messages with AI:

```
Slack (Watch Messages)
    ↓
Filter (exclude bot messages)
    ↓
OpenAI (Create Completion)
    ↓
Slack (Create a Message)
```

### 4. Lead Enrichment

Enrich CRM leads with AI-generated insights:

```
CRM (New Lead)
    ↓
HTTP (Company lookup)
    ↓
OpenAI (Analyze company)
    ↓
CRM (Update Lead)
```

**Prompt:**

```
Based on this company information, provide:
1. Industry classification
2. Company size estimate
3. Potential use cases for our product
4. Recommended approach

Company: {{1.company_name}}
Website: {{2.website_content}}
```

### 5. Content Calendar Automation

Generate a week's worth of social content:

```
Schedule (Weekly)
    ↓
Iterator (7 days)
    ↓
OpenAI (Generate post)
    ↓
Array Aggregator
    ↓
Google Sheets (Add rows)
```

***

## Working with Responses

### Parse the JSON Response

Make automatically parses JSON responses. Access fields like:

| Field         | Make Syntax                        |
| ------------- | ---------------------------------- |
| AI Response   | `{{X.choices[1].message.content}}` |
| Model Used    | `{{X.model}}`                      |
| Total Tokens  | `{{X.usage.total_tokens}}`         |
| Finish Reason | `{{X.choices[1].finish_reason}}`   |

### Handle Multiple Messages

For multi-turn conversations, use an **Array Aggregator** to build the messages array:

```json
{
  "messages": {{arrayAggregator.messages}}
}
```

***

## Recommended Models

| Scenario Type          | Recommended Model                   |
| ---------------------- | ----------------------------------- |
| **General Text**       | `deepseek/deepseek-chat-v3.1`       |
| **Analysis/Reasoning** | `deepseek/deepseek-r1-0528`         |
| **Code Generation**    | `z-ai/glm-5.1`                      |
| **Long Documents**     | `meta-llama/llama-4-maverick`       |
| **Quick Responses**    | `meta-llama/llama-3.3-70b-instruct` |

***

## Error Handling

### Add Error Handlers

Right-click any module → **Add error handler**

Recommended handlers:

* **Resume** - Continue with default value
* **Rollback** - Undo changes and retry
* **Break** - Stop and notify

### Common Errors

| Error            | Solution                       |
| ---------------- | ------------------------------ |
| 401 Unauthorized | Check API key is correct       |
| 404 Not Found    | Verify model name exactly      |
| 429 Rate Limited | Add delay between operations   |
| 500 Server Error | Retry with exponential backoff |

### Rate Limit Handling

Use the **Sleep** module between API calls:

```
API Call → Sleep (1 second) → Next API Call
```

For batch processing, use **Iterator** with built-in delay.

***

## Best Practices

### 1. Use Variables for API Key

Store your API key in a scenario variable:

* Go to **Scenario settings** → **Variables**
* Add `tensorix_api_key`
* Reference as `{{tensorix_api_key}}`

### 2. Optimize Token Usage

* Set appropriate `max_tokens` limits
* Use concise system prompts
* Summarize long inputs before processing

### 3. Structure Your Prompts

```
[ROLE]
You are a [specific role].

[TASK]
[Clear instruction]

[FORMAT]
Respond in [format].

[INPUT]
{{input_data}}
```

### 4. Monitor Usage

Add a **Webhook** or **Google Sheets** module to log:

* Token usage per request
* Response times
* Error rates

***

## Pricing Considerations

Tensorix charges per token. Optimize costs by:

* Using smaller context when possible
* Caching repeated queries
* Choosing appropriate models for each task
* Setting reasonable max\_tokens limits

***

## See Also

* [API Reference](https://github.com/Tensorix-ai/tensorix-docs/blob/main/api-reference/overview/README.md) - Full API documentation
* [Models](https://github.com/Tensorix-ai/tensorix-docs/blob/main/api-reference/models/README.md) - Model capabilities and pricing
* [Make.com Documentation](https://www.make.com/en/help) - Official Make guides


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.tensorix.ai/automation-platforms/make.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.