Skip to main content
HashnodeV DevV Dev

Command Palette

Search for a command to run...

Supercharge Your Zapier and n8n Workflows with Real Python

Your visual builder is great at connecting apps. Let Virtuality Run handle the code.

Published
•7 min read
Supercharge Your Zapier and n8n Workflows with Real Python
V
V.D.

Zapier and n8n are powerful. They connect hundreds of apps, automate repetitive tasks, and save teams countless hours. We're not here to replace them.

But every Zapier and n8n user hits the same wall: the code node.

You need to parse a messy API response. Transform a CSV. Score a lead with custom logic. Run a calculation that doesn't fit in an expression field. So you open the code node — and the limitations start piling up.

What if your code nodes had no limits?

The code node problem

Both Zapier and n8n offer code execution steps. On paper, they let you write custom logic. In practice, they're frustratingly limited.

Zapier's "Code by Zapier"

  • No external packages. You can't use pandas, BeautifulSoup, numpy, or any custom PyPI library. You're stuck with vanilla JavaScript or Python's standard library (with an exception for requests).

  • Strict timeouts. Depending on your plan, scripts time out in as little as 10 to 30 seconds. Long-running operations — API pagination, batch processing, web scraping — simply fail.

  • No file handling. You can't read, write, or process files. No CSV parsing, no PDF generation, no image manipulation.

  • No testing. You write code in a tiny text box, hit "Test," and hope. There's no way to write unit tests or validate edge cases before it runs in production.

  • Payload and memory limits. Large data payloads or memory-intensive scripts will often crash the node without clear warnings.

n8n's code nodes

n8n is more flexible, but still constrained:

  • Limited package support. The cloud version restricts which npm packages you can import. n8n also recently added Python, but on the Cloud version, you are restricted to basic Pyodide packages—you cannot import arbitrary third-party libraries.

  • No persistent environment. Every execution starts cold. No caching, no state, no warm connections.

  • No test framework. You test by running the full workflow. There's no way to unit test a single code node.

  • Debugging is painful. Console output is limited. Complex logic spread across multiple code nodes becomes hard to trace and maintain.

  • Scaling limits. Heavy compute tasks (data processing, ML inference, large file handling) can choke the n8n worker, affecting other workflows.

The core issue is the same: code nodes are an afterthought. They exist so you can write a quick expression or format a string — not run real software.

A different approach: offload the code

Instead of fighting your code node's limitations, what if you could call a full Python environment from your Zapier zap or n8n workflow?

That's exactly what Virtuality Run does.

How it works

  1. Write your logic in Virtuality Run — full Python, any PyPI package, with a browser-based IDE and AI assistant.

  2. Test it — write pytest tests and verify everything works before going live.

  3. Deploy it — your workflow gets a unique HTTPS endpoint.

  4. Call it from Zapier or n8n — use an HTTP request node to send data in and get results back.

Your visual builder handles what it's best at — connecting apps, routing events, managing triggers. Virtuality Run handles what it's best at — running real code.

Example: enriching leads with web scraping

Say you have a Zapier zap that triggers when a new lead comes into your CRM. You want to scrape the lead's company website and extract key information.

In Zapier alone, this is nearly impossible. There's no BeautifulSoup, no HTML parsing, no way to follow links or handle JavaScript-rendered pages.

With Virtuality Run, you write the scraping logic once:

import requests
from bs4 import BeautifulSoup

def run(company_url: str):
    response = requests.get(company_url, timeout=10)
    soup = BeautifulSoup(response.text, "html.parser")
    
    description = soup.find("meta", {"name": "description"})
    title = soup.find("title")
    
    # Extract social links
    social_links = []
    for a in soup.find_all("a", href=True):
        href = a["href"]
        if any(domain in href for domain in ["linkedin.com", "twitter.com", "github.com"]):
            social_links.append(href)
    
    return {
        "title": title.text.strip() if title else None,
        "description": description["content"] if description else None,
        "social_links": list(set(social_links)),
    }

Enable the API trigger, deploy it, and now your Zapier zap calls it with a single HTTP request:

POST [https://run-staging.virtualityhub.com/api/prod/workflows/](https://run-staging.virtualityhub.com/api/prod/workflows/){id}/trigger
Headers: x-api-key: your_key
Body: { "inputs": { "company_url": "[https://example.com](https://example.com)" } }

The response comes back as structured JSON. Zapier maps it to your CRM fields. Done.

Example: processing CSV files in n8n

You have an n8n workflow that receives a CSV export from a client. You need to clean the data, deduplicate rows, and calculate aggregates before loading it into your database.

In n8n's code node, you'd struggle with limited package access, memory constraints, and no way to test the transformation logic in isolation.

With Virtuality Run:

import pandas as pd
import io

def run(csv_content: str):
    df = pd.read_csv(io.StringIO(csv_content))
    
    # Clean and deduplicate
    df = df.drop_duplicates(subset=["email"])
    df["email"] = df["email"].str.lower().str.strip()
    df = df.dropna(subset=["email", "amount"])
    
    # Aggregate
    summary = {
        "total_rows": len(df),
        "total_amount": float(df["amount"].sum()),
        "unique_customers": int(df["email"].nunique()),
        "average_amount": float(df["amount"].mean()),
    }
    
    return {
        "cleaned_data": df.to_dict(orient="records"),
        "summary": summary,
    }

Your n8n workflow sends the CSV content to Virtuality Run via HTTP request and gets back clean, structured data ready for your database insert node.

Example: AI-powered text analysis

You want to classify support tickets that arrive in Zapier. Sentiment analysis, category detection, priority scoring — none of this is possible in a Zapier code step.

With Virtuality Run, you use any Python NLP library:

from textblob import TextBlob

def run(ticket_text: str, customer_tier: str = "standard"):
    blob = TextBlob(ticket_text)
    sentiment = blob.sentiment.polarity
    
    # Simple keyword-based categorization
    categories = {
        "billing": ["invoice", "charge", "payment", "refund", "subscription"],
        "technical": ["error", "bug", "crash", "slow", "broken", "not working"],
        "feature": ["feature", "request", "suggestion", "would like", "wish"],
    }
    
    detected_category = "general"
    for category, keywords in categories.items():
        if any(kw in ticket_text.lower() for kw in keywords):
            detected_category = category
            break
    
    # Priority scoring
    priority = "normal"
    if sentiment < -0.3 or customer_tier == "enterprise":
        priority = "high"
    if "urgent" in ticket_text.lower() or "down" in ticket_text.lower():
        priority = "critical"
    
    return {
        "sentiment": round(sentiment, 2),
        "category": detected_category,
        "priority": priority,
    }

Zapier calls the endpoint, gets back the classification, and routes the ticket accordingly. The logic is testable, version-controlled, and easy to update.

Why this works better than "just use a code node"

Feature

Code Node

Virtuality Run Endpoint

Packages

Standard libraries only (Zapier) / Heavily restricted (n8n Cloud)

Any PyPI package

Timeout

10–30s (Zapier) / Limited (n8n)

Up to 60 minutes

Testing

Manual only

pytest with pass/fail before deploy

IDE

Tiny text box

Full Monaco editor with AI assistant

Version control

None

Commit history, diff viewer, rollback

Debugging

console.log / print() and hope

Full stdout/stderr logs per run

Environments

One

Dev / staging / production

File handling

Painful or non-existent

Full file I/O with output storage

Maintenance

Edit inline, no review

Code review, test, deploy workflow

The pattern is simple: let your visual builder orchestrate, let Virtuality Run compute.

Getting started

Setting up a Virtuality Run endpoint for your Zapier or n8n workflow takes about 5 minutes:

  1. Sign up at run-staging.virtualityhub.com

  2. Create a workflow and write your Python logic (or let the AI generate it)

  3. Write tests to make sure it works

  4. Enable the API trigger in the config and deploy

  5. Copy the endpoint URL and API key into your Zapier HTTP action or n8n HTTP Request node

That's it. Your visual builder now has a full Python backend.

You don't have to choose

This isn't Zapier vs. Virtuality Run. It's not n8n vs. Virtuality Run. It's Zapier or n8n plus Virtuality Run.

Keep using your visual builder for what it does best — connecting apps, managing triggers, routing data. When you hit a wall that needs real code, don't fight the code node. Call a Virtuality Run endpoint instead.

Your workflows get the best of both worlds: visual simplicity for orchestration, full Python power for computation.

Virtuality Run is in preview. Read the documentation to learn more.

#virtuality#ai#n8n#diy#zapier#automation#software-development
14 views