Skip to main content
The Script block allows you to execute custom JavaScript code within your bot flow, enabling advanced logic, external API calls, and browser interactions.
This block doesn’t allow you to create a custom visual block
Code block

​
Configuration Options

​
Execution Environment

  • Execute on Client: Toggle between server-side and client-side execution
  • Script Name: Optional identifier for organizing and debugging scripts
  • Code Editor: Full-featured JavaScript editor with syntax highlighting and variable support
  • Variable Integration: Direct access to bot variables within your code

​
Server vs Client Execution

  • Server-side (Default): Secure, isolated environment with limited APIs
  • Client-side: Full browser access but requires user’s browser capabilities
  • Security Considerations: Server-side prevents malicious code execution
Variables in script are not parsed, they are evaluated. So it should be treated as if it were real javascript variables.You need to write console.log({{My variable}}) instead of console.log("{{My variable}}")

​
Features

​
Variable Management

Use the setVariable function to modify bot variables programmatically: 
if({{My variable}} === 'foo') {
  setVariable('My variable', 'bar')
} else {
  setVariable('My variable', 'other')
}
Important: setVariable is only available in server-side execution, not when “Execute on client” is enabled.

​
API Integration

Make HTTP requests to external services using the built-in fetch function: 
// Server-side fetch (simplified response handling)
const data = await fetch('https://api.example.com/data')
const parsed = JSON.parse(data) // If response is JSON

// Set results in variables
setVariable('API Response', parsed.result)

​
Conditional Logic

Implement complex business logic that’s difficult to achieve with standard blocks: 
// Complex conditional logic
const score = parseInt({{User Score}})
const category = {{User Category}}

if (score > 80 && category === 'premium') {
  setVariable('Qualification', 'gold')
  setVariable('Discount', 25)
} else if (score > 60) {
  setVariable('Qualification', 'silver')
  setVariable('Discount', 15)
} else {
  setVariable('Qualification', 'bronze')
  setVariable('Discount', 5)
}

​
Advanced Features

​
External API Calls

Integrate with third-party services and APIs: 
// CRM integration example
const customerData = {
  name: {{Customer Name}},
  email: {{Customer Email}},
  score: {{Lead Score}}
}

const response = await fetch('https://api.crm.com/leads', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_API_KEY'
  },
  body: JSON.stringify(customerData)
})

const result = JSON.parse(response)
setVariable('CRM Lead ID', result.id)

​
Data Processing

Process and transform user data: 
// Process array data
const responses = {{Survey Responses}} || []
const processed = responses
  .filter(item => item.length > 0)
  .map(item => item.toUpperCase())
  .join(', ')

setVariable('Processed Responses', processed)

​
Browser Interactions (Client-side)

Access browser APIs when “Execute on client” is enabled: 
// Get user's location
navigator.geolocation.getCurrentPosition(
  (position) => {
    setVariable('User Latitude', position.coords.latitude)
    setVariable('User Longitude', position.coords.longitude)
  },
  (error) => {
    setVariable('Location Error', error.message)
  }
)

​
Server-side Limitations

Because server scripts run in an isolated, secure environment:

​
Unavailable APIs

  • Console Functions: console.log, setTimeout, setInterval not available
  • Browser APIs: No access to window, document, localStorage, etc.
  • Node.js Modules: Cannot use import or require statements
  • Global Objects: Limited global scope compared to browser environment

​
Modified Fetch Behavior

The fetch function works differently on the server: 
// ❌ Standard fetch pattern doesn't work
const response = await fetch('https://api.example.com/data')
const data = await response.json() // This will fail

// ✅ Simplified server-side fetch
const data = await fetch('https://api.example.com/data')
const parsed = JSON.parse(data) // Parse manually if JSON
Response is always returned as a string, even for JSON responses.

​
Best Practices

​
Code Organization

  • Single Responsibility: Keep scripts focused on specific tasks
  • Error Handling: Always include try-catch blocks for external calls
  • Variable Naming: Use clear, descriptive variable names
  • Comments: Document complex logic for team collaboration

​
Performance Optimization

  • Minimal Processing: Keep scripts lightweight to avoid delays
  • Async Operations: Use await appropriately for API calls
  • Caching: Store results in variables to avoid repeated API calls
  • Timeout Handling: Implement proper error handling for slow operations

​
Security Considerations

  • Input Validation: Validate variable data before processing
  • API Key Management: Use environment variables for sensitive data
  • Data Sanitization: Clean user input before external API calls
  • Error Messages: Avoid exposing sensitive information in error messages

​
Client vs Server Decision

  • Use Server-side for: API calls, data processing, security-sensitive operations
  • Use Client-side for: Browser APIs, user interactions, real-time features
  • Consider Performance: Client-side reduces server load but depends on user’s device

​
Example Use Cases

​
CRM Integration

// Update CRM with form data
const leadData = {
  name: {{Full Name}},
  email: {{Email}},
  phone: {{Phone Number}},
  source: 'chatbot'
}

const response = await fetch('https://api.yourcrm.com/leads', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify(leadData)
})

setVariable('CRM Updated', response.success)

​
Dynamic Pricing

// Calculate dynamic pricing
const basePrice = 100
const userType = {{User Type}}
const volume = parseInt({{Order Volume}}) || 1

let discount = 0
if (userType === 'premium') discount = 0.2
else if (userType === 'standard') discount = 0.1

if (volume > 10) discount += 0.05

const finalPrice = basePrice * volume * (1 - discount)
setVariable('Final Price', finalPrice.toFixed(2))

​
Browser Page Control (Client-side)

// Redirect based on conditions
if({{Category}} === 'qualified') {
  window.location.href = 'https://my-site.com/qualified'
} else {
  window.location.href = 'https://my-site.com/info'
}

​
Troubleshooting

​
Common Script Errors

  • Variable Access: Ensure variables exist and contain expected data types
  • Syntax Errors: Check JavaScript syntax and bracket matching
  • Async Issues: Use await with Promise-based operations
  • Type Errors: Validate variable types before processing

​
Server-side Issues

  • Fetch Errors: Remember server-side fetch returns strings directly
  • Missing Functions: Global browser functions aren’t available
  • API Timeouts: Implement proper error handling for external calls
  • Memory Limits: Keep scripts efficient to avoid timeout issues

​
Client-side Issues

  • Browser Compatibility: Test across different browsers and devices
  • Security Restrictions: Some browsers block certain operations
  • Network Issues: Handle offline scenarios gracefully
  • Mobile Limitations: Consider mobile browser capabilities

​
Performance Problems

  • Slow Execution: Optimize loops and reduce API calls
  • Memory Usage: Clean up variables and avoid memory leaks
  • Network Delays: Implement reasonable timeouts for external calls
  • Error Recovery: Provide fallbacks when scripts fail
⌘I