At a Glance

The Marq APIs enable you to programmatically create personalized documents and presentations from templates. This comprehensive guide walks you through the complete workflow: from finding the right template to creating fully customized projects with dynamic content.

Key Benefits:

• Scale personalization: Generate hundreds of customized documents automatically
• Maintain brand consistency: Use approved templates while allowing dynamic content
• Integrate with existing systems: Connect your CRM, databases, or applications
• Reduce manual work: Automate repetitive document creation tasks

Understanding the Content Automation Workflow

Before diving into implementation, it's important to understand how Marq's content automation works:

Core Components

1. Templates: Pre-designed documents with placeholders for dynamic content
2. Smart Fields: Dynamic placeholders in templates that can be populated with data
3. Data Sets: Structured data sources (like spreadsheets or databases) connected to Marq
4. Projects: Individual instances created from templates with populated content

Smart Field Categories

Marq organizes smart fields into several categories:

👤 User Smart Fields - Automatically populated from user profiles

• text: User information like email, firstName, lastName, company
• images: Profile images and logos
• color: User-specific brand colors

👥 Team Smart Fields - Populated from team/organization data

• Available for team-level customization

📝 Project Smart Fields - Template-specific custom fields

• Unique to each template for custom content injection

📊 Data Smart Fields - Connected to external data sources

• Organized by data set name (e.g., "Properties", "Contacts")
• Includes special image fields for data-driven images

What You'll Need

• Client ID and Secret for OAuth access token
• Test account for creating projects

Complete Step-by-Step Workflow

Here's the complete workflow for automatically creating content from templates in Marq:

1. Find and Use Template
2. Identify which Variables (Smart Fields) Need to Be Populated
3. Identify Names and IDs for Data Smart Fields if Needed
4. Create Project

Step 1: Find and Use Template

Note: before proceeding, you should understand what type of integration you should configure based on token types:

Understanding Token Types:

User Token: Use when integrating on behalf of a specific user

• Automatically has access to templates that user can see
• No userId parameter needed
• Best for: User-facing applications

Account Token: Use when integrating on behalf of an entire account/organization

• Requires userId parameter to specify which user's templates to access
• Best for: Server-to-server integrations, batch processing
• Example: GET https://api.marq.com/v1/templates?userId=164182250

First, retrieve available templates to find the one you want to use:

https://api.marq.com/v1/templates

Important for Account Tokens:
If you're using an Account token (not a User token), you must include the userId parameter to retrieve templates available to that specific user:

https://api.marq.com/v1/templates?userId=164182250

Example Response:

{
  "templates": [
    {
      "id": "499caa4f-34df-4e7a-b903-e27af918b545",
      "name": "Real Estate Listing Flyer",
      "description": "Professional listing flyer template",
      "categoryValues": [
        {
          "id": 26683,
          "name": "Marketing Materials"
        }
      ]
    }
  ]
}

Filter by specific user or category:

GET https://api.marq.com/v1/templates?userId=164252231
GET https://api.marq.com/v1/templates?categoryValueId=26683

Step 2: Identify which Variables (Smart Fields) Need to Be Populated

Once you have your template ID, discover what smart fields are available:

GET https://api.marq.com/v1/templates/499caa4f-34df-4e7a-b903-e27af918b545/smartfields

Example Response:

{
  "userSmartFields": {
    "text": [
      "email",
      "firstName",
      "homeOffice",
      "workPhone",
      "company",
      "lastName"
    ],
    "images": [
      "profileImage"
    ],
    "color": []
  },
  "teamSmartFields": {
    "text": [],
    "images": [],
    "color": []
  },
  "projectSmartFields": {
    "text": [
      "customMessage",
      "marketingHeadline",
      "callToAction"
    ],
    "images": [
      "heroImage",
      "campaignLogo"
    ],
    "color": [
      "accentColor"
    ]
  },
  "dataSmartFields": {
    "Properties": {
      "text": [
        "bedrooms",
        "zip",
        "state",
        "yearBuilt",
        "address",
        "additionalFeatures",
        "longDescription",
        "city"
      ],
      "images": [],
      "color": []
    }
  },
  "specialDataImages": [
    "Secondary",
    "Primary"
  ]
}

Critical Check - Does the template have data smart fields?

Look at the dataSmartFields object in the response. If it contains data sets (like "Properties" in the example above), you'll need to get the correct column names from the actual data set schema before creating your project.

Understanding the Response:

• userSmartFields: Use this as a reference, you cannot insert User Smart fields via API, this will automatically populate from the user based on the user ID your provide as the OwnerID later on when using the Project API
• teamSmartFields: Use this as a reference, similar to the userSmartFields, these will auto populate based on the account settings set and managed by admins
• projectSmartFields: [Update via Project API] Custom fields specific to this template that you can populate
• dataSmartFields: [Update via Project API] Fields connected to data sets (organized by data set name)
• specialDataImages: Use this as a reference, you cannot update the data images, but it allows you know how the template is configured. If specialDataImages exist, the first image within a data set will auto populate the image placeholders that are designated as primary (e.g. hero image for property listing) and then all other images (bathrooms, backyard, bedrooms) will then sequentially populate all images designated as Secondary within the template.

Step 3: Identify Names and IDs for Data Smart Fields if Needed

⚠️ Why This Step is Critical:
The smart fields response shows template labels (like "address"), but your API calls must use actual column names (like "propertyAddress"). Using the wrong names causes COLUMN_NOT_FOUND errors.

Quick Reference - Common Mapping Issues:

• Template shows: "address" → API needs: "propertyAddress"
• Template shows: "longDescription" → API needs: "propertyDescription"
• Template shows: "bedrooms" → API needs: "bedrooms" ✓ (matches!)

⚠️ Important: The field names shown in the dataSmartFields response are template-specific labels, not the actual column names in your data set. To use data smart fields successfully, you need to get the actual column names from your data set schema.

If your template has data smart fields, follow these steps:

Step 3a: Get All Data Sets

First, retrieve all available data sets to find the one referenced in your template:

GET https://data.app.marq.com/dataSets

Example Response:

{
  "dataSets": [
    {
      "id": 3104,
      "name": "Properties",
      "uri": "https://data.app.marq.com/dataSets/3104",
      "lastSync": "2024-01-15T10:30:00Z",
      "properties": {
        "Type": "PropertyListings"
      }
    }
  ]
}

Find your data set:
Parse the results to find the data set with the same name that appeared in your template smart fields response (e.g., "Properties").

Step 3b: Get Collections in the Data Set

Once you have the data set URI, get the collections within that data set:

GET https://data.app.marq.com/collections?dataSet=https%3A%2F%2Fdata.app.marq.com%2FdataSets%2F3104

⚠️ Important: The dataSet parameter must be URL-encoded. The example above shows:

• Original: https://data.app.marq.com/dataSets/3104
• URL-encoded: https%3A%2F%2Fdata.app.marq.com%2FdataSets%2F3104

Example Response:

{
  "collections": [
    {
      "id": 23602565,
      "name": "Property Listings",
      "uri": "https://data.app.marq.com/collections/23602565",
      "lastSync": "2024-01-15T10:30:00Z",
      "itemCount": 1250,
      "dataSource": "https://data.app.marq.com/dataSources/715911"
    },
    {
      "id": 23602566,
      "name": "Archived Properties",
      "uri": "https://data.app.marq.com/collections/23602566",
      "lastSync": "2023-12-01T08:15:00Z",
      "itemCount": 500,
      "dataSource": "https://data.app.marq.com/dataSources/715912"
    }
  ]
}

Choose the correct collection:

• If there are multiple collections, determine which one is actively being used
• Look at the lastSync date to see if it's still active
• Check the itemCount to understand the data volume
• The most recent and actively synced collection is typically the correct one

Step 3c: Get the Collection Schema

Get the schema for the collection to understand the actual column names:

GET https://data.app.marq.com/collections/23602565/schema

Example Response:

{
  "schema": [
    {
      "name": "mlsNumber",
      "fieldType": "STRING",
      "isPrimary": true,
      "order": 1
    },
    {
      "name": "propertyAddress",
      "fieldType": "STRING",
      "isPrimary": false,
      "order": 2
    },
    {
      "name": "listingPrice",
      "fieldType": "NUMBER",
      "isPrimary": false,
      "order": 3
    },
    {
      "name": "bedrooms",
      "fieldType": "NUMBER",
      "isPrimary": false,
      "order": 4
    },
    {
      "name": "bathrooms",
      "fieldType": "NUMBER",
      "isPrimary": false,
      "order": 5
    },
    {
      "name": "squareFeet",
      "fieldType": "NUMBER",
      "isPrimary": false,
      "order": 6
    },
    {
      "name": "propertyDescription",
      "fieldType": "STRING",
      "isPrimary": false,
      "order": 7
    }
  ]
}

Key Information:

• name: The actual column name you must use in your API calls
• fieldType: The data type (STRING, NUMBER, etc.)
• isPrimary: Whether this field is the primary key

Mapping Template Fields to Actual Column Names:

Now you can map the template smart fields to the actual column names:

Understanding Primary Keys:

• Fields with "isPrimary": true can be used as primary keys for exact matching
• In the example above, "mlsNumber" is the primary key
• Use primary keys when you have an exact identifier for your data record

Choosing Your Content Population Strategy

Based on your smart fields discovery, choose the appropriate approach:

Option A: Using Connected Data Sets (dataSmartFields)

When to use:

• Template has data sets in dataSmartFields (like "Properties" in the example)
• Your data is already imported into Marq
• You want to populate multiple fields from a single data record

Understanding the Structure:
From the smart fields response, you can see that the "Properties" data set contains:

"dataSmartFields": {
  "Properties": {
    "text": ["bedrooms", "zip", "state", "yearBuilt", "address", "additionalFeatures", "longDescription", "city"],
    "images": [],
    "color": []
  }
}

⚠️ Critical Note: These field names are template-specific labels, not the actual column names in your data set. From Step 3c, you discovered the actual column names are different:

• Template shows: "address" → Actual column: "propertyAddress"
• Template shows: "longDescription" → Actual column: "propertyDescription"
• Template shows: "bedrooms" → Actual column: "bedrooms" (matches!)

Always use the actual column names from your data set schema when creating projects.

Strict Mode Decision Tree:

Use strict: true when:

• ✅ Automated batch processing (no manual intervention)
• ✅ Must guarantee complete documents (invoices, reports)
• ✅ Data validation is critical
• ❌ Project creation fails if data is missing

Use strict: false when:

• ✅ User-initiated project creation
• ✅ Users can complete missing fields manually
• ✅ Partial automation is acceptable
• ✅ Always creates projects (empty fields = placeholders)

Example Workflows:

• Newsletter generation: strict: true (must have complete subscriber data)
• Marketing template creation: strict: false (user can customize as needed)

The strict parameter controls how the system handles missing or unfound data:

• strict: true - Fail-safe mode: Project creation will fail if no data is found matching your filter criteria. Use this when you need to ensure all data smart fields are populated with actual data from your data set.

• strict: false - Flexible mode: Project will be created even if no matching data is found. Smart fields will remain as placeholders that can be manually populated later in the Marq editor.

When to use strict mode:

// Use strict: true when you need guaranteed data population
{
  "dataSmartFields": [
    {
      "strict": true,  // Fail if no data found - ensures complete automation
      "dataSetName": "Properties",
      "primaryKey": "12345"
    }
  ]
}

// Use strict: false when you want projects created regardless
{
  "dataSmartFields": [
    {
      "strict": false,  // Allow partial automation - user can complete manually
      "dataSetName": "Properties",
      "primaryKey": "might-not-exist"
    }
  ]
}

Implementation Examples:

Using Primary Key (Exact Match):

{
  "templateId": "499caa4f-34df-4e7a-b903-e27af918b545",
  "creatorId": 164252231,
  "title": "MLS #12345 Listing",
  "dataSmartFields": [
    {
      "strict": true,
      "dataSetName": "Properties",
      "primaryKey": "12345"  // Uses the mlsNumber primary key
    }
  ]
}

Using Column Filtering (Custom Filter):

{
  "templateId": "499caa4f-34df-4e7a-b903-e27af918b545",
  "creatorId": 164252231,
  "title": "84 Main Street Listing",
  "dataSmartFields": [
    {
      "strict": false,
      "dataSetName": "Properties",
      "columns": [
        {
          "column": "propertyAddress",  // Use actual column name from schema
          "value": "84 Main Street"
        }
      ]
    }
  ]
}

Multiple Column Filter:

{
  "dataSmartFields": [
    {
      "strict": false,
      "dataSetName": "Properties",
      "columns": [
        {
          "column": "propertyAddress",  // Actual column name
          "value": "84 Main Street"
        },
        {
          "column": "listingPrice",     // Actual column name
          "value": "750000"
        }
      ]
    }
  ]
}

Important Notes:

• dataSetName must match exactly what appears in the smart fields response ("Properties")
• Use primaryKey for exact matches, columns for custom filtering
• Consider your workflow: do you need guaranteed complete documents or is partial automation acceptable?

Option B: Direct Field Population (projectSmartFields)

When to use:

• You want to populate fields from projectSmartFields in the smart fields response
• Data comes from external APIs or calculations
• You need precise control over individual fields

Using the Smart Fields Response:
From the example response, you can populate these project-specific fields:

"projectSmartFields": {
  "text": ["customMessage", "marketingHeadline", "callToAction"],
  "images": ["heroImage", "campaignLogo"],
  "color": ["accentColor"]
}

Implementation:

{
  "templateId": "499caa4f-34df-4e7a-b903-e27af918b545",
  "creatorId": 164252231,
  "title": "84 Main Street Listing",
  "projectSmartFields": [
    {
      "name": "marketingHeadline",
      "value": "Luxury Living at Its Finest"
    },
    {
      "name": "customMessage",
      "value": "Don't miss this incredible opportunity!"
    },
    {
      "name": "callToAction",
      "value": "Schedule your private showing today!"
    },
    {
      "name": "heroImage",
      "value": "https://example.com/hero-photo.jpg",
      "dataType": "image"
    },
    {
      "name": "accentColor",
      "value": "#FF5733"
    }
  ]
}

Critical Details:

• name must exactly match the field name from the smart fields response
• For images fields, always include "dataType": "image"
• For color fields, use hex color codes (e.g., "#FF5733")
• text fields are populated as strings

Option C: User Context Override

When to use:

• You want to populate user information from a different user, you can use the applyUserId to still create a project for the user designated as creatorId but then apply the other user's information in all the userSmartFields. (e.g. I create the document for Jane Smith
• Template has userSmartFields that you want to override

User Smart Fields from Response:

"userSmartFields": {
  "text": ["email", "firstName", "homeOffice", "workPhone", "company", "lastName"],
  "images": ["profileImage"],
  "color": []
}

Implementation:

{
  "templateId": "499caa4f-34df-4e7a-b903-e27af918b545",
  "creatorId": 164252231,
  "applyUserId": 164252232,
  "title": "Agent Marketing Materials"
}

This will populate email, firstName, lastName, profileImage, etc. from user 164252232 instead of the creator.

Option D: Hybrid Approach (Multiple Methods)

You can combine multiple approaches:

{
  "templateId": "499caa4f-34df-4e7a-b903-e27af918b545",
  "creatorId": 164252231,
  "applyUserId": 164252232,
  "title": "Complete Custom Listing",
  "dataSmartFields": [
    {
      "strict": false,
      "dataSetName": "Properties",
      "primaryKey": "12345"
    }
  ],
  "projectSmartFields": [
    {
      "name": "marketingHeadline",
      "value": "Exclusive Listing - Just Reduced!"
    },
    {
      "name": "heroImage",
      "value": "https://example.com/custom-hero.jpg",
      "dataType": "image"
    }
  ]
}

Step 4: Create Your Project

Make the API call to create your customized project:

POST https://api.marq.com/v1/projects
Content-Type: application/json
Authorization: Bearer YOUR_TOKEN

{
  "templateId": "499caa4f-34df-4e7a-b903-e27af918b545",
  "creatorId": 164252231,
  "folderId": 272547995,
  "title": "84 Main Street Listing",
  "dataSmartFields": [
    {
      "strict": false,
      "dataSetName": "Properties",
      "columns": [
        {
          "column": "propertyAddress",  // Use actual column name from schema
          "value": "84 Main Street"
        }
      ]
    }
  ],
  "projectSmartFields": [
    {
      "name": "marketingHeadline",
      "value": "Luxury living at its finest!"
    }
  ]
}

Success Response:

{
  "id": "1603e295-d271-478b-b542-8fa91dc1d777",
  "selfUri": "https://api.marq.com/v1/users/164182250/projects/1603e295-d271-478b-b542-8fa91dc1d777",
  "title": "Sales Presentation",
  "editorUri": "https://app.marq.com/documents/edit/1603e295-d271-478b-b542-8fa91dc1d777",
  "publishedUri": null,
  "thumbnailUri": "https://app.marq.com/documents/thumb/1603e295-d271-478b-b542-8fa91dc1d777/0/1/NULL/400",
  "ownerId": 164182200,
  "created": "2024-07-24T15:24:14Z",
  "lastModified": "2024-07-24T15:24:14Z",
  "templateId": "4361c440-b341-4504-a0c3-387d118a9y65",
  "dataItemUsages": []
}

Understanding Strict Mode in Detail

Strict Mode Scenarios

Production Workflows - Use strict: true:

• Automated Reports: Ensure all data fields are populated before generating financial or regulatory reports
• Customer Communications: Prevent sending incomplete invoices or statements
• Marketing Campaigns: Guarantee all personalization data is applied before campaign launch

{
  "dataSmartFields": [
    {
      "strict": true,
      "dataSetName": "Customer Data",
      "primaryKey": "CUST-12345"
    }
  ]
}

Result: If customer "CUST-12345" doesn't exist, the API will return an error and no project will be created.

Development & User Workflows - Use strict: false:

• Draft Creation: Allow users to create projects even with incomplete data
• Testing: Create projects for development without requiring complete data sets
• Partial Automation: Let users manually complete projects when data is incomplete

{
  "dataSmartFields": [
    {
      "strict": false,
      "dataSetName": "Customer Data",
      "primaryKey": "CUST-MAYBE-EXISTS"
    }
  ]
}

Result: Project is created regardless. If customer data is found, fields are populated; if not, they remain as placeholders.

Strict Mode Best Practices

When to use strict: true:

• ✅ Automated batch processing where incomplete documents are problematic
• ✅ Critical business documents that require complete data
• ✅ Production workflows where manual intervention isn't desired
• ✅ When you need to validate data existence before project creation

When to use strict: false:

• ✅ User-initiated project creation where they can complete missing fields
• ✅ Development and testing environments
• ✅ When partial automation is acceptable
• ✅ Workflows where users prefer projects to be created even with incomplete data

Error Handling with Strict Mode

Authentication Errors:

• 401 Unauthorized - Invalid or expired access token
• 400 Bad Request - Invalid JSON format or missing required fields
• 403 Forbidden - Invalid client credentials

Common Authentication Error Response:

{
  "error": "invalid_client",
  "error_description": "Client authentication failed"
}

Strict Mode Errors:

// strict: true with non-existent data
{
  "error": {
    "code": "DATA_NOT_FOUND",
    "message": "No data found for primary key: CUST-12345",
    "details": {
      "dataSetName": "Customer Data",
      "primaryKey": "CUST-12345"
    }
  }
}

Complete Working Examples

📋 End-to-End Integration: Real Estate Automation

Business Need: Generate property listing flyers automatically when MLS listings are updated

Step 1: Setup (One-time)

// Store in your environment variables
const CLIENT_ID = "your-client-id";
const CLIENT_SECRET = "your-client-secret";
const TEMPLATE_ID = "499caa4f-34df-4e7a-b903-e27af918b545";

Step 2: Token Management

async function getAccessToken() {
  const response = await fetch('https://users.app.marq.com/oauth2/refreshToken', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Accept': 'application/json'
    },
    body: JSON.stringify({
      grant_type: 'refresh_token',
      client_id: CLIENT_ID,
      client_secret: CLIENT_SECRET,
      refresh_token: storedRefreshToken
    })
  });
  return response.json();
}

Step 3: Create Property Flyer

async function createPropertyFlyer(mlsNumber, customHeadline) {
  const token = await getAccessToken();
  
  const response = await fetch('https://api.marq.com/v1/projects', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${token.access_token}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      templateId: TEMPLATE_ID,
      creatorId: 164252231,
      title: `MLS #${mlsNumber} - Property Flyer`,
      dataSmartFields: [{
        strict: true,
        dataSetName: "Properties",
        primaryKey: mlsNumber
      }],
      projectSmartFields: [{
        name: "marketingHeadline",
        value: customHeadline
      }]
    })
  });
  
  return response.json();
}

Step 4: Error Handling

try {
  const project = await createPropertyFlyer("12345", "New Listing!");
  console.log("Project created:", project.editorUri);
} catch (error) {
  if (error.status === 401) {
    // Token expired, refresh and retry
    await refreshToken();
    return createPropertyFlyer("12345", "New Listing!");
  }
  throw error;
}

Error Handling and Troubleshooting

🔧 Quick Debug Flowchart

API Call Failed?

1. Check Response Status:

   • 401 → Token expired/invalid → Refresh your token
   • 400 → Bad request → Check JSON format and required fields
   • 404 → Not found → Verify IDs and endpoints

2. For Data Smart Fields Errors:

   • COLUMN_NOT_FOUND → Use actual column names from schema (Step 3c)
   • DATA_NOT_FOUND → Set strict: false or verify filter values
   • DATA_SET_NOT_FOUND → Use exact name from smart fields response

3. For Authentication Errors:

   • Verify Content-Type: application/json
   • Check client credentials
   • Ensure proper JSON format (not form-encoded)

Common Errors and Solutions

Error: "No data found for primary key"

{
  "error": "No data found for primary key: 12345"
}

Solutions:

• Check data existence: Verify the primary key exists in your data set
• Use strict: false: Allow project creation with placeholders
• Implement fallback logic: Try strict mode first, then fallback to non-strict

Error: "Smart field not found"

{
  "error": "Smart field 'Property Address' not found in template"
}

Solution: Use the exact field names from the smart fields API response. In this case, it should be "address" not "Property Address".

Error: "Column not found in data set"

{
  "error": "Column 'address' not found in data set 'Properties'"
}

Solution: Use the actual column names from your data set schema. From Step 3c, you discovered the actual column name is "propertyAddress", not "address".

Error: "Invalid data type"

{
  "error": "Expected image data type for smart field 'heroImage'"
}

Solution: Add "dataType": "image" for fields listed under images in the smart fields response.

Error: "Data set not found"

{
  "error": "Data set 'Properties' not found"
}

Solution: Use the exact data set name from the smart fields response under dataSmartFields.

Smart Fields Validation Checklist

Before creating a project, verify:

1. Template Field Names: Match exactly with smart fields response (for projectSmartFields)
2. Data Set Names: Use exact names from dataSmartFields (for dataSmartFields)
3. Column Names: Use actual column names from data set schema (for dataSmartFields filtering)
4. Primary Keys: Use correct primary key field names from schema
5. Data Types: Add "dataType": "image" for image fields
6. Color Format: Use hex codes for color fields
7. Strict Mode Strategy: Choose based on your workflow requirements

Data Set Integration Validation

Step-by-Step Validation Process:

1. Verify Data Set Exists:

   Bash

   GET https://data.app.marq.com/dataSets
   # Find data set with name matching your template's dataSmartFields
   

2. Get Collections:

   Bash

   GET https://data.app.marq.com/collections?dataSet=ENCODED_DATASET_URI
   # Choose the active collection (recent lastSync date)
   

3. Get Schema:

   Bash

   GET https://data.app.marq.com/collections/COLLECTION_ID/schema
   # Use these exact column names in your project creation
   

4. Test with Sample Data:

   Bash

   GET https://data.app.marq.com/collections/COLLECTION_ID/items?limit=5
   # Verify your filter values exist in the actual data
   

Error Reference

Related Documentation

• Project API Reference
• Template API Reference
• Smart Fields API Reference
• Data Automation Setup Guide
• Data Automation Guide
• Template Creation Best Practices

Need Help?

If you're still having trouble with content automation:

1. Always Get the Schema First: Use the data set schema discovery process to find actual column names
2. Check the Smart Fields Response: Always use exact field names and data set names from the smart fields API
3. Validate Column Names: Use the collection schema endpoint to get the correct column names for filtering
4. Choose Appropriate Strict Mode: Use strict: true for guaranteed complete documents, strict: false for flexible workflows
5. Test Your Filters: Verify that your filter values exist in the actual data set before creating projects
6. Start Simple: Test with projectSmartFields before using data sets
7. Use Account Token Correctly: Include userId parameter when listing templates with Account tokens
8. Contact Support: Reach out to [email protected] with your specific use case