Building OpenAI Scenarios in Make.com Step by Step

# Make.com Tutorial: Auto-Generate Blog Drafts from Google Sheets with OpenAI

## Step 1: Prepare Your Google Sheet
Create a Google Sheet with these column headers in row 1: "Idea", "Draft", and "Status". Add a few blog post ideas in the "Idea" column to test with later. Keep this tab named something simple like "Ideas".

## Step 2: Get Your OpenAI API Key
Go to **platform.openai.com**, sign in, and click your profile icon → "View API keys" (or navigate to **API keys** in the left menu). Click "Create new secret key", name it "Make.com", and copy the key immediately (it won't be shown again). Also confirm you have billing set up under "Billing" — without credits, API calls will fail with a `quota exceeded` error.

## Step 3: Create a New Scenario in Make
Log into **make.com**, click "Scenarios" in the left sidebar, then click the purple "Create a new scenario" button in the top-right. You'll land on the blank scenario canvas with a large "+" icon.

## Step 4: Add the Google Sheets Trigger
Click the "+" icon and search for **Google Sheets**. Select the trigger **"Watch Rows"**. Click "Create a connection", sign in with your Google account, and grant access. Then configure:
- "Spreadsheet ID": browse and select your sheet
- "Sheet Name": `Ideas`
- "Table contains headers": `Yes`
- "Row with headers": `1`
- "Limit": `10`

Click "OK", then right-click the module and choose "Choose where to start" → "From now on".

## Step 5: Add the OpenAI Module
Click the small "+" next to the Google Sheets module. Search for **OpenAI (ChatGPT, Whisper, DALL-E)** and select the action **"Create a Completion (GPT and o-series models)"** — this is the modern chat-based action. Avoid the older "Create a Completion (Legacy)" unless you need it.

## Step 6: Connect OpenAI to Make
Click "Create a connection". In the popup:
- "Connection name": `OpenAI - My Account`
- "API Key": paste the key from Step 2
- "Organization ID": leave blank unless you belong to multiple orgs

Click "Save". If you get an `Invalid API key` error, re-copy the key carefully — no spaces.

## Step 7: Configure the Model and Messages
In the OpenAI module:
- "Model": select `gpt-4o-mini` (cheap and fast) or `gpt-4o` (higher quality)
- Under "Messages", click "Add item" twice to create two messages.

**Message 1 (system):**
- "Role": `System`
- "Message Content": `You are a professional blog writer. Write engaging, well-structured blog post drafts in approximately 300 words with a clear intro, body, and conclusion.`

**Message 2 (user):**
- "Role": `User`
- "Message Content": type `Write a 300-word blog post draft about: ` then click the Google Sheets field picker and insert the `Idea` variable.

## Step 8: Set Parameters (Max Tokens & Temperature)
Scroll down and configure:
- "Max Completion Tokens": `500` (300 words ≈ 400 tokens, plus buffer)
- "Temperature": `0.7` (balanced creativity; use `0.3` for factual, `1.0` for creative)
- "Top P", "N", "Stop": leave default

Click "OK" to save the module.

## Step 9: Add the Google Sheets Update Module
Click the "+" after the OpenAI module. Search **Google Sheets** again and select **"Update a Row"**. Configure:
- "Connection": same as before
- "Spreadsheet ID" and "Sheet Name": same as Step 4
- "Row number": map the `Row number` variable from the trigger module
- "Draft" (column B): map `Choices[] → Message → Content` from the OpenAI module
- "Status" (column C): type `Done`

Click "OK".

## Step 10: Test with "Run Once"
Click the purple "Run once" button at the bottom-left. Make will watch for rows. Go to your Google Sheet and add a new idea in a fresh row. Within ~1 minute, the scenario should fire. Check the bubbles above each module for a green checkmark and inspect the output by clicking them.

**Common errors & fixes:**
- `429 Rate limit` → reduce the trigger "Limit" or add a delay module
- `Model not found` → your API key's tier may not have access; try `gpt-4o-mini`
- Empty draft written → check that you mapped `Content` (not `Message` object itself)

## Step 11: Add Error Handling
Right-click the OpenAI module and choose "Add error handler". Select **"Resume"** and set a default output (e.g., `Content`: `Error — please retry`). This prevents one bad row from halting the entire scenario.

## Step 12: Schedule Your Scenario
Click the clock icon on the Google Sheets trigger module. Set:
- "Run scenario": `At regular intervals`
- "Minutes": `15`

Then toggle the scenario **ON** using the switch at the bottom-left. Save with Ctrl/Cmd+S.

---

## Tips & Best Practices

- **Watch token limits**: a 300-word draft uses ~400 tokens output + ~50 input. Setting "Max Completion Tokens" too low will truncate drafts mid-sentence — too high wastes money. Monitor usage at platform.openai.com/usage.
- **Control costs**: use `gpt-4o-mini` for routine content (roughly 20× cheaper than `gpt-4o`). Set a monthly spend limit under OpenAI's **Billing → Limits** page.
- **Always add error handlers**: OpenAI occasionally returns 429 or 503 errors. A "Resume" or "Break" handler with retries (3 attempts, 5-minute interval) keeps scenarios resilient.
- **Test with 1–2 

# Make.com + OpenAI Integration Tutorial: Auto-Generate Blog Drafts from Google Sheets

## Step 1: Create a New Scenario in Make.com

1. Log in to your Make.com account at make.com
2. Click "Create a new scenario" from the dashboard
3. Name your scenario something descriptive like "Google Sheets → OpenAI Blog Draft Generator"
4. Click "Create"

You'll see a blank canvas with a plus icon (+) in the center, ready to add your first module.

---

## Step 2: Add Google Sheets as Your Trigger Module

1. Click the plus icon (+) in the center of the canvas
2. Search for "Google Sheets" in the module library
3. Select "Google Sheets" and choose the action "Watch New Rows"
4. Click "Add"
5. If prompted, click "Create a connection" and authorize Make.com to access your Google account
6. In the "Spreadsheet" field, select the Google Sheet containing your blog ideas
7. In the "Worksheet" field, select the sheet tab with your data (e.g., "Sheet1")
8. In the "Table contains headers" field, toggle "Yes" if your first row has column names
9. Click "OK" to save the trigger

**Common error:** If the sheet doesn't appear, ensure you have Editor access to the Google Sheet and refresh your connection.

---

## Step 3: Obtain Your OpenAI API Key

1. Open a new browser tab and go to platform.openai.com
2. Log in with your OpenAI account (create one if needed)
3. Click your profile icon in the top-right corner
4. Select "API keys" from the dropdown
5. Click "Create new secret key"
6. Copy the key immediately and **save it somewhere safe**—you won't be able to see it again
7. Keep this browser tab open; you'll need this key in the next step

**Important:** This API key costs money to use. OpenAI charges per token. Set up billing and monitor usage at platform.openai.com/account/billing/overview.

---

## Step 4: Add the OpenAI Module to Your Scenario

1. Click the plus icon (+) to the right of your Google Sheets trigger module
2. Search for "OpenAI" in the module library
3. Select "OpenAI" and choose the action "Create a Chat Completion"
   - (Use "Chat Completion" instead of "Completion"—it's newer, more reliable, and recommended for text generation)
4. Click "Add"
5. In the connection field that appears, click "Create a connection"
6. Paste your OpenAI API key into the "API Key" field
7. Click "Save" to create the connection
8. You'll now see configuration fields for the Chat Completion action

---

## Step 5: Configure the OpenAI Model

1. In the "Model" field, select "gpt-3.5-turbo"
   - (This is cost-effective and fast for blog drafts. For higher quality, use "gpt-4", but it costs more)
2. Leave all other model fields at their defaults for now

---

## Step 6: Set Up the System Message

1. Locate the "Messages" section
2. Click "Add item" under "Messages"
3. In the "Role" field, select "system" from the dropdown
4. In the "Content" field, paste this system prompt:

```
You are a professional blog writer. Write clear, engaging, and informative blog drafts. 
Keep your tone conversational but authoritative. Always deliver exactly what is requested.
```

This tells OpenAI how to behave as it processes your requests.

---

## Step 7: Map the Blog Idea and Create the User Message

1. Click "Add item" again under "Messages" to create a second message
2. In the "Role" field, select "user"
3. In the "Content" field, click the data mapping icon (it looks like a chain link or variable symbol)
4. Select the column from your Google Sheet that contains the blog idea (e.g., "Blog Idea" or "Title")
5. The field should now show something like `{{1.Blog Idea}}`
6. Complete the prompt by typing after the mapped variable:

```
{{1.Blog Idea}} - Write a 300-word blog post draft on this topic. Include an introduction, main points, and conclusion.
```

Replace `{{1.Blog Idea}}` with your actual column name if different.

---

## Step 8: Configure Token Limits and Temperature

1. Locate the "Max Tokens" field and enter `400`
   - (This ensures the draft stays around 300 words with buffer; 1 token ≈ 0.75 words)
2. Locate the "Temperature" field and set it to `0.7`
   - (0.7 balances creativity with consistency; 0 = deterministic, 1 = very creative)
3. Leave other parameters (Top P, Frequency Penalty, Presence Penalty) at their defaults

---

## Step 9: Add a Google Sheets Output Module to Write the Draft Back

1. Click the plus icon (+) to the right of the OpenAI module
2. Search for and select "Google Sheets"
3. Choose the action "Update a Row"
4. Click "Add"
5. In the "Spreadsheet" field, select the same Google Sheet from Step 2
6. In the "Worksheet" field, select the same sheet tab
7. In the "Row number" field, click the mapping icon and select the row identifier from your Google Sheets trigger
   - This is typically a "Row number" or ID field; it ensures the draft is written to the correct row

---

## Step 10: Map the OpenAI Output to the Google Sheet Column

1. In the "Update values" section, click "Add item" to map a field
2. Set the "Key" to the name of the column where you want the draft (e.g., "Blog Draft" or "AI Generated Content")
3. Click the mapping icon in the "Value" field
4. Navigate to the OpenAI module output and select "Content" under the "Messages" section
   - This captures the generated text from OpenAI
5. The field should now show something like `{{2.choices[0].message.content}}`
6. Click "OK" to confirm the mapping

---

## Step 11: Test Your Scenario with "Run Once"

1. Add a test row to your Google Sheet with a blog idea (e.g., "How to optimize your morning routine")
2. Return to your Make.com scenario
3. Click "Run once" in the bottom-left corner
4. Watch the execution panel at the bottom for results:
   - Green checkmarks = success
   - Red X = error; click to view details
5. Return to your Google Sheet and verify the draft was written to the correct row

**Common errors:**
- "Invalid API key": Double-check your OpenAI API key in Step 3 and confirm it was pasted correctly
- "No rows found": Ensure your trigger is watching the correct sheet and worksheet
- "Rate limited": OpenAI may rate-limit if you run too many requests too quickly; wait a moment and retry

---

## Step 12: Add Error Handling (Optional but Recommended)

1. Click the wrench icon (settings) on the OpenAI module
2. Toggle "Show advanced settings"
3. Look for an "Error handling" option and select "Continue on error" or "Throw an error" based on your preference
4. This prevents the entire scenario from failing if OpenAI temporarily times out

---

## Step 13: Schedule Your Scenario

1. Click the clock icon in the top toolbar
2. Set a schedule (e.g., "Run every 15 minutes" or "Every hour")
3. Alternatively, leave it on "Manual" and trigger it yourself by clicking "Run once"
4. Click "Save"

**Recommendation:** For frequent checks, schedule it every 30 minutes to avoid unnecessary API charges and rate limits.

---

## Step 14: Save and Deploy

1. Click "Save" in the top-left corner
2. Your scenario is now active and will monitor your Google Sheet
3. Each new row with a blog idea will trigger OpenAI to generate a 300-word draft, which is automatically written back to the same row

---

## Tips & Best Practices

- **Monitor Token Usage:** Log into platform.openai.com/account/usage regularly to track API costs. A 300-word draft costs roughly $0.001–$0.003 per request (depending on your model and token count).
- **Use Filters:** Add a "Filter" module between your Google Sheets trigger and OpenAI to only process rows where a "Blog

Of course. As a Make.com and OpenAI expert, I can provide a detailed, step-by-step tutorial to build your automated blog drafting scenario.

Here is your beginner-friendly guide to automatically generating blog drafts from Google Sheets using OpenAI in Make.com.

***

### **Tutorial: Automated Blog Drafting with Google Sheets and OpenAI**

This tutorial will guide you through creating a Make.com scenario that automatically generates a blog post draft whenever you add a new idea to a Google Sheet.

#### **Step 1: Prepare Your Google Sheet**

Before starting in Make.com, set up your Google Sheet. This is the foundation of your automation.

1.  Create a new Google Sheet.
2.  In the first row, create these exact column headers: `Blog Post Idea`, `Generated Draft`, and `Status`.
3.  Add a sample idea in the `Blog Post Idea` column (e.g., "The top 5 benefits of remote work"). Leave the other columns empty for now.

#### **Step 2: Create a New Scenario and Add the Trigger**

Now, let's start building in Make.com.

1.  Log in to your Make.com account and click the "**+ Create a new scenario**" button in the top right.
2.  Click the large plus `+` symbol in the center of the screen and search for "**Google Sheets**".
3.  Select "**Watch New Rows**" from the list of triggers. This module will

1. Log into Make.com, click **Create a new scenario** in the dashboard, and name it "Blog Idea to Draft Generator".

2. Search for and add the **Google Sheets > Watch New Rows** module as the trigger. Click **Add** to connect your Google account (authorize if prompted), select your spreadsheet and worksheet, map **Table contains headers** to **Yes** if applicable, and choose the column for blog ideas (e.g., "Idea"). Save and confirm structure by adding a sample row in your sheet.

3. Click the **+** after the trigger, search for **OpenAI**, and add **Create a Chat Completion** (preferred over "Create a Completion" for modern chat-based generation).

4. Obtain your OpenAI API key: Visit platform.openai.com/api-keys, sign in, click **Create new secret key**, copy it, then in Make, click **Add** under Connection in the OpenAI module, paste the key into **API Key**, name the connection, and save.

5. In the OpenAI module, set **Model** to `gpt-3.5-turbo` (cost-effective for beginners). Under **Messages**, add a **System** message: "You are an expert blog writer. Generate engaging, 300-word drafts based on the idea provided." Add a **User** message: map `{{1.Idea}}` from the Google Sheets trigger, prepend "Write a 300-word blog post draft for this idea: ".

6. In **Max Tokens**, enter `600` (allows ~300 words + buffer; common error: exceeding limits causes truncation—monitor via OpenAI dashboard). Set **Temperature** to `0.7` for creative balance. Leave other params default, then click **OK**.

7. Click the **+** after OpenAI, add **Google Sheets > Update a Row** using the same Google connection. Select your spreadsheet and worksheet.

8. In Update a Row, set **Row number** to `{{1.Row number}}` (maps from trigger to target the new row). Under **Values**, map the generated draft: in the "Draft" column field (adjust to your sheet), enter `{{3.choices[1].message.content}}` (exact path from OpenAI output; common error: wrong mapping—use Data Store or click "Show advanced settings" to map bundles).

9. Click **OK** to save the scenario. Ensure modules connect with arrows (drag if needed).

10. Add a sample blog idea row in your Google Sheet (e.g., Column A: "Idea" header, new row: "Top 10 AI Tools for Marketers").

11. Click **Run once** in the scenario editor. Watch execution: green checks mean success. Check sheet for draft in the target column. Fix errors: Invalid API key (recreate key), auth issues (reconnect Google), or "No data" (ensure sheet has headers matching trigger).

12. If test passes, click **Scheduling** (bottom panel), toggle **On**, and set to **On demand** or cron for polling (e.g., every 15 mins: `*/15 * * * *`). Common error: Infinite loops—use **Limit** to 1 iteration in trigger.

13. Save the scenario (Ctrl+S). Activate with the toggle switch.

14. Monitor runs via **History** tab; edit prompts for better drafts.

**Tips & Best Practices:**
- Track token usage in OpenAI dashboard to avoid surprise costs (~$0.002/1k tokens on gpt-3.5-turbo); use `gpt-4o-mini` for efficiency.
- Add an **Error Handler** route (right-click module > Add error handler > Tools > Ignore) to skip bad ideas without halting.
- Insert a **Router** before Update Row for filters (e.g., ignore short ideas <20 chars) and **Text Parser** to trim drafts.
- Test incrementally; start with 100-word drafts to validate before scaling.
- Enable **Instant Trigger** if using Google Sheets webhooks (pro feature) for real-time, reducing polling costs.