Have you ever stared at your screen, anxiously waiting for a long Houdini render to finish? Do you find yourself refreshing the render view or checking task managers every few minutes?
Manually monitoring render progress can interrupt your workflow and lead to wasted time. You might miss the moment your scene is ready or struggle to balance other tasks while the render runs.
In this guide, you’ll learn how to automate notifications so you receive an email exactly when your Houdini render completes. No more constant checking or overlooked finishes.
We’ll walk you through simple steps using built-in tools and minimal scripting. By the end, you’ll have a reliable system that frees you to focus on creativity instead of waiting on renders.
Why should I get an email when my Houdini render finishes?
Waiting beside your workstation until a long Houdini render completes is an inefficient use of time. Whether you’re running a GPU-accelerated Mantra sequence or a complex Solaris LOP network, builds can stretch for hours. An automated email notification lets you move on to other tasks, meetings, or simply take a break, knowing you’ll be alerted the moment frames are ready.
In a production environment, render queues often live on remote farms or headless servers via hbatch. Without notifications, you risk discovering failures late, potentially after you’ve left for the day. Immediate emails help you:
- Catch render errors or nuke noise artifacts as soon as they occur, reducing turnaround time.
- Track resource usage—if a job hangs or spikes memory, the callback can include log excerpts.
- Coordinate multi-pass workflows by triggering downstream compositing scripts once all beauty passes finish.
Ultimately, integrating email alerts into your Houdini pipeline turns long renders from guessing games into predictable milestones. You’ll spend less time monitoring and more time iterating on lighting, shading, or sim tweaks—confident that each completed render lands in your inbox without you watching a progress bar.
What prerequisites do I need (Houdini version, Python, SMTP/API keys, network access)?
To trigger an email from your renderer, verify you’re on Houdini 18.5 or higher. Versions earlier than 18.0 use Python 2, which limits modern libraries. Houdini’s built-in Python interpreter (accessible via hython or Python SOPs) must support SMTP or HTTP modules.
Install required Python packages—typically smtplib for SMTP or requests for REST APIs—into Houdini’s Python site-packages folder. You can pip-install against Houdini’s interpreter: hython -m pip install requests.
Prepare your mailing credentials: for SMTP, you need host, port (e.g., 587), username, and password. For transactional email APIs (SendGrid, Mailgun), request an API key and note the endpoint URL and auth header format.
Ensure network access from your render machine: open outbound TCP ports (SMTP 25/587 or API 443). On managed render farms, configure firewalls or proxies so the hython process can reach external servers without interruption.
How do I add a Python callback in Houdini to detect render completion and send an email?
Houdini’s ROP nodes include a Scripts tab where you can attach Python code to run when a render starts or finishes. By placing an SMTP send routine in the “Stop Script” field, you capture the exact moment Houdini completes the render and trigger an email. This method uses hou.pwd() to reference the current ROP dynamically and requires minimal setup in the GUI.
Example Houdini Python callback (using hou module) with a simple SMTP send
Open your ROP node’s Scripts tab, select “Python” for the Stop Script, and paste:
import smtplib
from email.mime.text import MIMEText
node = hou.pwd()
out_path = node.evalParm("vm_picture")
subject = f"Render Complete: {node.name()}"
body = f"Your render finished. Output file: {out_path}"
msg = MIMEText(body)
msg["Subject"] = subject
msg["From"] = "us**@*****le.com"
msg["To"] = "ar****@*****le.com"
server = smtplib.SMTP("smtp.example.com", 587)
server.starttls()
server.login("user", "password")
server.sendmail(msg["From"], [msg["To"]], msg.as_string())
server.quit()
This code uses hou.pwd() to pull the current node, evalParm() to retrieve the output path, and Python’s smtplib to send the email. Adjust SMTP credentials and ports to match your mail server.
How to test the callback locally and verify logs
Before running a full render, create a one-frame test and enable Houdini’s Python Shell (Windows > Python Source Editor). Add a print() or Python logging call right after the email code to confirm execution:
- Render a single frame; watch the Python Shell for your debug message.
- Check your email inbox and spam folder to confirm delivery.
- If no message appears, inspect Houdini’s Help > Python Shell for exceptions.
For persistent logs, import Python’s logging module and write to a file path you control. This ensures you capture errors when Houdini runs headless on a render farm.
How do I securely send emails from Houdini: SMTP vs Email API (SendGrid/Mailgun) and credential handling?
Choosing between SMTP and an Email API affects security, deliverability, and integration complexity. SMTP uses standard mail ports (usually 587 for TLS) via Python’s smtplib. Email APIs like SendGrid or Mailgun offer REST endpoints, JSON payloads, built-in analytics, and higher throughput. In Houdini you implement these in a Python callback triggered by hbatch or HQueue when a render completes.
| Criteria | SMTP | Email API |
|---|---|---|
| Authentication | Username/Password over TLS | Bearer token (API Key) |
| Throughput | Limited by server settings | High, rate-limited by plan |
| Integration | Python smtplib in hython callback | requests or official SDK |
| Monitoring | Server logs only | Real-time analytics, webhooks |
Proper credential handling ensures pipeline security. Never hardcode secrets in .hip files or version control. Use these strategies:
- Environment variables: Houdini’s hython scripts access os.environ to read SMTP passwords or API keys.
- .env files with python-dotenv: Load keys at runtime without exposing them in code.
- ~/.netrc on Linux/macOS: Store SMTP credentials; let Python’s netrc module parse them automatically.
In your render-finished callback (hython or hbatch), read the credentials from the environment or .netrc, then initialize smtplib.SMTP or an Email API client. This approach keeps secrets out of scene files, maintains repeatable builds, and scales across artists and render nodes.
How can I use render managers or render farms (Deadline, Tractor, GridMarkets) to handle notifications instead?
Rather than adding custom email scripts inside Houdini, you can leverage a dedicated render farm or render manager that already supports built-in notifications. Tools like Deadline, Tractor, and GridMarkets centralize job submission and let you configure email alerts at the job level. This offloads the complexity of hooking into Houdini and keeps your local workstation free of notification logic.
In Deadline, you simply submit your Houdini ROP job via Deadline Monitor or the command line (DeadlineCommand). Under the job’s “Notification” pane you can enable “On Job Complete” and provide recipient addresses. Deadline ships with an EmailNotificationEvent plugin; you only need to adjust the SMTP settings in the Repository’s DeadlineEvents.ini. When the farm finishes your job, Deadline triggers the event and sends the email automatically.
Tractor uses a similar approach but relies on per-task completion scripts. When you submit through the Tractor tsk command or the Tractor Houdini submitter, include a post-task hook:
- Define a shell or Python script (e.g.
notify.sh) that callsmailxor an API. - In your Tractor job spec, under
post, reference that script. - Tractor will execute it on the farm’s head node after each render task.
For GridMarkets, the cloud platform exposes email notifications directly in its web UI. Upon upload of your .hip and asset archive, you tick “Email me when done” and supply your address. GridMarkets handles staging, rendering across Linux or Windows nodes, and automatically pings you when it detects exit codes of your Houdini ROPs.
Using a farm or manager lets you:
- Maintain a single configuration for emails
- Avoid breaking your local pipeline when Houdini updates
- Scale out both renders and notifications in one system
By relying on Deadline, Tractor, or GridMarkets, you gain robust retry logic, centralized logs, and enterprise-grade email alerts—all without writing custom post-render scripts inside Houdini itself.
How do I troubleshoot common issues (no email, auth errors, firewall, render job detection)?
When your Houdini render finishes but no notification arrives, start by isolating the failure point. First, confirm that your Python or Hython script actually runs. Next, verify outbound connectivity to your SMTP server. Finally, ensure your render callback is firing at the correct moment. Each of these steps addresses a different failure mode.
No email: Open Houdini’s Console (Help → Windows → Console) and look for your script’s print statements. If you see “Email sent” in the log but nothing arrives, the issue lies downstream—likely SMTP or firewall. If you see no script messages, double-check that you placed your code in the ROP’s “On Job Complete” callback or in an afterTOP script for PDG tasks.
Authentication errors: SMTP servers often require TLS on port 587 or SSL on port 465. In Python, use smtplib.SMTP(‘smtp.example.com’, 587) then starttls() before login(). Test credentials outside Houdini in a local Python REPL. Store passwords in environment variables or Houdini’s HOUDINI_PATH to avoid embedding secrets in your scene.
Firewall restrictions: Corporate networks may block outbound SMTP. On Windows or Linux, run telnet smtp.example.com 587. A successful banner confirms port access. If that fails, request your network admin to whitelist the mail server IP or use a REST-based mail API over port 443, which is almost always open.
Render job detection: Rely on Houdini callbacks rather than polling. In a ROP output node, open the “Scripts” tab and paste your send_email() call into the “Post-Render Script” field. For Solaris or Karma, use the LOP’s “Callback” parameter. In PDG, attach a Python Processor to the final TOP with an onComplete handler. This precise hook ensures the email fires exactly when Houdini finishes writing the last frame.
- Verify console logs to confirm script execution.
- Test SMTP login in a standalone Python shell.
- Check network port access with telnet or netcat.
- Use Houdini ROP/PDG callbacks instead of external polling.
