JANCTION Render

Posted on Oct 2 Edited on Oct 14

Codex and Claude Code MCP setup for JANCTION Render, and the limits that are easy to miss

#blender #mcp #codex #claude

Update (2026-10-14): one instruction now renders up to 3,000 frames (in parts of 240 under one job id), and up to 4K on prepaid credit. The limits below were updated to match.

Update (2026-10-12): free to start, 100 JPY of GPU time per new key with no card and 400 JPY more after saving a card on a page that charges nothing (once per card), up to 500 JPY in all; then 0.1 JPY per GPU-second, and previews stay free up to 2 GPU-minutes a day. Paid use started on 2026-10-08, and this post describes the current pricing. Auto top-up and monthly plans are optional (https://render.janction.jp/pricing).

JANCTION Render (https://render.janction.jp) renders AI-written scenes and existing .blend files on a cloud GPU. It is a separate product from SmartRender, JasmyLab's distributed-GPU platform.

Add https://render.janction.jp/mcp and an agent can render a Blender scene on a cloud GPU. There is no sign-up and no card to start. You need an MCP client that allows a custom remote server. Each new key starts with a welcome credit of up to 500 JPY (100 JPY with no card, 400 JPY more after saving a card that is not charged; 14 days) for previews and finals; after that, previews stay free up to 2 GPU-minutes a day (reset at 00:00 UTC, 09:00 JST) and finals cost 0.1 JPY per GPU-second from prepaid credit. A job the free credit does not cover is answered with HTTP 402 payment_required and a checkout_url instead of running. It is not queued, and splitting the job does not add free credit. One instruction may render up to 3,000 frames (run as parts of 240 under one job id), at 1080p on free time and up to 4K on prepaid credit.

This post is from JasmyLab, the operator of JANCTION Render. The service runs on JANCTION's own GPUs (NVIDIA RTX PRO 6000 Blackwell) with no availability guarantee; when they are busy, jobs wait in a queue.

Site: https://render.janction.jp
Repository: https://github.com/JasmyLab-JANCTION/janction-render

What this MCP is

It renders. It does not model the scene that is open in your desktop Blender. A local Blender MCP does that, and it does not require a discrete GPU: Cycles can render on a CPU. JANCTION Render accepts a .blend, a bpy script, or a 3D file (glTF, FBX, USD, OBJ, STL, PLY, Alembic), runs Blender on a datacenter NVIDIA GPU, and returns a preview, frames, or an MP4.

Default Blender is 5.0. Pass blender="5.2" when render_info or /v1/health lists 5.2. On 2026-10-02 the public health endpoint listed both. The default engine is Cycles. Final jobs can set engine='eevee'; each EEVEE job pays a shader-compile overhead, so short previews stay on Cycles.

Codex

codex mcp add janction-render --url https://render.janction.jp/mcp

Authentication is OAuth. The consent page creates a free key. If the client cannot open a browser, a raw API key from POST /v1/keys also works as Authorization: Bearer.

There is a plugin marketplace entry on the same GitHub repository (codex plugin marketplace add JasmyLab-JANCTION/janction-render). Marketplace install and a successful render are different checks. Confirm with render_info before you trust a render.

Prompt that matches the published sample:

Using JANCTION Render, build a glossy red cube rotating on a grey floor and show me a 4-frame preview.
If it looks right, call render_estimate, then render 24 frames at 1280x720 as an MP4.

Claude Code

claude mcp add --transport http janction-render https://render.janction.jp/mcp

Then /mcp and authenticate. The same prompt works. Claude.ai's custom connector is a separate path (Settings → Connectors) and depends on the plan. Team and enterprise admins can disable custom MCP servers. Do not treat "it works in Claude Code" as "it works in every Claude surface."

Setup pages:

From your own agent or app

Codex and Claude Code are one way in. An agent or app you build yourself calls the same service through the Python package or the remote MCP server.

Python (pip install janction-render; the first call creates a free key and keeps it in ~/.janction-render.json):

from janction_render.client import Client

c = Client()                                   # or Client(api_key="jr_...")
scene = c.upload("scene.py")                   # a bpy script, a .blend, or a .glb / .fbx / .usd / .obj file
job = c.submit(scene["scene_id"], kind="final", frame_start=1, frame_end=48, output="mp4")
job = c.wait(job["job_id"], timeout=1800)
print(job["status"], c.download(job["job_id"], "out", only="mp4"))

Agent frameworks connect to https://render.janction.jp/mcp with the key as a bearer token (curl -s -X POST https://render.janction.jp/v1/keys gives one, no sign-up). With the OpenAI Agents SDK, keep the longer timeout: render_preview waits for the image, which takes longer than the 5-second default.

import asyncio
from agents import Agent, Runner
from agents.mcp import MCPServerStreamableHttp

async def main():
    async with MCPServerStreamableHttp(name="janction-render", client_session_timeout_seconds=120,
                                       params={"url": "https://render.janction.jp/mcp",
                                               "headers": {"Authorization": "Bearer jr_..."}}) as render:
        agent = Agent(name="3D artist", instructions="Render Blender scenes with janction-render.", mcp_servers=[render])
        result = await Runner.run(agent, "Render a preview of https://render.janction.jp/samples/cube_scene.py")
        print(result.final_output)

asyncio.run(main())

LangChain (pip install langchain-mcp-adapters):

import asyncio
from langchain_mcp_adapters.client import MultiServerMCPClient

async def main():
    client = MultiServerMCPClient({"janction-render": {"url": "https://render.janction.jp/mcp", "transport": "streamable_http",
                                                       "headers": {"Authorization": "Bearer jr_..."}}})
    tools = await client.get_tools()           # render_preview, render_final, render_status, render_download, ...
    print([t.name for t in tools])

asyncio.run(main())

Webhooks instead of polling, safe retries and the OpenAPI document: https://github.com/JasmyLab-JANCTION/janction-render#from-your-own-agent-or-app

A render, not a Blender session

The useful order is fixed:

scene_info reads cameras, frame range, and missing files without rendering.
render_preview returns 1–4 frames. The published 4-tile example (rotating cube, 640×360 tiles, 16 samples) was about 4 GPU seconds. The round trip that day was about 8 seconds. Those are different clocks.
render_estimate returns a duration, whether the job fits the free credit left, and what it would cost.
render_final renders frames and can join an MP4. render_download returns files or 24-hour links.

GPU seconds include Blender startup and scene load on the worker. They are not "GPU chip only," and they are not the time from your keypress to the file on disk. Queue wait is extra. Whether the upload is inside the round-trip number depends on the path; do not assume every published case includes it.

A 24-frame 1280×720 MP4 at 64 samples was about 58.7 GPU seconds, with a round trip around 65 seconds, on an NVIDIA RTX PRO 6000 Blackwell Max-Q Workstation Edition (96 GB). That scene is simple. Volumes and large textures will not scale the same way. Figures: https://render.janction.jp/benchmarks and https://render.janction.jp/benchmarks.json

What fails in ordinary use

A .blend saved in a newer Blender than the worker you selected.
Unpacked image textures. Pack them, or send them as assets. Missing textures render pink.
Asking for more than 3,000 frames in one instruction, or above 1920×1080 without prepaid credit (beta_limit). Split a longer animation; splitting does not add free credit.
Custom add-ons. The worker is stock Blender 5.0 or 5.2 plus the bundled HDRI presets and standard importers.
Treating Colab, SheepIt, or Sceneplane as the same product. Colab's official FAQ does not promise a T4 or a 90-minute idle timeout. SheepIt has no MCP. Sceneplane's free tier, checked 2026-10-02, is 30 compute minutes per month and includes scene work, not a GPU-second quota. https://sceneplane.online/

Since 2026-10-08, GPU time beyond the free credit is billed at 0.1 JPY per GPU second from prepaid credit. render_estimate shows the amount before anything runs, and a failed render counts only the frames that finished (for up to 5 failed GPU-minutes per key a day).

DEV Community