Unit introduction
Welcome to unit two of the Introduction to operations and credits course!
In the previous unit, you learned the basics of operations, credits, and how to track your credit use. Now, you’ll take a closer look at how credit counting works in real scenarios.
In this unit you will explore:
- different ways modules use credits
- credit usage through real use cases
- tools that do not consume credits
You won’t be adding anything new to the scenario covered in the first two courses, but it’s worth having it open for some exercises.
Credits usage in Make
Like you learned in the previous unit, credits are how you are billed within Make.
There are two different ways you can use credits in Make:
- Fixed credit usage: Features use a set number of credits per run.
- Dynamic credit usage: Some AI features and advanced modules use a varying number of credits per run based on actual consumption.
Let’s discover more about each one.
Fixed credit usage
1 to 1 credit usage
Fixed credit usage includes features that use a set number of credits per run. It is pretty straightforward: each operation uses a credit.
1 operation = 1 credit
So for example, the Gmail → Send an Email module will consume one credit per every email sent. If the module sends 3 emails, it performs 3 operations and will consume 3 credits.
More than 1 credit per operation
Some modules with fixed credit usage consume more than 1 credit for an operation depending on the complexity of the task.
For example, some Make AI Content Extractor modules each use a different number of credits per operation.
Dynamic credit usage
Dynamic credit usage means that some modules will use a varying number of credits based on actual usage rather than a fixed rate. This means that an operation can consume more or less credits depending on a different factors.
When using AI in Make, you have two ways to pay for your token usage:
- Use Make’s AI provider;
- Or use your own connection to a provider.
You can read more information on credits and tokens here.
What factors affect credit consumption?
When using Make’s AI provider, credit consumption for AI features may depend on:
- AI tokens: Tokens are how AI providers measure usage. The more information you send or generate, the more tokens and credits you use.
- File size: Bigger files use more credits.
- Pages: More pages use more credits.
- Run time: Longer runs use more credits.
Which features in Make use dynamic credits?
Some of the AI features that consume credits this way include:
- Make AI Toolkit
- Make AI Agents
- Make AI Content Extractor
How can I identify features with dynamic credit usage?
You can identify features with dynamic credit usage by their tags. The tag will show you how the module consumes credits: AI Tokens.
Use case 1 - Watch emails / Add summary to a spreadsheet
To give more context on counting operations and credits, let’s run through a few of the actions on simple scenarios to give you an idea of how credits are consumed.
The scenario here will perform two separate actions: it will watch the emails of an account, and add each email to a row.
Gmail: Watch Emails
The first action is to watch an email account. For this example, the module is watching the activity of a Gmail account.
The trigger module will always perform one operation and consume one credit regardless of how many emails were sent, or what the limit was set to.
For example, if there were 0 emails, or 50 emails, this would always count as one operation.
For this use case, we will say that five emails returned from Watch Emails.
The trigger module has returned five emails but has consumed one credit.
Google Sheets: Add a Row
The second module adds one row to the spreadsheet for every email generated.
The module will perform the Add a Row action five times, once per email. Each action counts as one operation, so the module performs five operations and consumes five credits overall.
Therefore, the entire scenario will consume six credits in total. One credit from Watch emails, and five credits from Add a Row.
MCQ
Before you look at the next use case, let’s try and put this new knowledge to good use and look at a scenario:
- The first module will watch responses on a form
- This will create a document for each response
- It will download the document
- And then mail it to the user who filled out the form
The scenario involves the following modules: Google Forms (Watch responses on a form) → Google Docs (Create a document) → Google Drive (Download a file) → Gmail (Send an email).
Four people have submitted their responses. How many credits will this scenario consume in total?
Use case 2 - Forms, documents, files and emails
Let’s break down the question you have just reviewed in further detail.
The scenario displayed here will perform four separate actions: watch the responses of a form, create a document from the details provided for each user, download the file to Google Drive, and then email the user a copy of their form responses.
The first action watches the responses on a form using the Google Forms module. For the purpose of this use case, let’s say that we know that there are four responses waiting to be processed. Since there are four form submissions, this generates four bundles of data.
A bundle is a set of data that moves through your scenario. You’ll explore bundles in more detail later, but keep this term in mind throughout the rest of the unit.
As with the previous use case, the first module will perform only one operation and consume one credit, regardless of how many times the form was filled out.
Since the first module received four responses, Make will process each response (bundle) once. There are three actions performed in each bundle: Create a Document (using Google Docs), Download a File (using Google Drive), and Send an Email (using Gmail).
Each action consumes one credit, so there are three credits processed per bundle. With four bundles and three credits each, the scenario uses 12 credits.
Adding the one credit from the source module brings the total to 13 credits used in the entire scenario.
Use case 3 - dynamic credit usage in AI features
Imagine you’re a customer support agent who needs to analyze the sentiment of every email you receive. You build a scenario in Make that automates this using the Make AI Toolkit → Analyze Sentiment module. Let’s explore how this process consumes credits.
Gmail: Watch new emails
The first module is Gmail → Watch new emails, which watches for any new emails received. This is a trigger module and will use only one operation and one credit regardless of how many emails you received. For this use case, three emails returned from the Gmail → Watch new emails module and it consumed one credit.
Make AI Toolkit: Analyze sentiment
The next module is Make AI toolkit → Analyze sentiment. It evaluates the tone of a text and determines if it’s positive, neutral, or negative. In this case, the module analyzes three emails. This means it is performing three operations. Credits are counted differently here.
The Make AI toolkit module uses credits based on the number of AI tokens. The use of tokens depends on how much text is processed. More interactions, longer prompts, bigger files, and longer answers all use more tokens.
Each operation used a different number of credits because each email had a different length. Longer emails used more tokens. The first operation used 1.19 credits, the second 1.43 credits, and the third 2.56 credits. The module consumed a total of 5.18 credits.
Slack: Create a Message
The Slack → Create a Message module sends a new message in Slack. This module sends three messages because it processed three emails. This means it performed three operations and consumed three credits.
One credit from Watch emails, 5.18 credits from Analyze Sentiment, and 3 credits from Create a Message. The total credits used for this scenario is 9.18 credits.
What tools do not use credits in Make?
Let’s revisit the Make Foundation Use Case and look at the credit usage. There are a few common questions here that are worth answering.
- As expected, your source module will Get current weather, and generate a bundle, consuming one credit.
- The bundle moves along the scenario and through the router.
Note: The router does not consume any credits.
- Based on the filter criteria, the bundle has been filtered to the top module. The filter icon contains a
1, this is to show that one bundle has passed through the filter.Note: A bundle passing through a filter does not consume any credits.
- The bundle arrives at the Google Sheets → Add a Row module and fulfills the action of adding a new row, consuming one credit.