> ## Documentation Index
> Fetch the complete documentation index at: https://docs.context.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# Make Integration

> Automate brand data workflows with Make (formerly Integromat)'s visual automation platform

## Overview

Connect Context.dev with Make (formerly Integromat) to create powerful visual automation workflows that enrich your data with brand information.

<Card title="Install Context.dev for Make" icon="download" href="https://www.make.com/en/integrations/context-dev">
  Click here to install the Context.dev integration in your Make account
</Card>

## What is Make?

[Make](https://www.make.com) is a visual automation platform that allows you to design complex workflows by connecting different apps and services together. Unlike Zapier, Make offers more advanced features like:

* Visual workflow builder with branching logic
* Built-in data transformations and operations
* Error handling and retry mechanisms
* Advanced scheduling options
* Multiple paths and conditional logic

## Getting Started

### Installation

Install the Context.dev integration from the Make marketplace:

1. Click the [installation link](https://www.make.com/en/integrations/context-dev)
2. Authorize Context.dev in your Make account
3. Add your Context.dev API key from your [dashboard](https://context.dev)

### Available Features

### Context.dev Actions

1. **Retrieve Brand Data**
   * Input: Domain, email, or ticker
   * Output: Complete brand information (logos, colors, company data)

2. **NAICS Classification**
   * Input: Domain or company name
   * Output: Industry classification codes

3. **Transaction Enrichment**
   * Input: Merchant name, MCC, location
   * Output: Identified brand with logo and information

4. **AI Products Extraction**
   * Input: Domain
   * Output: Product catalog with pricing and features

5. **Screenshot Capture**
   * Input: URL
   * Output: Website screenshot

6. **Styleguide Extraction**
   * Input: Domain
   * Output: Design system (colors, fonts, components)

## Example Use Cases

### Example: Generate Branded Presentations

Use the Make scenario described in our guide [Brand Client Presentations](/integrations/no-code/client-presentation-branding) to automatically populate Google Slides with brand logos and names. This example demonstrates using Make's HTTP module and Google Slides modules to fetch brand data and inject logos into a presentation template.

### CRM Enrichment Workflow

```
Trigger: New Contact in HubSpot
  ↓
Action: Extract domain from email
  ↓
Context.dev: Retrieve Brand Data
  ↓
Router:
  → If brand found: Update HubSpot contact with brand data
  → If not found: Add to manual review list
```

### Competitor Monitoring

```
Trigger: Scheduled (Daily)
  ↓
Array: List of competitor domains
  ↓
For Each Competitor:
  → Context.dev: Retrieve Brand Data
  → Context.dev: Extract AI Products
  ↓
Action: Update Google Sheets with latest data
  ↓
Action: Send Slack notification if changes detected
```

### Transaction Processing

```
Trigger: New Transaction via Webhook
  ↓
Context.dev: Transaction Enrichment
  ↓
Router:
  → If brand identified:
     - Add logo to transaction record
     - Categorize by industry
  → If not identified:
     - Flag for manual review
```

## Alternative: HTTP Module

You can also use Context.dev with Make's HTTP module for custom API calls:

### Setup Instructions

<Steps>
  <Step title="Add HTTP Module">
    In your Make scenario, add an "HTTP" > "Make a Request" module
  </Step>

  <Step title="Configure Request">
    Set up the API call:

    * **URL**: `https://api.context.dev/v1/brand/retrieve`
    * **Method**: `POST`
    * **Headers**:
      * `Authorization`: `Bearer YOUR_API_KEY`
      * `Content-Type`: `application/json`
  </Step>

  <Step title="Add Request Body">
    ```json theme={null}
    {
      "domain": "{{1.domain}}"
    }
    ```

    (where `{{1.domain}}` references the domain from a previous module)
  </Step>

  <Step title="Parse Response">
    Use Make's JSON parsing to extract the data you need from the response
  </Step>
</Steps>

### Example: HTTP Request Configuration

```json theme={null}
{
  "url": "https://api.context.dev/v1/brand/retrieve",
  "method": "POST",
  "headers": [
    {
      "name": "Authorization",
      "value": "Bearer {{parameters.apiKey}}"
    },
    {
      "name": "Content-Type",
      "value": "application/json"
    }
  ],
  "body": {
    "domain": "{{trigger.email | split('@') | last}}"
  }
}
```

## Data Transformation

### Extract Domain from Email

Use Make's built-in functions:

```
{{trim(split(email, "@")[1])}}
```

### Format Brand Data

Transform Context.dev response for your use:

```
Company Name: {{brand.title}}
Logo URL: {{brand.logos[0].url}}
Primary Color: {{brand.colors[0].hex}}
Industry: {{brand.industries.eic[0].industry}}
```

### Handle Missing Data

Use Make's conditional logic:

```
{{if(brand.logos[0].url, brand.logos[0].url, "https://placehold.co/400x400?text=No+Logo")}}
```

## Error Handling

Configure error handling in Make:

<Steps>
  <Step title="Add Error Handler Route">
    Right-click on the Context.dev module and select "Add error handler"
  </Step>

  <Step title="Choose Error Type">
    * `DataError`: Invalid request format
    * `RuntimeError`: API errors (404, 429, etc.)
    * `ConnectionError`: Network issues
  </Step>

  <Step title="Define Recovery Action">
    * Retry with exponential backoff
    * Log error to database
    * Send notification to admin
    * Continue with default/fallback data
  </Step>
</Steps>

## Rate Limiting

Make respects Context.dev's rate limits. Rate limits vary by plan tier - see the [authentication page](/guides/get-started/authentication#rate-limiting) for current limits.

**Best Practice:** Use Make's scheduling and rate limiting features to stay within your limits.

## Pricing Considerations

* Context.dev API calls cost the same whether through Make or directly
* Make has its own pricing based on operations used
* HTTP module calls count as Make operations
* Consider caching to reduce both Context.dev and Make costs

## Resources

<CardGroup cols={2}>
  <Card title="Make Documentation" icon="book" href="https://www.make.com/en/help/getting-started">
    Learn Make basics
  </Card>

  <Card title="HTTP Module Guide" icon="code" href="https://www.make.com/en/help/modules/http">
    Using HTTP modules in Make
  </Card>

  <Card title="Context.dev API Docs" icon="code" href="/api-reference">
    Complete API reference
  </Card>

  <Card title="Zapier Integration" icon="plug" href="/integrations/zapier">
    Current Zapier integration (live now)
  </Card>
</CardGroup>

***

<Tip>
  Have questions about using Context.dev with Make? [Contact us](mailto:hello@context.dev) - we're happy to help you get started.
</Tip>