Skill: Personize No-Code Pipelines

.json

When to Use This Skill

• User wants to connect Personize to HubSpot, Salesforce, Google Sheets, Slack, Postgres, or any app with an API
• User asks for "no-code" or "n8n" or "workflow automation" integration
• User wants scheduled syncs without writing code
• User needs webhook-triggered data flows

When NOT to Use This Skill

• Want TypeScript/SDK code you can test and version → use entity-memory (CRM sync section)
• Need durable pipelines with retries, waits, and complex orchestration → use code-pipelines
• Only need a single API call → use entity-memory directly

Prerequisites

• An n8n instance (cloud or self-hosted)
• A Personize secret key (

  sk_live_...

  ) configured as an HTTP Header Auth credential in n8n:
  • Name:

    Authorization

  • Value:

    Bearer sk_live_...

  • Credential name:

    Personize API Key

    (referenced in all templates)

Personize API Endpoints for n8n

https://agent.personize.ai

Authorization: Bearer sk_live_...

/api/v1/batch-memorize

/api/v1/memorize

/api/v1/upsert

/api/v1/smart-recall

/api/v1/search

/api/v1/smart-memory-digest

/api/v1/ai/smart-guidelines

/api/v1/me

n8n Workflow JSON Structure

nodes

connections

settings

{
  "name": "Workflow Name",
  "nodes": [ /* array of node objects */ ],
  "connections": { /* source node name → target connections */ },
  "settings": { "executionOrder": "v1" }
}

Constraints

Keywords follow RFC 2119: MUST = non-negotiable, SHOULD = strong default (override with stated reasoning), MAY = agent discretion.

1. MUST use unique node names -- because node names serve as connection keys in the

   connections

   object; duplicates cause wiring failures on import.
2. MUST set

   "settings": { "executionOrder": "v1" }

   -- because omitting it causes non-deterministic node execution order in n8n.
3. MUST reference credentials by the display name the user created in n8n -- because n8n resolves credentials by name, not by ID; mismatched names cause auth failures on import.
4. SHOULD space nodes ~220px horizontally in position values

   [x, y]

   -- because consistent spacing produces readable canvas layouts that users can navigate without rearranging.
5. SHOULD use UUID-like strings for node IDs (e.g.,

   "pz-sync-001"

   ) -- because predictable IDs simplify debugging and log correlation.
6. MUST connect Loop Over Items output 0 to the loop body and output 1 to the post-loop node -- because reversed connections cause infinite loops or skipped processing.

Common Node Reference

type

typeVersion

n8n-nodes-base.scheduleTrigger

1.1

n8n-nodes-base.manualTrigger

1

n8n-nodes-base.webhook

2

n8n-nodes-base.httpRequest

4.2

n8n-nodes-base.splitInBatches

3

n8n-nodes-base.code

2

n8n-nodes-base.if

2

n8n-nodes-base.set

3.4

n8n-nodes-base.noOp

1

n8n-nodes-base.hubspot

2

n8n-nodes-base.salesforce

1

n8n-nodes-base.googleSheets

4.5

n8n-nodes-base.slack

2.2

n8n-nodes-base.postgres

2.5

n8n-nodes-base.mySql

2.4

HTTP Request Node Pattern for Personize

{
  "id": "pz-api-001",
  "name": "Personize: Batch Memorize",
  "type": "n8n-nodes-base.httpRequest",
  "typeVersion": 4.2,
  "position": [860, 300],
  "parameters": {
    "method": "POST",
    "url": "https://agent.personize.ai/api/v1/batch-memorize",
    "authentication": "predefinedCredentialType",
    "nodeCredentialType": "httpHeaderAuth",
    "sendBody": true,
    "specifyBody": "json",
    "jsonBody": "={{ JSON.stringify($json.payload) }}",
    "options": {
      "response": { "response": { "fullResponse": true } }
    }
  },
  "credentials": {
    "httpHeaderAuth": {
      "id": "pz-cred",
      "name": "Personize API Key"
    }
  }
}

Expression Syntax

• {{ $json.fieldName }}

  — field from previous node

• {{ $('Node Name').item.json.field }}

  — field from a specific node

• {{ JSON.stringify($json) }}

  — entire previous output as JSON string

• ={{ expression }}

  — prefix for expression mode in parameter values

Workflow Pattern 1: Sync IN (Source App → Personize)

[Trigger] → [Fetch Records] → [Build Payload] → [Batch Memorize] → [Done]

When to use Loop Over Items vs. Single Call

• Single

  batch-memorize

  call (preferred): When the source returns all rows at once and total rows < 500. The Code node builds the entire

  { source, mapping, rows }

  payload and one HTTP Request sends it.
• Loop Over Items with chunking: When source returns thousands of rows. Split into chunks of 50-100, send each chunk as a separate

  batch-memorize

  call with a Wait node for rate limits.

Code Node: Build batch-memorize Payload

batch-memorize

// Input: array of source records from previous node
const items = $input.all();

const rows = items.map(item => item.json);

const payload = {
  source: 'n8n-sync',
  mapping: {
    entityType: 'contact',
    email: 'email',           // source field name containing email
    runName: 'n8n-sync-' + Date.now(),
    properties: {
      // Structured fields — stored directly
      email:      { sourceField: 'email',      collectionId: 'YOUR_COL_ID', collectionName: 'Contacts Standard Schema' },
      first_name: { sourceField: 'firstname',  collectionId: 'YOUR_COL_ID', collectionName: 'Contacts Standard Schema' },
      last_name:  { sourceField: 'lastname',   collectionId: 'YOUR_COL_ID', collectionName: 'Contacts Standard Schema' },
      company:    { sourceField: 'company',    collectionId: 'YOUR_COL_ID', collectionName: 'Contacts Standard Schema' },
      // AI extraction fields — extractMemories: true
      notes: {
        sourceField: 'notes',
        collectionId: 'YOUR_GEN_COL_ID',
        collectionName: 'Generated Content',
        extractMemories: true,
      },
    },
  },
  rows: rows,
  chunkSize: 1,
};

return [{ json: { payload } }];

YOUR_COL_ID

YOUR_GEN_COL_ID

GET /api/v1/collections

client.collections.list()

Per-Property

extractMemories

Decision

Rule of thumb: Set

extractMemories: true

on free-form text (notes, transcripts, emails). Omit it for structured fields (email, name, dates, counts). See the

entity-memory

skill's

reference/memorize.md

for the complete decision table and examples.

Workflow Pattern 2: Sync OUT (Personize → Destination App)

[Trigger] → [Export from Personize] → [Loop Over Items] → [Push to Destination] → [Done]

Code Node: Build Export Query

return [{
  json: {
    groups: [{
      id: 'g1',
      logic: 'AND',
      conditions: [
        { property: 'company', operator: 'IS_SET' }
      ]
    }],
    type: 'Contact',
    returnRecords: true,
    pageSize: 100,
    includeMemories: false
  }
}];

Export Filter Operators

EQ

NEQ

CONTAINS

GT

LT

IS_SET

IS_NOT_SET

IN

Workflow Pattern 3: Per-Record AI Enrichment

[Trigger] → [Fetch Record] → [Smart Digest] → [AI Prompt] → [Push Result]

smart-memory-digest

Code Node: Build Smart Digest Request

const email = $json.email;
return [{
  json: {
    email: email,
    type: 'Contact',
    token_budget: 2000,
    include_properties: true,
    include_memories: true
  }
}];

Code Node: Build AI Prompt Request

const context = $('Personize: Smart Digest').item.json.data.compiledContext;
const email = $('Personize: Smart Digest').item.json.data.properties?.email || '';

return [{
  json: {
    prompt: `Using the context below, write a personalized outreach email for ${email}.\n\nContext:\n${context}`,
    model: 'claude-sonnet-4-6'
  }
}];

Workflow Pattern 4: Webhook → Memorize (Real-time Sync)

[Webhook] → [Transform] → [Memorize Pro] → [Respond]

Webhook Node

{
  "id": "pz-webhook-001",
  "name": "Webhook",
  "type": "n8n-nodes-base.webhook",
  "typeVersion": 2,
  "position": [200, 300],
  "parameters": {
    "path": "personize-ingest",
    "httpMethod": "POST",
    "responseMode": "lastNode"
  }
}

Code Node: Build memorize_pro Payload

const data = $json.body || $json;
return [{
  json: {
    content: `Name: ${data.name}\nEmail: ${data.email}\nCompany: ${data.company}\nNotes: ${data.notes || ''}`,
    speaker: data.source || 'webhook',
    enhanced: true,
    tags: ['webhook', 'real-time'],
    email: data.email
  }
}];

Rate Limit Handling in n8n

Option A: Retry on Fail (Recommended)

{
  "retryOnFail": true,
  "maxTries": 3,
  "waitBetweenTries": 60000
}

Option B: Wait Node Between Batches

n8n-nodes-base.wait

{
  "id": "pz-wait-001",
  "name": "Rate Limit Wait",
  "type": "n8n-nodes-base.wait",
  "typeVersion": 1.1,
  "position": [1080, 300],
  "parameters": {
    "amount": 62,
    "unit": "seconds"
  }
}

GET /api/v1/me

Building a Workflow: Step-by-Step

Step 1: Identify the direction

• Sync IN = data flows into Personize (use

  batch-memorize

  or

  memorize_pro

  )
• Sync OUT = data flows out of Personize (use

  export

  or

  recall_pro

  or

  smart-memory-digest

  )
• Bidirectional = combine both patterns in one workflow

Step 2: Choose the trigger

• Schedule — for periodic batch syncs (hourly, daily)
• Webhook — for real-time event-driven ingestion
• Manual — for testing and one-time imports

Step 3: Choose source/destination nodes

Step 4: Build the mapping

• The source field name (from the source app)
• The target property name (in Personize)
• Whether it needs AI extraction (

  extractMemories: true

  )

Step 5: Generate the workflow JSON

templates/

• Node names (descriptive of the actual source/destination)
• API URLs and endpoints
• Code node logic for field mapping
• Credential references
• Schedule interval

Step 6: Add error handling

• Set

  retryOnFail: true

  on all HTTP Request nodes hitting Personize
• Add Wait nodes between batches if syncing > 50 records
• Optionally add an IF node after the API call to check

  {{ $json.success }}

  and handle errors

Step 7: Output the JSON

.json

1. Open n8n
2. Create a new workflow
3. Menu > Import from File (or Ctrl+V to paste)
4. Create the Personize API Key credential (Header Auth with

   Authorization: Bearer sk_live_...

   )
5. Create credentials for the source/destination app
6. Test with Manual Trigger first, then activate the Schedule Trigger

Template Workflows

templates/

templates/hubspot-to-personize.json

templates/personize-to-slack.json

templates/webhook-to-personize.json

templates/gsheets-to-personize.json

n8n App Integrations (400+)

Reference Documentation & Search Queries