# JANCTION Render > JANCTION Render is a cloud GPU rendering API and MCP server for Blender: a Blender render farm that AI agents can call as a tool. Render Blender scenes (.blend, a bpy Python script, or a 3D file such as glTF / FBX / USD / OBJ) on JANCTION NVIDIA GPUs from Claude, ChatGPT, Claude Code, Codex, Cursor or any MCP client, without a local GPU. Free beta: nothing is charged. Inputs and results are deleted 24 hours after last use. Updated 2026-10-02. ## When to use JANCTION Render Use it when: - the user asks to render a Blender .blend file or a bpy script (an image, frames or an animation/MP4) - an AI coding agent created a Blender scene and needs the final image or video - the machine has no NVIDIA GPU, or local Blender rendering is slow - many frames need GPU rendering (frames are split across GPUs and joined into an MP4) - a model exported from another tool (glTF/GLB, FBX, USD, OBJ, STL, PLY, Alembic) should be rendered with Cycles - a quick look at a scene is needed before committing to a long render (render_preview, a few GPU seconds) Do not use it for: - modeling or editing a scene without rendering (use a local Blender or a Blender editing MCP; render the result here) - non-Blender workloads (video encoding, game engines, generic GPU compute) Guides (English): https://render.janction.jp/blender-render-farm · https://render.janction.jp/blender-cloud-rendering · https://render.janction.jp/render-blender-without-gpu · https://render.janction.jp/free-blender-cloud-rendering · https://render.janction.jp/blender-mcp · https://render.janction.jp/claude-blender · https://render.janction.jp/chatgpt-blender · https://render.janction.jp/claude-code-blender · https://render.janction.jp/codex-blender · https://render.janction.jp/bpy-script-cloud-gpu · https://render.janction.jp/blender-render-api · https://render.janction.jp/blender-render-farm-api-comparison · https://render.janction.jp/faq · https://render.janction.jp/blender-mcp-comparison · https://render.janction.jp/google-colab-vs-janction-render Guides (Japanese): https://render.janction.jp/ja/blender-render-farm · https://render.janction.jp/ja/blender-cloud-rendering · https://render.janction.jp/ja/render-blender-without-gpu · https://render.janction.jp/ja/free-blender-cloud-rendering · https://render.janction.jp/ja/blender-mcp · https://render.janction.jp/ja/claude-blender · https://render.janction.jp/ja/chatgpt-blender · https://render.janction.jp/ja/claude-code-blender · https://render.janction.jp/ja/codex-blender · https://render.janction.jp/ja/bpy-script-cloud-gpu · https://render.janction.jp/ja/blender-render-api · https://render.janction.jp/ja/blender-render-farm-api-comparison · https://render.janction.jp/ja/faq · https://render.janction.jp/ja/blender-mcp-comparison · https://render.janction.jp/ja/google-colab-vs-janction-render Full text of all guides in one file: https://render.janction.jp/llms-full.txt · Japanese summary: https://render.janction.jp/ja/llms.txt Measured times (real jobs, GPU seconds by resolution/frames/samples, prompts used): https://render.janction.jp/benchmarks (JSON: /benchmarks.json) OpenAPI 3 spec of the HTTP API: https://render.janction.jp/openapi.json · Live status (workers, queue, 7-day success rate): https://render.janction.jp/status and /v1/health ## Connect (remote MCP, no install) - MCP server URL: https://render.janction.jp/mcp (Streamable HTTP). Auth: OAuth 2.1 with dynamic client registration (a consent page creates a free API key), or `Authorization: Bearer `. - Claude.ai: Settings > Connectors > Add custom connector > paste the URL. ChatGPT: Settings > Connectors > Advanced > Developer mode > Create > paste the URL. - Claude Code: `claude mcp add --transport http janction-render https://render.janction.jp/mcp` (then `/mcp` to authenticate). Codex: `codex mcp add janction-render --url https://render.janction.jp/mcp`. Cursor and others: Streamable HTTP at the same URL. - Plugins (MCP + workflow skill in one package): Claude Code `/plugin marketplace add JasmyLab-JANCTION/janction-render`; Codex `codex plugin marketplace add JasmyLab-JANCTION/janction-render` (Agent Plugins format, plugins/janction-render) - Remote tools take scene_script (bpy code as text), scene_url (https link to a .blend, .py or 3D file), or scene_id; asset_urls sends textures or glTF .bin files along. Results come back as an inline image plus links valid about 24 hours. Hosts that support MCP Apps (Claude web/desktop and others) also show an interactive panel: preview image, progress bar with ETA, "Open MP4", and preset buttons after environment="compare". ## Install (stdio MCP, sends local files) - Claude Code: `claude mcp add janction-render -e JANCTION_RENDER_SERVER=https://render.janction.jp -- uvx --from janction-render janction-render-mcp` - Codex and other clients: `pip install janction-render`, then run `janction-render-mcp` as a stdio MCP server with JANCTION_RENDER_SERVER=https://render.janction.jp - Package: https://pypi.org/project/janction-render/ · Source: https://github.com/JasmyLab-JANCTION/janction-render · Registry: io.github.JasmyLab-JANCTION/janction-render · Smithery: https://smithery.ai/servers/jasmylab/janction-render - A temporary API key is issued automatically; keep it in JANCTION_RENDER_API_KEY to reuse the same quota/credit - The stdio tools take scene_path (local .blend / .py / 3D file) and assets (local files sent along); a .blend's external files are collected automatically when blender-asset-tracer is installed ## Flow for an agent 1. scene_info(scene_script | scene_url | scene_path) - cameras, frame range, resolution, missing files. No render. 2. render_preview(..., frames="1-24") - up to 4 frames tiled in one image; look at it, fix the scene, repeat. Options: environment (night, overcast, studio, sunset; "compare" renders one frame under all presets in one labelled image), environment_strength, environment_visible, blender (5.0 / 5.2), orbit=true (turntable: a camera circles the scene; the preview shows 0/90/180/270 degrees; render_final with orbit and no frame_end renders one full turn of orbit_frames frames, default 24, as an MP4). 3. Ask the user "is this OK?". 4. render_estimate(scene_id, frame_start, frame_end, width, height, samples) - "about 3 minutes", and whether it fits today's free quota. Tell the user. 5. render_final(scene_id, ...) - returns job_id and the estimate (estimate.human). Use the same environment / blender as the preview. 6. render_status(job_id) until done (eta.human = remaining time incl. queue), then render_download(job_id, only="mp4") for the video (only="frames" for every PNG). 7. billing() shows today's quota (free beta) or the balance. 429 quota_exceeded carries resets_at; 402 payment_required (paid plans) carries checkout_url. render_info() lists workers, queue, supported inputs, environment presets and Blender versions. ## Inputs - A .blend file (send external images as assets, or pack them: File > External Data > Pack Resources), or - A Blender Python (bpy) script that builds the scene: no local Blender needed. Set scene.frame_start/frame_end and add a camera and a light (or pass environment="studio"). If you start from an empty scene (bpy.ops.wm.read_factory_settings(use_empty=True)) you must add a camera, a light and a world yourself; otherwise the service adds an automatic camera and a sun and says so in warnings. Assets sent with the script are in os.environ["JR_ASSETS_DIR"]. - A 3D file: glTF/GLB, FBX, USD/USDA/USDC/USDZ, OBJ, STL, PLY, Alembic. It is imported into an empty scene; an automatic camera and light are added; materials from other tools are approximated by Blender's importers. A .gltf or .obj given as scene_url (or scene_path in the stdio tools) brings its .bin / .mtl / textures from the same folder automatically; the upload response lists "references" that are still missing. - Do not set Material.use_nodes (always on in Blender 5.x; it only produces a deprecation warning). - Blender 5.0 animation API: animate with obj.keyframe_insert(); do not touch obj.animation_data.action.fcurves (removed in 5.0). For linear motion set bpy.context.preferences.edit.keyframe_new_interpolation_type = 'LINEAR' before inserting keyframes. - Engine: Cycles on GPU, Blender 5.0 / 5.2. Resolution, samples and denoising are set by the service; scripts should not rely on their own render settings. A .blend saved with a newer Blender may not open on 5.0; try blender="5.2" or prefer a bpy script. - environment presets: night, overcast, studio, sunset. They replace the scene's world with a bundled HDRI (CC0, Poly Haven). environment_visible=false keeps the lighting but shows a flat grey backdrop. ## Price Free beta: nothing is charged. Limits: 10 GPU-minutes per key per day (20 per network), final renders up to 240 frames and 1080p. When the daily quota is used up the API answers 429 quota_exceeded with resets_at. Planned pricing (0.1 JPY per GPU second, top-up from 500 JPY) will be announced here and in llms.txt before it starts. ## HTTP API - POST /v1/keys -> {api_key} (header X-API-Key afterwards) - POST /v1/files (multipart "file": .blend, .py or a 3D file) -> {scene_id}; POST /v1/files/{id}/assets (multipart "files") adds textures etc.; GET /v1/files/lookup?sha256= reuses an earlier upload - POST /v1/estimate {kind, frames|frame_start/frame_end, width, height, samples, scene_id?} -> seconds, wall_seconds, human, quota (no render) - POST /v1/jobs {scene_id, kind: info|preview|final, frames|frame_start/frame_end, width, height, samples, camera, fps, output, environment, environment_strength, environment_visible, blender, orbit, orbit_frames, orbit_elevation} -> job (+ estimate) - GET /v1/jobs/{id} -> status, progress, eta, artifacts[], cost, warnings, info, expires_at_iso - POST /mcp -> remote MCP (Streamable HTTP; Bearer api key or OAuth). GET /.well-known/oauth-protected-resource/mcp - GET /v1/jobs/{id}/artifacts/{name} -> PNG / MP4 (header X-API-Key) - DELETE /v1/jobs/{id} -> cancel - GET /v1/me -> quota (free beta) or balance · GET /v1/health -> workers (online / gated = GPU lent to another workload), queue, features (inputs, environments, blender_versions) ## Security and data - Your files and scripts run only inside a disposable container: no network, non-root, no capabilities, CPU/memory/time limits, one GPU. The container is destroyed after each job. Scripts that spawn processes, open sockets, use ctypes or dynamic imports, or carry miner signatures are rejected at upload (error script_blocked). - Inputs, intermediate data and results are deleted 24 hours after last use. Nothing is used for training. Logs keep sizes, timings and failure reasons only. - Details: https://render.janction.jp/security · security.txt: https://render.janction.jp/.well-known/security.txt ## Policies - Terms: https://render.janction.jp/terms - Privacy: https://render.janction.jp/privacy - Legal notice (Japan, Act on Specified Commercial Transactions): https://render.janction.jp/legal - Support: https://render.janction.jp/support · FAQ: https://render.janction.jp/faq - Operator: JasmyLab Inc. (Tokyo, Japan) - Contact: contact@jasmylab.com --- # Guides (full text) --- # Blender render farm for AI agents > JANCTION Render is a Blender render farm exposed as an MCP server. An AI agent sends a .blend, a bpy script or a 3D file, gets a 720p preview back in a few GPU seconds, and renders the final frames or an MP4 on JANCTION NVIDIA GPUs. Free beta: 10 GPU-minutes per key per day, no sign-up. URL: https://render.janction.jp/blender-render-farm ## The problem A classic render farm is built for humans: you upload a .blend through a web form, wait, and download. An AI agent that just wrote a Blender scene cannot click through that. It needs a tool it can call, an image it can look at, and a time estimate it can tell the user. ## How JANCTION Render works It is a render farm whose interface is a set of MCP tools. The agent sends the scene, gets a preview back inline, fixes the scene, asks the user, then renders the final frames on JANCTION GPUs (NVIDIA, Cycles). Frames are split across GPUs and joined into an MP4. Results come back as files (stdio) or as links valid for 24 hours (remote). - scene_info reads the scene without rendering: cameras, frame range, objects, missing files. - render_preview renders 1-4 frames at 720p in a few GPU seconds and returns the image, so the agent can look, fix the script and try again. - render_estimate says how long the final render takes ("about 3 minutes") and whether it fits today's free quota. - render_final renders the frames on GPUs and joins them into an MP4; render_status reports the remaining time; render_download returns the files or links. ## Connect | from | how | | Claude.ai (web / desktop / mobile) | Settings → Connectors → Add custom connector → https://render.janction.jp/mcp. "Connect" opens a page that creates a free key | | ChatGPT | Settings → Connectors → Advanced → Developer mode → Create → https://render.janction.jp/mcp (OAuth) | | Claude Code | claude mcp add --transport http janction-render https://render.janction.jp/mcp, then /mcp to authenticate | | Codex | codex mcp add janction-render --url https://render.janction.jp/mcp | | Cursor and other MCP clients | Streamable HTTP at https://render.janction.jp/mcp; OAuth or Authorization: Bearer | | Terminal (stdio, sends local files) | claude mcp add janction-render -e JANCTION_RENDER_SERVER=https://render.janction.jp -- uvx --from janction-render janction-render-mcp | ## Prompt to try ``` Using JANCTION Render, build a glossy red cube rotating on a grey floor and show me a 4-frame preview. If it looks right, render 24 frames at 1280x720 as an MP4. ``` ## What comes back (The 4-frame preview Claude.ai got from that prompt: 4 GPU seconds. The 24-frame 720p MP4 that followed took 58 GPU seconds (2026-10-01, RTX PRO 6000).) ## How long it takes | job | GPU time | note | | preview, 4 frames (720p split in 4 tiles, 16 samples, denoised) | about 4 s | round trip about 8 s; the image comes back inline | | final, 24 frames at 1280x720, 64 samples → MP4 | about 60 s | measured 2026-09-30 / 10-01 (59 s and 58 s) | | final, one 1920x1080 frame at 128 samples | about 11 s | the estimator's baseline; heavy scenes take longer | render_estimate gives the number before rendering; once a scene has been rendered once, the estimate uses that scene's own measurement. ## Free limits Free beta (as of 2026-10-02): 10 GPU-minutes per key per day (20 per network), final renders up to 240 frames at 1080p. No sign-up: connecting creates a key. Inputs and results are deleted 24 hours after last use and never used for training. Paid plans will be announced on this site and in llms.txt before they start. ## How it differs from other render farms - Called as a tool (MCP or HTTP), not through a web form or a Blender add-on; the agent sees the preview image and can fix the scene itself. - A bpy script is a valid input: no Blender needs to be installed on the machine that asks for the render. - Previews are deliberately cheap (a few GPU seconds) so that "look, fix, repeat" costs almost nothing. - Free beta with a daily quota rather than trial credits; nothing is charged today. ## FAQ ### Do I need a Blender install or a GPU? No. A bpy script or a 3D file is enough; the service runs Blender 5.0 with Cycles on its own NVIDIA GPUs. A .blend works too. ### Is it really free? During the beta, yes: 10 GPU-minutes per key per day, final renders up to 240 frames at 1080p. Paid plans will be announced on this site before they start. ### Where do the files go? Inputs and results stay on JANCTION servers for 24 hours after last use, then they are deleted. They are never used for training. ### Which agents can use it? Any MCP client: Claude.ai, ChatGPT, Claude Code, Codex, Cursor. There is also a plain HTTP API and a Python package (janction-render). --- # Blender cloud rendering when you have no GPU > Send the scene (a .blend, a bpy script or a 3D file) to JANCTION Render and the render runs on a datacenter NVIDIA GPU with Blender 5.0 and Cycles. No instance to set up, no driver, no Blender install. A 720p preview takes a few GPU seconds; 24 frames at 720p take about a minute. Free beta. URL: https://render.janction.jp/blender-cloud-rendering ## The problem Cycles on a laptop without a discrete GPU takes minutes per frame; a 240-frame animation is a day. Cloud GPU instances need setup, drivers, a Blender install and a way to move files back and forth. ## How JANCTION Render works Send the scene, get the render. Each job runs in a disposable container on a JANCTION GPU with Blender 5.0 and Cycles; the container has no network access and is destroyed after the job. Turntable. orbit=true makes a camera circle the scene once (default 24 frames): a preview shows four angles, a final render gives the whole turn as an MP4. Handy for an imported model. (A 48-frame turntable (960x540, 24 samples, studio preset) made with render_final(orbit=true) from a bpy script: 76 GPU seconds on JANCTION Render, 2026-10-02.) Inputs: a .blend (send external images along, or pack them: File → External Data → Pack Resources), a bpy Python script (no local Blender needed; set the scene, camera and frame range only, the service sets engine, resolution and samples), or a 3D file (glTF/GLB, FBX, USD, OBJ, STL, PLY, Alembic, imported into an empty scene). A scene without a camera or light gets an automatic one and the response says so under warnings. environment = studio / sunset / overcast / night lights the scene with a bundled HDRI; a preview with environment="compare" shows the same frame under all four presets in one labelled image. (The same scene under the four presets. No lighting work in the script: pick one and the first render already looks finished (rendered by JANCTION Render, 2026-10-02).) ## From the command line ``` pip install janction-render export JANCTION_RENDER_SERVER=https://render.janction.jp janction-render preview my_scene.blend --frames 1-24 # 4 frames tiled in one image janction-render render my_scene.blend --frames 1-240 --wait # output.mp4 ``` ## From an AI agent | from | how | | Claude.ai (web / desktop / mobile) | Settings → Connectors → Add custom connector → https://render.janction.jp/mcp. "Connect" opens a page that creates a free key | | ChatGPT | Settings → Connectors → Advanced → Developer mode → Create → https://render.janction.jp/mcp (OAuth) | | Claude Code | claude mcp add --transport http janction-render https://render.janction.jp/mcp, then /mcp to authenticate | | Codex | codex mcp add janction-render --url https://render.janction.jp/mcp | | Cursor and other MCP clients | Streamable HTTP at https://render.janction.jp/mcp; OAuth or Authorization: Bearer | | Terminal (stdio, sends local files) | claude mcp add janction-render -e JANCTION_RENDER_SERVER=https://render.janction.jp -- uvx --from janction-render janction-render-mcp | ``` Using JANCTION Render, build a glossy red cube rotating on a grey floor and show me a 4-frame preview. If it looks right, render 24 frames at 1280x720 as an MP4. ``` (The 4-frame preview Claude.ai got from that prompt: 4 GPU seconds. The 24-frame 720p MP4 that followed took 58 GPU seconds (2026-10-01, RTX PRO 6000).) ## How long it takes | job | GPU time | note | | preview, 4 frames (720p split in 4 tiles, 16 samples, denoised) | about 4 s | round trip about 8 s; the image comes back inline | | final, 24 frames at 1280x720, 64 samples → MP4 | about 60 s | measured 2026-09-30 / 10-01 (59 s and 58 s) | | final, one 1920x1080 frame at 128 samples | about 11 s | the estimator's baseline; heavy scenes take longer | render_estimate gives the number before rendering; once a scene has been rendered once, the estimate uses that scene's own measurement. ## Free limits Free beta (as of 2026-10-02): 10 GPU-minutes per key per day (20 per network), final renders up to 240 frames at 1080p. No sign-up: connecting creates a key. Inputs and results are deleted 24 hours after last use and never used for training. Paid plans will be announced on this site and in llms.txt before they start. ## Other ways to render without a GPU, compared - CPU rendering at home: free, works for stills, too slow for animations. - Google Colab and similar notebooks: free GPU time exists but is limited and variable; you install Blender yourself each session and move files by hand. - SheepIt: a free distributed farm where you render for others to earn points; good for the community, with a queue and no API for agents. - Commercial render farms (GarageFarm, RebusFarm, Fox Renderfarm and others): mature, add-on based, paid by GPU-hour or credits; built for people, not for tool calls. - Cloud PCs with a GPU (Vagon, iRender): you rent a whole machine by the hour and run Blender in it. - JANCTION Render: a tool call with a preview loop and a free daily quota; no machine to manage. ## FAQ ### Which Blender version renders my file? Blender 5.0 (Cycles on NVIDIA GPUs). A .blend saved with a newer Blender may not open; a bpy script is the most portable input. Blender 5.2 can be selected with blender='5.2' when the worker has that image. ### Can I send textures with my .blend? Yes: the Python package sends files referenced by the .blend automatically (blender-asset-tracer), and the HTTP API and MCP tools accept assets / asset_urls. Packing them into the .blend also works. ### How big can a job be? During the free beta up to 240 frames and 1920x1080 per job, and 10 GPU-minutes per key per day. Split larger animations into several jobs. --- # MCP server for Blender rendering > JANCTION Render is a Model Context Protocol server whose tools render Blender on JANCTION GPUs. It complements Blender MCP servers that edit a scene inside a running Blender: those need Blender and a GPU on your machine, this one needs neither. Remote URL: https://render.janction.jp/mcp. Free beta. URL: https://render.janction.jp/blender-mcp ## Two kinds of "Blender MCP" Most Blender MCP servers (BlenderMCP and others) connect an agent to a Blender running on your machine so it can build and edit a scene. Rendering still happens on your machine. JANCTION Render is the other half: it renders. Use both together: build the scene with a local Blender MCP or a bpy script, render it here. ## Two transports - Remote (Streamable HTTP): https://render.janction.jp/mcp. OAuth 2.1 with dynamic client registration; pressing Connect opens a page that creates a free API key. Scenes are sent as scene_script (bpy code as text), scene_url (https link to a .blend, .py or 3D file) or scene_id; results are an inline image plus links valid 24 hours. For Claude.ai, ChatGPT, Claude Code, Codex, Cursor. - stdio: uvx --from janction-render janction-render-mcp. Reads local files and saves results next to your project. For Claude Code, Codex and other terminal agents. ## Tools | tool | what | | scene_info | read the scene without rendering: cameras, frame range, resolution, objects, missing files | | render_preview | fast preview, 1-4 frames tiled in one image (720p budget), returned inline | | render_estimate | how long it will take and whether it fits today's free quota, before rendering | | render_final | final frames or an MP4, split across GPUs, with a time estimate | | render_status / render_download / render_cancel | progress and remaining time, files or links, cancel | | billing / render_info | free-beta quota; workers online, queue, supported inputs and environment presets | Read-only tools carry readOnlyHint; only render_cancel is destructive. Every tool has a title and a description that says when to use it. ## Connect | from | how | | Claude.ai (web / desktop / mobile) | Settings → Connectors → Add custom connector → https://render.janction.jp/mcp. "Connect" opens a page that creates a free key | | ChatGPT | Settings → Connectors → Advanced → Developer mode → Create → https://render.janction.jp/mcp (OAuth) | | Claude Code | claude mcp add --transport http janction-render https://render.janction.jp/mcp, then /mcp to authenticate | | Codex | codex mcp add janction-render --url https://render.janction.jp/mcp | | Cursor and other MCP clients | Streamable HTTP at https://render.janction.jp/mcp; OAuth or Authorization: Bearer | | Terminal (stdio, sends local files) | claude mcp add janction-render -e JANCTION_RENDER_SERVER=https://render.janction.jp -- uvx --from janction-render janction-render-mcp | ``` Using JANCTION Render, build a glossy red cube rotating on a grey floor and show me a 4-frame preview. If it looks right, render 24 frames at 1280x720 as an MP4. ``` ## Listings Official MCP Registry io.github.JasmyLab-JANCTION/janction-render · Smithery · Glama · PyPI janction-render · GitHub · llms.txt. The GitHub repository is also a plugin marketplace for Claude Code and Codex (/plugin marketplace add JasmyLab-JANCTION/janction-render). ## Free limits Free beta (as of 2026-10-02): 10 GPU-minutes per key per day (20 per network), final renders up to 240 frames at 1080p. No sign-up: connecting creates a key. Inputs and results are deleted 24 hours after last use and never used for training. Paid plans will be announced on this site and in llms.txt before they start. ## FAQ ### Is this the same as BlenderMCP? No. BlenderMCP (ahujasid/blender-mcp) lets an agent control a Blender running on your computer. JANCTION Render renders scenes on JANCTION's GPUs. They work well together. ### Does the remote MCP need an API key? Pressing Connect in Claude.ai or ChatGPT opens a consent page that creates a free key for you. Claude Code and Cursor can also send an existing key as a Bearer token. ### Which MCP spec features are used? Streamable HTTP, OAuth 2.1 with dynamic client registration and PKCE, tool annotations (readOnlyHint, destructiveHint) and tool titles. Protected-resource metadata is at /.well-known/oauth-protected-resource/mcp. --- # Claude Code + Blender rendering > Add the JANCTION Render MCP server to Claude Code (one command), then ask for a scene. Claude Code writes the bpy script, previews it on a JANCTION GPU in a few seconds, fixes it, and renders the final frames or MP4. No local GPU and no local Blender needed. Free beta. URL: https://render.janction.jp/claude-code-blender ## Setup ``` # remote (nothing to install; OAuth creates a free key) claude mcp add --transport http janction-render https://render.janction.jp/mcp # or stdio (sends local files, saves results locally) claude mcp add janction-render -e JANCTION_RENDER_SERVER=https://render.janction.jp -- uvx --from janction-render janction-render-mcp # plugin with the workflow skill /plugin marketplace add JasmyLab-JANCTION/janction-render /plugin install janction-render@janction-render ``` ## Then ask ``` Using JANCTION Render, build a glossy red cube rotating on a grey floor and show me a 4-frame preview. If it looks right, render 24 frames at 1280x720 as an MP4. ``` Or: "Build a small street scene in Blender with a camera fly-through and render a 24-frame preview with janction-render." ## What Claude Code does - scene_info reads the scene without rendering: cameras, frame range, objects, missing files. - render_preview renders 1-4 frames at 720p in a few GPU seconds and returns the image, so the agent can look, fix the script and try again. - render_estimate says how long the final render takes ("about 3 minutes") and whether it fits today's free quota. - render_final renders the frames on GPUs and joins them into an MP4; render_status reports the remaining time; render_download returns the files or links. (The 4-frame preview Claude.ai got from that prompt: 4 GPU seconds. The 24-frame 720p MP4 that followed took 58 GPU seconds (2026-10-01, RTX PRO 6000).) ## How long it takes | job | GPU time | note | | preview, 4 frames (720p split in 4 tiles, 16 samples, denoised) | about 4 s | round trip about 8 s; the image comes back inline | | final, 24 frames at 1280x720, 64 samples → MP4 | about 60 s | measured 2026-09-30 / 10-01 (59 s and 58 s) | | final, one 1920x1080 frame at 128 samples | about 11 s | the estimator's baseline; heavy scenes take longer | render_estimate gives the number before rendering; once a scene has been rendered once, the estimate uses that scene's own measurement. ## Tips for scripts - Add a camera and a light and set the frame range; do not change render settings or call bpy.ops.render.render. - Animate with obj.keyframe_insert(); action.fcurves was removed in Blender 5.0. - Do not set Material.use_nodes (always on in 5.x). Procedural materials work; image textures are sent as assets or packed into a .blend. - Pass environment='studio' (or sunset / overcast / night) for HDRI lighting when you have not set up lights. - Sample: cube_scene.py. ## Free limits Free beta (as of 2026-10-02): 10 GPU-minutes per key per day (20 per network), final renders up to 240 frames at 1080p. No sign-up: connecting creates a key. Inputs and results are deleted 24 hours after last use and never used for training. Paid plans will be announced on this site and in llms.txt before they start. ## FAQ ### Does Claude Code need Blender installed? No. Claude Code writes a bpy script as text and sends it; Blender runs on the JANCTION GPU. ### Remote or stdio: which one? Remote if you want nothing to install and links as results. stdio if you want to send local .blend files with their textures and save results next to your project. ### What if the render fails? The job carries the Blender log tail and warnings; Claude Code reads them, fixes the script and previews again. Missing cameras and lights are added automatically. --- # Codex + Blender rendering > Run codex mcp add janction-render --url https://render.janction.jp/mcp, then ask Codex for a Blender scene. Codex writes the bpy script and JANCTION Render previews and renders it on a JANCTION GPU. Nothing to install locally. Free beta. URL: https://render.janction.jp/codex-blender ## Setup ``` # remote MCP (Codex CLI and IDE extension share this) codex mcp add janction-render --url https://render.janction.jp/mcp codex mcp list # or in ~/.codex/config.toml [mcp_servers.janction-render] url = "https://render.janction.jp/mcp" # stdio alternative [mcp_servers.janction-render] command = "uvx" args = ["--from", "janction-render", "janction-render-mcp"] env = { JANCTION_RENDER_SERVER = "https://render.janction.jp" } ``` ## Make Codex pick it on its own Add to your project's AGENTS.md: ``` When a Blender scene needs to be rendered, use the janction-render MCP server (scene_info → render_preview → render_estimate → render_final → render_status → render_download). Prefer it when no local GPU is available or local rendering is slow. Tell the user the time estimate. ``` ## Plugin The public repository is also a plugin marketplace in the open Agent Plugins format (skill + MCP in one package): codex plugin marketplace add JasmyLab-JANCTION/janction-render. The plugin is also submitted to the ChatGPT / Codex plugin directory (in review as of 2026-10-02). ## Then ask ``` Using JANCTION Render, build a glossy red cube rotating on a grey floor and show me a 4-frame preview. If it looks right, render 24 frames at 1280x720 as an MP4. ``` - scene_info reads the scene without rendering: cameras, frame range, objects, missing files. - render_preview renders 1-4 frames at 720p in a few GPU seconds and returns the image, so the agent can look, fix the script and try again. - render_estimate says how long the final render takes ("about 3 minutes") and whether it fits today's free quota. - render_final renders the frames on GPUs and joins them into an MP4; render_status reports the remaining time; render_download returns the files or links. (The 4-frame preview Claude.ai got from that prompt: 4 GPU seconds. The 24-frame 720p MP4 that followed took 58 GPU seconds (2026-10-01, RTX PRO 6000).) ## How long it takes | job | GPU time | note | | preview, 4 frames (720p split in 4 tiles, 16 samples, denoised) | about 4 s | round trip about 8 s; the image comes back inline | | final, 24 frames at 1280x720, 64 samples → MP4 | about 60 s | measured 2026-09-30 / 10-01 (59 s and 58 s) | | final, one 1920x1080 frame at 128 samples | about 11 s | the estimator's baseline; heavy scenes take longer | render_estimate gives the number before rendering; once a scene has been rendered once, the estimate uses that scene's own measurement. ## Free limits Free beta (as of 2026-10-02): 10 GPU-minutes per key per day (20 per network), final renders up to 240 frames at 1080p. No sign-up: connecting creates a key. Inputs and results are deleted 24 hours after last use and never used for training. Paid plans will be announced on this site and in llms.txt before they start. ## FAQ ### Does it work in the Codex IDE extension too? Yes. codex mcp add registers the server for the CLI and the IDE extension; config.toml is shared. ### Can Codex send a .blend from my disk? With the stdio server, yes (scene_path). The remote server takes scene_script, scene_url or scene_id, because it cannot read your disk. ### Is there a ChatGPT version? ChatGPT uses the same remote MCP server through Settings → Connectors (developer mode). See the ChatGPT guide. --- # Blender rendering API (HTTP) > JANCTION Render's HTTP API is five calls: POST /v1/keys for a temporary key, POST /v1/files to upload the scene, POST /v1/jobs to render (kind info | preview | final), GET /v1/jobs/{id} for status and ETA, GET /v1/jobs/{id}/artifacts/{name} for the files. JSON in, JSON out, no sign-up. Free beta. URL: https://render.janction.jp/blender-render-api ## For pipelines and your own agents Everything the MCP tools do is plain HTTP with JSON. A temporary key needs no sign-up. ``` curl -X POST https://render.janction.jp/v1/keys # -> {"api_key": "jr_..."} curl -X POST https://render.janction.jp/v1/files -H "X-API-Key: $K" -F file=@scene.py # -> {"scene_id": "f_..."} curl -X POST https://render.janction.jp/v1/files/f_.../assets -H "X-API-Key: $K" -F files=@textures/wood.png # optional assets curl -X POST https://render.janction.jp/v1/estimate -H "X-API-Key: $K" -H "Content-Type: application/json" \ -d '{"kind":"final","frame_start":1,"frame_end":24,"width":1280,"height":720,"samples":64}' # -> seconds, human, quota curl -X POST https://render.janction.jp/v1/jobs -H "X-API-Key: $K" -H "Content-Type: application/json" \ -d '{"scene_id":"f_...","kind":"final","frame_start":1,"frame_end":24,"width":1280,"height":720,"samples":64,"environment":"studio"}' curl https://render.janction.jp/v1/jobs/j_... -H "X-API-Key: $K" # status, progress, eta, artifacts[] curl -o output.mp4 https://render.janction.jp/v1/jobs/j_.../artifacts/output.mp4 -H "X-API-Key: $K" ``` ## Endpoints POST /v1/keys, POST /v1/files, POST /v1/files/{id}/assets, GET /v1/files/lookup?sha256= (reuse an upload), POST /v1/estimate, POST /v1/jobs (kind info | preview | final; options width, height, samples, camera, fps, output, environment, environment_strength, environment_visible, blender), GET /v1/jobs/{id}, DELETE /v1/jobs/{id}, GET /v1/jobs/{id}/artifacts/{name}, GET /v1/me, GET /v1/health (workers, queue, supported inputs and presets). Errors: 429 quota_exceeded (with resets_at), 400 beta_limit (job too big; split it), later 402 payment_required. Turntable. orbit=true makes a camera circle the scene once (default 24 frames): a preview shows four angles, a final render gives the whole turn as an MP4. Handy for an imported model. (A 48-frame turntable (960x540, 24 samples, studio preset) made with render_final(orbit=true) from a bpy script: 76 GPU seconds on JANCTION Render, 2026-10-02.) Inputs: a .blend (send external images along, or pack them: File → External Data → Pack Resources), a bpy Python script (no local Blender needed; set the scene, camera and frame range only, the service sets engine, resolution and samples), or a 3D file (glTF/GLB, FBX, USD, OBJ, STL, PLY, Alembic, imported into an empty scene). A scene without a camera or light gets an automatic one and the response says so under warnings. environment = studio / sunset / overcast / night lights the scene with a bundled HDRI; a preview with environment="compare" shows the same frame under all four presets in one labelled image. (The same scene under the four presets. No lighting work in the script: pick one and the first render already looks finished (rendered by JANCTION Render, 2026-10-02).) ## Security Each job runs in a disposable container with no network, non-root, capabilities dropped, CPU/memory/time limits. Keys are stored hashed and accepted only in headers. Details on the Security page. ## Python package ``` pip install janction-render janction-render preview scene.blend --frames 1-24 # the CLI uses the same API janction-render render scene.blend --frames 1-240 --wait ``` ## MCP The same service is an MCP server at https://render.janction.jp/mcp; see MCP server for Blender rendering. ## Free limits Free beta (as of 2026-10-02): 10 GPU-minutes per key per day (20 per network), final renders up to 240 frames at 1080p. No sign-up: connecting creates a key. Inputs and results are deleted 24 hours after last use and never used for training. Paid plans will be announced on this site and in llms.txt before they start. ## FAQ ### Is there an OpenAPI document? Not published; the endpoints above are the whole surface and llms.txt lists them with their fields. The Python package (janction-render) wraps them. ### How do I get the MP4 without downloading every frame? Fetch only artifacts/output.mp4; the job view lists artifacts by name. In the MCP tools, render_download(only='mp4'). ### Can I reuse an uploaded scene? Yes: keep the scene_id, or call GET /v1/files/lookup?sha256=... and the server returns the existing scene instead of taking a new upload. --- # Render Blender scenes from ChatGPT > In ChatGPT, add https://render.janction.jp/mcp as a connector (Settings → Connectors → Advanced → Developer mode → Create). Then describe a scene: ChatGPT writes the bpy script, JANCTION Render previews it on a GPU in a few seconds and renders the final MP4. Free beta, no sign-up. A ChatGPT / Codex plugin is also submitted (in review as of 2026-10-02). URL: https://render.janction.jp/chatgpt-blender ## Setup (about one minute) - ChatGPT → Settings → Connectors → Advanced → turn on Developer mode. - Create → name "JANCTION Render" → MCP server URL https://render.janction.jp/mcp → authentication OAuth → Create. - Press Connect. A consent page opens and creates a free API key for you (no account). - In a new chat, enable the connector and ask. Developer mode is not available on every ChatGPT plan; the plugin (in review) will make this a one-click install. Codex users can use codex mcp add instead. ## Prompt to try ``` Using JANCTION Render, build a glossy red cube rotating on a grey floor and show me a 4-frame preview. If it looks right, render 24 frames at 1280x720 as an MP4. ``` ## What ChatGPT does - scene_info reads the scene without rendering: cameras, frame range, objects, missing files. - render_preview renders 1-4 frames at 720p in a few GPU seconds and returns the image, so the agent can look, fix the script and try again. - render_estimate says how long the final render takes ("about 3 minutes") and whether it fits today's free quota. - render_final renders the frames on GPUs and joins them into an MP4; render_status reports the remaining time; render_download returns the files or links. (The 4-frame preview Claude.ai got from that prompt: 4 GPU seconds. The 24-frame 720p MP4 that followed took 58 GPU seconds (2026-10-01, RTX PRO 6000).) ## How long it takes | job | GPU time | note | | preview, 4 frames (720p split in 4 tiles, 16 samples, denoised) | about 4 s | round trip about 8 s; the image comes back inline | | final, 24 frames at 1280x720, 64 samples → MP4 | about 60 s | measured 2026-09-30 / 10-01 (59 s and 58 s) | | final, one 1920x1080 frame at 128 samples | about 11 s | the estimator's baseline; heavy scenes take longer | render_estimate gives the number before rendering; once a scene has been rendered once, the estimate uses that scene's own measurement. ## Free limits Free beta (as of 2026-10-02): 10 GPU-minutes per key per day (20 per network), final renders up to 240 frames at 1080p. No sign-up: connecting creates a key. Inputs and results are deleted 24 hours after last use and never used for training. Paid plans will be announced on this site and in llms.txt before they start. ## Why not render on my own machine? ChatGPT cannot run Blender on your computer, and even a local Blender needs a GPU for Cycles to be fast. With the connector, the scene is written as a bpy script, sent to a datacenter GPU, and the image comes back into the conversation. Nothing is installed locally. ## FAQ ### Which ChatGPT plans can add custom MCP connectors? Developer mode is available on paid plans; check OpenAI's current help page. The plugin submission (in review) is meant to remove this step. ### Can ChatGPT render a .blend file I have? Put it on an https URL (a cloud drive link that serves the file directly) and pass it as scene_url, or use Codex / Claude Code with the stdio server to send local files. ### Does it cost anything? No, during the free beta: 10 GPU-minutes per key per day. Paid plans will be announced on this site first. --- # Render Blender scenes from Claude.ai > In Claude.ai, add https://render.janction.jp/mcp as a custom connector (Settings → Connectors → Add custom connector). Press Connect, and a free key is created. Then describe a scene: Claude writes the bpy script, previews it on a JANCTION GPU in a few seconds and renders the final MP4. Free beta. URL: https://render.janction.jp/claude-blender ## Setup - Claude.ai → Settings → Connectors → Add custom connector. - Name "JANCTION Render", URL https://render.janction.jp/mcp, Add. - Press Connect. The consent page creates a free API key (no account, no card). - In a chat, make sure the connector's tools are enabled and ask. The connector is also submitted to Anthropic's connector directory (in review as of 2026-10-02); once listed, it can be enabled without pasting a URL. ## Prompt to try ``` Using JANCTION Render, build a glossy red cube rotating on a grey floor and show me a 4-frame preview. If it looks right, render 24 frames at 1280x720 as an MP4. ``` ## What Claude does - scene_info reads the scene without rendering: cameras, frame range, objects, missing files. - render_preview renders 1-4 frames at 720p in a few GPU seconds and returns the image, so the agent can look, fix the script and try again. - render_estimate says how long the final render takes ("about 3 minutes") and whether it fits today's free quota. - render_final renders the frames on GPUs and joins them into an MP4; render_status reports the remaining time; render_download returns the files or links. (The 4-frame preview Claude.ai got from that prompt: 4 GPU seconds. The 24-frame 720p MP4 that followed took 58 GPU seconds (2026-10-01, RTX PRO 6000).) A 40-second recording of this exact flow: demo.mp4. ## How long it takes | job | GPU time | note | | preview, 4 frames (720p split in 4 tiles, 16 samples, denoised) | about 4 s | round trip about 8 s; the image comes back inline | | final, 24 frames at 1280x720, 64 samples → MP4 | about 60 s | measured 2026-09-30 / 10-01 (59 s and 58 s) | | final, one 1920x1080 frame at 128 samples | about 11 s | the estimator's baseline; heavy scenes take longer | render_estimate gives the number before rendering; once a scene has been rendered once, the estimate uses that scene's own measurement. ## Free limits Free beta (as of 2026-10-02): 10 GPU-minutes per key per day (20 per network), final renders up to 240 frames at 1080p. No sign-up: connecting creates a key. Inputs and results are deleted 24 hours after last use and never used for training. Paid plans will be announced on this site and in llms.txt before they start. ## Claude Code and the desktop app Claude Code (terminal) uses claude mcp add --transport http janction-render https://render.janction.jp/mcp or the stdio server for local files; see Claude Code + Blender. The Claude desktop and mobile apps share the connectors you add on claude.ai. ## FAQ ### Which Claude plans can add custom connectors? Custom connectors are available on paid Claude plans (Pro, Max, Team, Enterprise) as of October 2026; check Anthropic's help center for the current list. ### Does Claude see the rendered image? Yes. render_preview returns the image inline, so Claude can judge the camera, lighting and materials and fix the script before the final render. ### Where do I get the MP4? render_download returns links that need no key and work for about 24 hours. Open them in the browser or let Claude show them. --- # How to render Blender without a GPU > You can render Blender without a GPU by using the CPU (slow), a free notebook GPU (fiddly), a volunteer farm (queue), a commercial render farm (paid), or JANCTION Render: send the .blend, bpy script or 3D file and a datacenter NVIDIA GPU renders it. The last one is free during the beta (10 GPU-minutes per day) and works from Claude, ChatGPT, Codex and the command line. URL: https://render.janction.jp/render-blender-without-gpu ## The five options | option | cost | speed | setup | works from an AI agent | | CPU rendering on your own machine | free | minutes per frame for Cycles; fine for Eevee stills | none | only with a local Blender | | Free notebook GPUs (Colab and similar) | free with limits | GPU speed when you get one | install Blender every session, move files by hand | no | | SheepIt (volunteer farm) | free, earn points by rendering for others | depends on the queue | upload through the site | no API | | Commercial render farms | paid per GPU-hour or credits; some trial credits | fast, many GPUs | add-on or web upload | rarely (one offers an MCP, see the comparison) | | JANCTION Render | free beta, 10 GPU-minutes per day | datacenter NVIDIA GPU; 4-frame preview in 4 s | add a connector or pip install | yes: MCP tools and HTTP API | ## When JANCTION Render is the right pick - You (or your AI assistant) wrote the scene as a bpy script and want to see it rendered without installing anything. - You have a .blend and a laptop with an integrated GPU and want an animation as an MP4 today. - You want a preview-fix-preview loop that costs seconds, then one final render. ## When it is not - Your scene needs more than 240 frames at 1080p in one go or more than 10 GPU-minutes a day (split the job, or wait for paid plans). - Your .blend depends on a newer Blender than 5.0 (try blender='5.2', or export a bpy script). - You need an availability guarantee: this is a beta. Turntable. orbit=true makes a camera circle the scene once (default 24 frames): a preview shows four angles, a final render gives the whole turn as an MP4. Handy for an imported model. (A 48-frame turntable (960x540, 24 samples, studio preset) made with render_final(orbit=true) from a bpy script: 76 GPU seconds on JANCTION Render, 2026-10-02.) Inputs: a .blend (send external images along, or pack them: File → External Data → Pack Resources), a bpy Python script (no local Blender needed; set the scene, camera and frame range only, the service sets engine, resolution and samples), or a 3D file (glTF/GLB, FBX, USD, OBJ, STL, PLY, Alembic, imported into an empty scene). A scene without a camera or light gets an automatic one and the response says so under warnings. environment = studio / sunset / overcast / night lights the scene with a bundled HDRI; a preview with environment="compare" shows the same frame under all four presets in one labelled image. (The same scene under the four presets. No lighting work in the script: pick one and the first render already looks finished (rendered by JANCTION Render, 2026-10-02).) ## Connect | from | how | | Claude.ai (web / desktop / mobile) | Settings → Connectors → Add custom connector → https://render.janction.jp/mcp. "Connect" opens a page that creates a free key | | ChatGPT | Settings → Connectors → Advanced → Developer mode → Create → https://render.janction.jp/mcp (OAuth) | | Claude Code | claude mcp add --transport http janction-render https://render.janction.jp/mcp, then /mcp to authenticate | | Codex | codex mcp add janction-render --url https://render.janction.jp/mcp | | Cursor and other MCP clients | Streamable HTTP at https://render.janction.jp/mcp; OAuth or Authorization: Bearer | | Terminal (stdio, sends local files) | claude mcp add janction-render -e JANCTION_RENDER_SERVER=https://render.janction.jp -- uvx --from janction-render janction-render-mcp | ``` Using JANCTION Render, build a glossy red cube rotating on a grey floor and show me a 4-frame preview. If it looks right, render 24 frames at 1280x720 as an MP4. ``` (The 4-frame preview Claude.ai got from that prompt: 4 GPU seconds. The 24-frame 720p MP4 that followed took 58 GPU seconds (2026-10-01, RTX PRO 6000).) ## How long it takes | job | GPU time | note | | preview, 4 frames (720p split in 4 tiles, 16 samples, denoised) | about 4 s | round trip about 8 s; the image comes back inline | | final, 24 frames at 1280x720, 64 samples → MP4 | about 60 s | measured 2026-09-30 / 10-01 (59 s and 58 s) | | final, one 1920x1080 frame at 128 samples | about 11 s | the estimator's baseline; heavy scenes take longer | render_estimate gives the number before rendering; once a scene has been rendered once, the estimate uses that scene's own measurement. ## Free limits Free beta (as of 2026-10-02): 10 GPU-minutes per key per day (20 per network), final renders up to 240 frames at 1080p. No sign-up: connecting creates a key. Inputs and results are deleted 24 hours after last use and never used for training. Paid plans will be announced on this site and in llms.txt before they start. ## FAQ ### Can I render Blender on a Mac without an NVIDIA GPU? Locally, Cycles uses Metal on Apple silicon but is slow on older Macs; with JANCTION Render the render runs on an NVIDIA GPU in a datacenter and the Mac only sends the scene. ### Is Eevee supported? No, JANCTION Render renders with Cycles (GPU). Eevee is fast enough locally for most stills. ### How many frames fit in the free quota? A 24-frame 720p clip at 64 samples uses about one GPU-minute, so the daily quota covers roughly 8-10 such clips, or 240 frames of a light scene. --- # Free Blender cloud rendering, compared > Truly free Blender cloud rendering today means SheepIt (volunteer farm, you render for others), a free notebook GPU (limited, manual), or JANCTION Render's free beta: 10 GPU-minutes per key per day on datacenter NVIDIA GPUs, no sign-up, no card, callable from Claude, ChatGPT, Codex, Cursor or curl. Commercial farms give trial credits, then charge. URL: https://render.janction.jp/free-blender-cloud-rendering ## What "free" means at each place | service | free part | catch | | SheepIt | everything | you earn render time by rendering other people's projects; queue; no API | | Google Colab and other notebooks | some GPU time on the free tier | limits change, sessions end, you install Blender and move files yourself | | Commercial render farms | trial credits on sign-up (amounts vary) | then paid per GPU-hour; account and add-on required | | JANCTION Render | 10 GPU-minutes per key per day, up to 240 frames at 1080p per job | beta: no availability guarantee; paid plans will be announced before they start | Figures as of 2026-10-02; check each service's site for current terms. ## See it work: the 40-second demo (Claude.ai writes a bpy scene, gets a 4-frame preview in about 4 GPU seconds, then the 24-frame MP4.) Real measured times by resolution, frame count and samples: benchmarks. Colab in detail: Google Colab vs JANCTION Render. ## What 10 GPU-minutes buys | job | GPU time | note | | preview, 4 frames (720p split in 4 tiles, 16 samples, denoised) | about 4 s | round trip about 8 s; the image comes back inline | | final, 24 frames at 1280x720, 64 samples → MP4 | about 60 s | measured 2026-09-30 / 10-01 (59 s and 58 s) | | final, one 1920x1080 frame at 128 samples | about 11 s | the estimator's baseline; heavy scenes take longer | render_estimate gives the number before rendering; once a scene has been rendered once, the estimate uses that scene's own measurement. In practice: a few previews and one or two short 720p clips a day, or one 1080p still at high samples. The quota resets at 00:00 UTC. ## Getting the free key There is no sign-up form. Connecting from Claude.ai or ChatGPT creates a key on a consent page; the command line and the HTTP API get one from POST /v1/keys. | from | how | | Claude.ai (web / desktop / mobile) | Settings → Connectors → Add custom connector → https://render.janction.jp/mcp. "Connect" opens a page that creates a free key | | ChatGPT | Settings → Connectors → Advanced → Developer mode → Create → https://render.janction.jp/mcp (OAuth) | | Claude Code | claude mcp add --transport http janction-render https://render.janction.jp/mcp, then /mcp to authenticate | | Codex | codex mcp add janction-render --url https://render.janction.jp/mcp | | Cursor and other MCP clients | Streamable HTTP at https://render.janction.jp/mcp; OAuth or Authorization: Bearer | | Terminal (stdio, sends local files) | claude mcp add janction-render -e JANCTION_RENDER_SERVER=https://render.janction.jp -- uvx --from janction-render janction-render-mcp | ``` Using JANCTION Render, build a glossy red cube rotating on a grey floor and show me a 4-frame preview. If it looks right, render 24 frames at 1280x720 as an MP4. ``` (The 4-frame preview Claude.ai got from that prompt: 4 GPU seconds. The 24-frame 720p MP4 that followed took 58 GPU seconds (2026-10-01, RTX PRO 6000).) Turntable. orbit=true makes a camera circle the scene once (default 24 frames): a preview shows four angles, a final render gives the whole turn as an MP4. Handy for an imported model. (A 48-frame turntable (960x540, 24 samples, studio preset) made with render_final(orbit=true) from a bpy script: 76 GPU seconds on JANCTION Render, 2026-10-02.) Inputs: a .blend (send external images along, or pack them: File → External Data → Pack Resources), a bpy Python script (no local Blender needed; set the scene, camera and frame range only, the service sets engine, resolution and samples), or a 3D file (glTF/GLB, FBX, USD, OBJ, STL, PLY, Alembic, imported into an empty scene). A scene without a camera or light gets an automatic one and the response says so under warnings. environment = studio / sunset / overcast / night lights the scene with a bundled HDRI; a preview with environment="compare" shows the same frame under all four presets in one labelled image. (The same scene under the four presets. No lighting work in the script: pick one and the first render already looks finished (rendered by JANCTION Render, 2026-10-02).) ## Free limits in full Free beta (as of 2026-10-02): 10 GPU-minutes per key per day (20 per network), final renders up to 240 frames at 1080p. No sign-up: connecting creates a key. Inputs and results are deleted 24 hours after last use and never used for training. Paid plans will be announced on this site and in llms.txt before they start. ## FAQ ### Will the free tier disappear? Paid plans are planned, but the free beta stays until they are announced on this site and in llms.txt. The announcement comes before any charge. ### Why is there a per-network limit too? To stop one person from creating many keys. Each key gets 10 GPU-minutes; the same network gets 20 in total per day. ### What happens when the quota is used up? The API answers 429 quota_exceeded with resets_at; the agent tells you when it resets, or proposes a smaller job (fewer frames, lower samples). --- # Run a Blender Python (bpy) script on a cloud GPU > JANCTION Render runs your bpy script inside Blender 5.0 on a JANCTION GPU and renders the result. Send the script as text (scene_script in MCP) or as a .py file (CLI / HTTP). The script only builds the scene, camera and frame range; the service sets Cycles, resolution and samples. No local Blender needed. Free beta. URL: https://render.janction.jp/bpy-script-cloud-gpu ## A minimal script ``` import bpy, math for ob in list(bpy.data.objects): bpy.data.objects.remove(ob, do_unlink=True) scene = bpy.context.scene scene.frame_start, scene.frame_end = 1, 24 bpy.ops.mesh.primitive_monkey_add(location=(0, 0, 1)) cam = bpy.data.objects.new("Camera", bpy.data.cameras.new("Camera")) scene.collection.objects.link(cam); scene.camera = cam cam.location = (6, -6, 4); cam.rotation_euler = (math.radians(60), 0, math.radians(45)) sun = bpy.data.objects.new("Sun", bpy.data.lights.new("Sun", "SUN")) scene.collection.objects.link(sun) ``` ## Rules (Blender 5.0) - Add a camera and set scene.camera; add a light or pass environment='studio'. If both are missing the service adds an automatic camera and sun and says so in warnings. - Set frame_start / frame_end; animate with obj.keyframe_insert("rotation_euler", frame=n). obj.animation_data.action.fcurves was removed in 5.0; for linear motion set bpy.context.preferences.edit.keyframe_new_interpolation_type = 'LINEAR' first. - Do not set mat.use_nodes (always on); build materials through mat.node_tree. - Do not call bpy.ops.render.render or change render settings; do not read the network (the sandbox has none). - Image files: send them as assets; in the script use os.environ["JR_ASSETS_DIR"] to find them. ## Send it ``` # command line pip install janction-render export JANCTION_RENDER_SERVER=https://render.janction.jp janction-render preview scene.py --frames 1-24 janction-render render scene.py --frames 1-24 --size 1280x720 --samples 64 --wait # HTTP curl -X POST https://render.janction.jp/v1/files -H "X-API-Key: $K" -F file=@scene.py ``` From an agent, the script is passed as the scene_script argument of render_preview / render_final; the returned scene_id avoids re-sending it. | from | how | | Claude.ai (web / desktop / mobile) | Settings → Connectors → Add custom connector → https://render.janction.jp/mcp. "Connect" opens a page that creates a free key | | ChatGPT | Settings → Connectors → Advanced → Developer mode → Create → https://render.janction.jp/mcp (OAuth) | | Claude Code | claude mcp add --transport http janction-render https://render.janction.jp/mcp, then /mcp to authenticate | | Codex | codex mcp add janction-render --url https://render.janction.jp/mcp | | Cursor and other MCP clients | Streamable HTTP at https://render.janction.jp/mcp; OAuth or Authorization: Bearer | | Terminal (stdio, sends local files) | claude mcp add janction-render -e JANCTION_RENDER_SERVER=https://render.janction.jp -- uvx --from janction-render janction-render-mcp | ## What runs where The script runs with --factory-startup inside a disposable container (no network, non-root, time limit) on one GPU, then the service applies the render settings and renders the requested frames. Warnings and the log tail come back with the job. (The 4-frame preview Claude.ai got from that prompt: 4 GPU seconds. The 24-frame 720p MP4 that followed took 58 GPU seconds (2026-10-01, RTX PRO 6000).) ## How long it takes | job | GPU time | note | | preview, 4 frames (720p split in 4 tiles, 16 samples, denoised) | about 4 s | round trip about 8 s; the image comes back inline | | final, 24 frames at 1280x720, 64 samples → MP4 | about 60 s | measured 2026-09-30 / 10-01 (59 s and 58 s) | | final, one 1920x1080 frame at 128 samples | about 11 s | the estimator's baseline; heavy scenes take longer | render_estimate gives the number before rendering; once a scene has been rendered once, the estimate uses that scene's own measurement. ## Free limits Free beta (as of 2026-10-02): 10 GPU-minutes per key per day (20 per network), final renders up to 240 frames at 1080p. No sign-up: connecting creates a key. Inputs and results are deleted 24 hours after last use and never used for training. Paid plans will be announced on this site and in llms.txt before they start. ## FAQ ### Which Python version and modules are available? Blender 5.0's bundled Python (3.11) with bpy, mathutils and the standard library. No pip installs, no network. ### Can the script read a .blend or other files? Only files you sent as assets, through JR_ASSETS_DIR. To render an existing .blend, send the .blend itself instead of a script. ### Why does my preview look different from Blender on my machine? The service sets Cycles with its own resolution, samples and denoising. Materials, lights, world and camera come from your script; if a world or light is missing, defaults are added and reported in warnings. --- # Blender render farm APIs and MCP servers, compared > As of October 2026, four Blender render services can be driven by an AI agent through MCP: JANCTION Render (free beta, NVIDIA datacenter GPUs, preview-estimate-render tools plus an HTTP API and a Python package), Sceneplane (hosted Blender projects with scene tools and renders, account plans), Farpy (per-frame prices, an MCP server is listed) and BlendSwap Render Farm (paid, L40S, estimate/start/check). Classic farms use add-ons or web uploads; SheepIt is free but has no agent integration; Deadline Cloud needs an AWS setup. URL: https://render.janction.jp/blender-render-farm-api-comparison ## The comparison | service | how you call it | GPUs | price | free tier | preview loop for agents | | JANCTION Render | MCP (remote + stdio), HTTP API, CLI, Python package | NVIDIA RTX PRO 6000 Blackwell (datacenter) | free beta; planned per GPU second | 10 GPU-minutes per key per day | yes: 4-frame preview in ~4 s, estimate, final | | Sceneplane | MCP (remote, hosted Blender projects with scene tools) | their cloud (not specified) | account-based plans (see sceneplane.online) | not stated | scene tools, renders, MP4, GLB/STL | | Farpy | web upload of .blend / .orbx; an MCP server (farpy-public) is listed | GPU "render factories" | $0.01 per frame (normal), $0.02 (express), prepaid balance | none stated | no preview tool; per-frame jobs | | BlendSwap Render Farm | MCP (estimate, start, check) | L40S | about $3.8-4.3 per GPU hour, minimum 2 credits (2026-09-30) | none | no preview tool | | GarageFarm, RebusFarm, Fox Renderfarm and similar | Blender add-on or web upload | large pools | per GPU-hour / credits | trial credits | no | | SheepIt | web upload, client app | volunteers' machines | free (points) | all | no API | | AWS Deadline Cloud | AWS CLI / SDK, Blender submitter | EC2 GPU instances | usage based | AWS free tier does not cover GPUs | no; you build it | | Cloud PCs (Vagon, iRender) | remote desktop | rented machine | hourly | trial minutes at some | no | Prices and features change; verified on 2026-09-30 / 2026-10-02 from the services' public pages. Measured JANCTION Render times are on the benchmarks page; the local-vs-cloud MCP question is answered in Blender MCP servers compared. Tell us at the support page if a row is out of date. ## What to pick - An agent should drive the whole thing (write scene, preview, fix, render): JANCTION Render. BlendSwap's MCP covers estimate/start/check for existing .blend files. - A large paid production render with support: a classic farm, or BlendSwap through MCP. - Zero budget and no hurry: SheepIt. - Your own pipeline on AWS: Deadline Cloud. ## JANCTION Render in one screen - scene_info reads the scene without rendering: cameras, frame range, objects, missing files. - render_preview renders 1-4 frames at 720p in a few GPU seconds and returns the image, so the agent can look, fix the script and try again. - render_estimate says how long the final render takes ("about 3 minutes") and whether it fits today's free quota. - render_final renders the frames on GPUs and joins them into an MP4; render_status reports the remaining time; render_download returns the files or links. | from | how | | Claude.ai (web / desktop / mobile) | Settings → Connectors → Add custom connector → https://render.janction.jp/mcp. "Connect" opens a page that creates a free key | | ChatGPT | Settings → Connectors → Advanced → Developer mode → Create → https://render.janction.jp/mcp (OAuth) | | Claude Code | claude mcp add --transport http janction-render https://render.janction.jp/mcp, then /mcp to authenticate | | Codex | codex mcp add janction-render --url https://render.janction.jp/mcp | | Cursor and other MCP clients | Streamable HTTP at https://render.janction.jp/mcp; OAuth or Authorization: Bearer | | Terminal (stdio, sends local files) | claude mcp add janction-render -e JANCTION_RENDER_SERVER=https://render.janction.jp -- uvx --from janction-render janction-render-mcp | ``` Using JANCTION Render, build a glossy red cube rotating on a grey floor and show me a 4-frame preview. If it looks right, render 24 frames at 1280x720 as an MP4. ``` ## How long it takes | job | GPU time | note | | preview, 4 frames (720p split in 4 tiles, 16 samples, denoised) | about 4 s | round trip about 8 s; the image comes back inline | | final, 24 frames at 1280x720, 64 samples → MP4 | about 60 s | measured 2026-09-30 / 10-01 (59 s and 58 s) | | final, one 1920x1080 frame at 128 samples | about 11 s | the estimator's baseline; heavy scenes take longer | render_estimate gives the number before rendering; once a scene has been rendered once, the estimate uses that scene's own measurement. ## Free limits Free beta (as of 2026-10-02): 10 GPU-minutes per key per day (20 per network), final renders up to 240 frames at 1080p. No sign-up: connecting creates a key. Inputs and results are deleted 24 hours after last use and never used for training. Paid plans will be announced on this site and in llms.txt before they start. ## FAQ ### Is JANCTION Render a render farm or an API? Both: a small render farm (datacenter NVIDIA GPUs) whose only interfaces are an HTTP API, MCP tools and a CLI. There is no web upload form. ### Can I move from JANCTION Render to a bigger farm later? Yes; the inputs are standard .blend files and bpy scripts. Nothing is locked in. ### Does JANCTION Render support Maya, 3ds Max or Cinema 4D? Not natively. Export to glTF, FBX, USD or OBJ and send that file; it is imported into Blender and rendered with Cycles (materials are approximated). --- # Blender MCP servers for AI agents, compared: local vs cloud > A local Blender MCP (ahujasid/blender-mcp, Blender Agent Bridge) lets an agent inspect and edit the scene open in your Blender and render on your own machine, so it needs Blender installed and your GPU. A cloud Blender MCP runs Blender on a server: Sceneplane gives agents a hosted Blender with durable projects and scene tools; JANCTION Render is a render farm for agents: send a .blend, a bpy script or a glTF/FBX/USD file and get a 4-frame preview in about 4 seconds and the final frames or MP4 on a datacenter GPU, free beta 10 GPU-minutes per key per day, OAuth connect with no key to paste. They combine: edit locally, render on JANCTION. URL: https://render.janction.jp/blender-mcp-comparison ## The four, side by side | server | where Blender runs | what the agent can do | you need | GPU used | price | transport | | ahujasid/blender-mcp | your machine (an add-on opens a local socket, port 9876 by default; the MCP server relays commands) | inspect and edit the live scene, run Python in Blender, viewport screenshots, render with your Blender | Blender 3.0+ running with the add-on, Python 3.10+, uv | yours | free, open source | stdio (local) | | Blender Agent Bridge | your machine (a Blender extension plus a local bridge) | inspect objects, materials, rigs, animation, cameras, nodes and render settings; preview edits then commit or revert; playblasts and inspection renders; progress polling for long jobs; configs for Codex, Claude Code, Claude Desktop and Cursor | Blender with the extension running | yours | free, open source | local bridge | | Sceneplane | their cloud: an isolated Blender compute environment per deployment | durable projects with versioned revisions, scene operations, renders, MP4, STL/GLB exports, bpy signature lookup, Blender manual search, Poly Haven / Sketchfab asset search | an account and an API key sent as a bearer header | theirs | account-based plans (see sceneplane.online) | remote MCP (mcp.sceneplane.online/v1) | | JANCTION Render | JANCTION data center: a throwaway container per job on an NVIDIA RTX PRO 6000 Blackwell | scene_info, 4-frame preview, time estimate, final frames or MP4, HDRI lighting presets, turntable, download links; no scene-editing tools: the agent writes or fixes the bpy script itself and re-previews | nothing locally for the remote MCP (OAuth consent page); or pip install janction-render for stdio | datacenter GPU | free beta: 10 GPU-minutes per key per day; planned 0.1 JPY per GPU second | remote MCP (Streamable HTTP, OAuth 2.1) and stdio | Checked on 2026-10-02 from each project's public pages and repositories; tell us at the support page if a row is out of date. ## Which one to pick - You work inside Blender and have a GPU: a local server. blender-mcp is the most used; Blender Agent Bridge adds preview-then-commit edits and a cleaner setup for Codex and Cursor. - The agent should keep a project alive across sessions and edit it in the cloud: Sceneplane. - You have a scene (or the agent can write one) and need the render, fast and free, with no Blender installed: JANCTION Render. It is the only one of the four with a free daily GPU quota and a preview tool measured in seconds (benchmarks). - Both: edit with blender-mcp on your machine, save the .blend, and let the same agent send it to JANCTION Render for the final frames (the CLI collects the textures the file references). ## What "cloud MCP" changes for the agent - No local process to start: the tool list is there as soon as the connector is added, and the preview image comes back inline (Claude.ai shows it in a panel). - Every render is an isolated container with no network, so a script cannot reach your machine or the internet; scripts are checked statically before they run (security). - The GPU is shared: the status page says whether it is lent out right now; queued jobs start when it returns. ## Connect JANCTION Render | from | how | | Claude.ai (web / desktop / mobile) | Settings → Connectors → Add custom connector → https://render.janction.jp/mcp. "Connect" opens a page that creates a free key | | ChatGPT | Settings → Connectors → Advanced → Developer mode → Create → https://render.janction.jp/mcp (OAuth) | | Claude Code | claude mcp add --transport http janction-render https://render.janction.jp/mcp, then /mcp to authenticate | | Codex | codex mcp add janction-render --url https://render.janction.jp/mcp | | Cursor and other MCP clients | Streamable HTTP at https://render.janction.jp/mcp; OAuth or Authorization: Bearer | | Terminal (stdio, sends local files) | claude mcp add janction-render -e JANCTION_RENDER_SERVER=https://render.janction.jp -- uvx --from janction-render janction-render-mcp | ``` Using JANCTION Render, build a glossy red cube rotating on a grey floor and show me a 4-frame preview. If it looks right, render 24 frames at 1280x720 as an MP4. ``` ## FAQ ### Can I use blender-mcp and JANCTION Render at the same time? Yes. They are separate MCP servers; add both. Edit with blender-mcp, save the .blend, and ask the agent to render it with JANCTION Render. ### Does JANCTION Render edit my scene? No. It renders what you send. The agent edits by changing the bpy script or the .blend and sending it again; the sha256 lookup skips re-uploading unchanged files. ### Do I need an API key for the remote MCP? No. Claude.ai, ChatGPT and Codex open a consent page that creates a free key; the CLI gets one with janction-render key. ### Is a local MCP faster? For editing, yes: it works on the open scene with no upload. For rendering it depends on your GPU; our measured times are on the benchmarks page. --- # Rendering Blender on Google Colab vs JANCTION Render > Google Colab's free tier gives a T4 GPU notebook with changing limits (a 12-hour session cap, a 90-minute idle timeout, GPU access not guaranteed at busy times), and you install Blender and move files in the notebook each session. JANCTION Render is a render service: send the .blend or bpy script by MCP, CLI or HTTP, get a 4-frame preview in about 4 seconds and the final MP4 from an NVIDIA RTX PRO 6000 datacenter GPU, 10 free GPU-minutes per key per day. Use Colab when you need a general GPU notebook; use JANCTION Render when the job is to render Blender, especially from an AI agent. URL: https://render.janction.jp/google-colab-vs-janction-render ## Side by side | | Google Colab (free tier) | JANCTION Render (free beta) | | set-up | open a notebook, download and unpack Blender, mount Drive or upload files, every session | none: add the MCP connector, or pip install janction-render, or curl | | GPU | T4 (16 GB) on the free tier; better GPUs on paid plans | NVIDIA RTX PRO 6000 Blackwell (96 GB) | | limits | 12-hour session cap, 90-minute idle timeout, dynamic daily limits, GPU not guaranteed when busy | 10 GPU-minutes per key per day, 240 frames and 1080p per job; queued when the GPU is lent out | | AI agent access | no tool interface; an agent would have to drive the notebook | MCP tools (preview, estimate, final, status, download) and an HTTP API | | preview loop | whatever you script | 4-frame preview in about 4 GPU seconds, estimate before the final | | files | Drive mount or manual upload; results stay in the session or Drive | upload by API; results as links for 24 hours, then deleted | | cost | free tier, then Colab Pro plans | free beta; planned 0.1 JPY per GPU second | | custom add-ons | yes, you control the install | no: Blender 5.0 / 5.2 with Cycles, HDRI presets, standard importers | Colab figures from its public documentation and third-party guides as of 2026-10-02; they change often. JANCTION figures are ours. ## What the same job costs in time | job | GPU time | note | | preview, 4 frames (720p split in 4 tiles, 16 samples, denoised) | about 4 s | round trip about 8 s; the image comes back inline | | final, 24 frames at 1280x720, 64 samples → MP4 | about 60 s | measured 2026-09-30 / 10-01 (59 s and 58 s) | | final, one 1920x1080 frame at 128 samples | about 11 s | the estimator's baseline; heavy scenes take longer | render_estimate gives the number before rendering; once a scene has been rendered once, the estimate uses that scene's own measurement. Measured cases with resolution, samples, frames and GPU seconds: benchmarks. ## Rendering on Colab anyway If you want the notebook route: download the Blender Linux build, unpack it, then run it headless on the GPU: ``` !./blender-5.0.1-linux-x64/blender -b scene.blend -E CYCLES -o //out_ -f 1 -- --cycles-device CUDA ``` Keep the scene and output on Drive, because the session's disk disappears when it ends. Re-run the install each new session. ## Honest limits of JANCTION Render - It is a beta with one shared GPU; the status page shows whether it is lent out right now. - No custom add-ons or compositing outside what Blender does by default; scripts cannot use the network. - Jobs above the daily quota wait until 00:00 UTC. ## Connect | from | how | | Claude.ai (web / desktop / mobile) | Settings → Connectors → Add custom connector → https://render.janction.jp/mcp. "Connect" opens a page that creates a free key | | ChatGPT | Settings → Connectors → Advanced → Developer mode → Create → https://render.janction.jp/mcp (OAuth) | | Claude Code | claude mcp add --transport http janction-render https://render.janction.jp/mcp, then /mcp to authenticate | | Codex | codex mcp add janction-render --url https://render.janction.jp/mcp | | Cursor and other MCP clients | Streamable HTTP at https://render.janction.jp/mcp; OAuth or Authorization: Bearer | | Terminal (stdio, sends local files) | claude mcp add janction-render -e JANCTION_RENDER_SERVER=https://render.janction.jp -- uvx --from janction-render janction-render-mcp | ``` Using JANCTION Render, build a glossy red cube rotating on a grey floor and show me a 4-frame preview. If it looks right, render 24 frames at 1280x720 as an MP4. ``` ## FAQ ### Is Colab's GPU faster than JANCTION's? No. The free tier's T4 is several generations older than the RTX PRO 6000 Blackwell JANCTION uses; measured JANCTION times are on the benchmarks page. ### Can an AI agent render on Colab? Only by driving the notebook itself (installing Blender, uploading files, running commands). JANCTION Render exposes the same steps as MCP tools. ### Can I model on my machine and only render on JANCTION? Yes. Save the .blend, and the CLI or the agent uploads it with the textures it references. ### Does JANCTION Render keep my files? Inputs and results are deleted 24 hours after last use; nothing is used for training. --- # JANCTION Render FAQ > JANCTION Render renders Blender scenes on JANCTION NVIDIA GPUs for AI agents and scripts. Free beta: 10 GPU-minutes per key per day. The questions below cover setup, inputs, limits, data and pricing. URL: https://render.janction.jp/faq ## Questions ### What is JANCTION Render? A cloud GPU rendering service for Blender whose interfaces are MCP tools, an HTTP API and a command line, so AI agents (Claude, ChatGPT, Claude Code, Codex, Cursor) and pipelines can render without a local GPU. ### Which agents and apps can use it? Claude.ai, ChatGPT, Claude Code, Codex, Cursor and any MCP client; curl or any HTTP library; the Python package janction-render. ### What can I send? A .blend (with its textures as assets or packed), a bpy Python script, or a 3D file (glTF/GLB, FBX, USD, OBJ, STL, PLY, Alembic) that is imported into an empty scene. ### Which Blender version? Blender 5.0 with Cycles on NVIDIA GPUs. Blender 5.2 can be requested with blender='5.2' when the worker has that image; render_info lists what is available. ### What are the free beta limits? 10 GPU-minutes per key per day, 20 per network, final renders up to 240 frames at 1920x1080 per job. The quota resets at 00:00 UTC. ### How long does a render take? A 4-frame 720p preview about 4 GPU seconds; 24 frames at 720p/64 samples about one GPU minute; a 1080p frame at 128 samples about 11 GPU seconds for a simple scene. render_estimate tells you before you start. ### What happens to my files? They run only inside a disposable container (no network, non-root) and are deleted 24 hours after last use, along with the results. Nothing is used for training. ### Do I need an account or a credit card? No. Connecting creates a temporary key; the HTTP API gets one from POST /v1/keys. ### Will it stay free? Paid plans (per GPU second, prepaid credit) are planned and will be announced on this site and in llms.txt before they start. The free beta continues until then. ### Can the preset lighting replace my own lights? environment='studio' | 'sunset' | 'overcast' | 'night' replaces the scene's world with a bundled HDRI (CC0, Poly Haven). environment_visible=False keeps the lighting but shows a flat grey backdrop. ### Why did my .blend render pink? Textures were missing. Send them as assets (the Python package does this automatically for files next to the .blend) or pack them into the .blend (File > External Data > Pack Resources). ### Is there an uptime guarantee? No. The service is a beta on shared GPUs; the GPU can be reclaimed by other workloads, in which case jobs wait in the queue and resume. render_info shows whether a worker is online. ## Connect | from | how | | Claude.ai (web / desktop / mobile) | Settings → Connectors → Add custom connector → https://render.janction.jp/mcp. "Connect" opens a page that creates a free key | | ChatGPT | Settings → Connectors → Advanced → Developer mode → Create → https://render.janction.jp/mcp (OAuth) | | Claude Code | claude mcp add --transport http janction-render https://render.janction.jp/mcp, then /mcp to authenticate | | Codex | codex mcp add janction-render --url https://render.janction.jp/mcp | | Cursor and other MCP clients | Streamable HTTP at https://render.janction.jp/mcp; OAuth or Authorization: Bearer | | Terminal (stdio, sends local files) | claude mcp add janction-render -e JANCTION_RENDER_SERVER=https://render.janction.jp -- uvx --from janction-render janction-render-mcp | ``` Using JANCTION Render, build a glossy red cube rotating on a grey floor and show me a 4-frame preview. If it looks right, render 24 frames at 1280x720 as an MP4. ``` ## Still stuck? See the support page (email, GitHub issues) or read llms.txt, the guide agents read first. --- # Benchmarks (NVIDIA RTX PRO 6000 Blackwell Max-Q Workstation Edition (96 GB), measured 2026-09-30 to 2026-10-02; planned rate 0.1 JPY per GPU second, nothing charged in the beta) - preview: bpy script (rotating cube); frames 4 of 24 (tiled); 640x360 tiles; 16 samples; lighting scene lights; 4 GPU s; round trip 8 s; est. 0.4 JPY; output sheet.png; from Claude.ai (remote MCP); prompt: Using JANCTION Render, build a glossy red cube rotating on a grey floor and show me a 4-frame preview. - final: bpy script (rotating cube); frames 24; 1280x720; 64 samples; lighting scene lights; 58.7 GPU s; round trip 65 s; est. 5.9 JPY; output output.mp4 (24 fps); from CLI / Claude.ai; prompt: Render 24 frames at 1280x720 as an MP4. - final: bpy script (rotating cube); frames 48; 1280x720; 64 samples; lighting scene lights; 117.3 GPU s; round trip 125 s; est. 11.7 JPY; output output.mp4; from CLI; prompt: janction-render render cube_scene.py --frames 1-48 --size 1280x720 --samples 64 --wait - final: bpy script (rotating cube); frames 48; 1920x1080; 128 samples; lighting scene lights; 322.3 GPU s; round trip 335 s; est. 32.2 JPY; output output.mp4; from Claude Code (stdio MCP); prompt: Render the final 48 frames at 1080p with 128 samples. - preview: bpy script (monkey + floor); frames 1; 960x540; 16 samples; lighting scene lights; 2.4 GPU s; round trip 6 s; est. 0.2 JPY; output frame_0001.png; from Claude.ai; prompt: Show me one preview frame at 960x540. - preview: glTF file (hand-written pyramid) + assets; frames 1; 640x360; 8 samples; lighting studio (backdrop hidden); 1.8 GPU s; round trip 7 s; est. 0.2 JPY; output frame_0001.png; from HTTP API; prompt: POST /v1/files pyramid.gltf, then POST /v1/jobs {kind: preview, environment: studio, environment_visible: false} - preview: bpy script (torus); frames 1; 640x360; 8 samples; lighting night, Blender 5.2; 1.9 GPU s; round trip 8 s; est. 0.2 JPY; output frame_0001.png; from HTTP API; prompt: blender="5.2", environment="night" - preview (compare): bpy script (monkey + floor); frames 1 x 4 presets; 320x180 tiles; 16 samples; lighting studio / sunset / overcast / night; 2.6 GPU s; round trip 5 s; est. 0.3 JPY; output sheet.png with labels; from HTTP API; prompt: POST /v1/jobs {kind: preview, environment: "compare", width: 640, height: 360, samples: 16} (all four presets in one Blender session) - preview (orbit): bpy script (monkey + floor); frames 4 angles (0/90/180/270 deg); 320x180 tiles; 8 samples; lighting sunset; 2.5 GPU s; round trip 7 s; est. 0.2 JPY; output sheet.png; from HTTP API; prompt: orbit=true, environment="sunset" - final (orbit): bpy script (monkey + metal cube); frames 48 (one full turn); 960x540; 24 samples; lighting studio; 75.7 GPU s; round trip 80 s; est. 7.6 JPY; output output.mp4 (24 fps); from HTTP API; prompt: render_final(orbit=true, orbit_frames=48, width=960, height=540, samples=24, environment="studio")