DEV Community: JANCTION Render

White-background product shots for a whole catalog from GLB files: 9 products, 36 images in 44 seconds (measured)

JANCTION Render — Wed, 21 Oct 2026 15:20:20 +0000

If you sell physical products and already have 3D models (GLB, glTF, FBX, USD), you can turn every model into a set of product shots on a plain white background without opening Blender. This is how I did it with JANCTION Render, and what it cost when I measured it on 2026-10-22.

JANCTION Render is a cloud GPU render farm for Blender that AI agents call as an MCP server or HTTP API. Send a .blend file, a bpy script or a 3D file (glTF / FBX / USD) and get frames or an MP4 back. No local Blender or GPU is needed.

One request for the whole catalog

POST /v1/batches takes up to 100 items. Each item points at a model; defaults applies to all of them:

curl -s https://render.janction.jp/v1/batches \
  -H "X-API-Key: $JANCTION_RENDER_API_KEY" -H "Content-Type: application/json" \
  -d '{
    "defaults": {"kind": "final", "preset": "product", "background": "white"},
    "items": [
      {"ref": "bottle",  "scene_url": "https://example.com/models/bottle.glb"},
      {"ref": "speaker", "scene_url": "https://example.com/models/speaker.glb"},
      {"ref": "chair",   "scene_url": "https://example.com/models/chair.glb"}
    ]
  }'

preset: "product" renders 4 shots around the object (1440x1440, studio lighting, the object framed to its size).
background: "white" makes only what the camera sees directly white. The lighting and the reflections on the product still come from the studio light, so metal and glass do not go flat. "transparent" gives PNGs with alpha instead, and the default stays a neutral grey.
GET /v1/batches/{batch_id} returns the state of every item and its job id; each job lists its PNGs.

What I measured

I used 9 models from the Khronos glTF Sample Assets that are released as CC0: WaterBottle, BoomBox, Avocado, Lantern, SheenChair, ToyCar, Corset, BarramundiFish and GlassVaseFlowers. One batch request, a new key, the live service.

	result
images	36 (9 products x 4 angles), 1440x1440 PNG, 128 samples
time from the request to the last image	44 seconds
GPU time	118.2 GPU seconds in total (12.7 to 14.1 per product)
cost	about 12 JPY at 0.1 JPY per GPU-second; with a new key it came out of the welcome credit
failures	0
background	the corner pixels are pure white (255, 255, 255)

The same 9 products on the default grey background took 47 seconds and 136.1 GPU seconds the day before, so the white background does not cost more.

Things to know before you run your own catalog

Glass on white has little contrast. For clear products, background: "transparent" and your own backdrop may look better.
The camera frames the whole model from each angle, so a long, thin object seen end-on comes out small in that shot (the fish in my test did in its first angle).
A new key gets a welcome credit (100 JPY right away, 400 JPY more after saving a card that is not charged, valid 14 days). After that, renders use prepaid credit at 0.1 JPY per GPU-second.
The farm has a small number of GPUs. When they are busy, items wait in the queue; the batch keeps going and reports each item when it finishes.

From an AI agent

The same thing works from Claude, ChatGPT or any MCP client connected to https://render.janction.jp/mcp: ask for product shots of a GLB and the agent calls render_final with preset="product". The background option is on the HTTP API for now.

Current prices and limits: https://render.janction.jp/pricing and https://render.janction.jp/facts.json.

A Blender MCP server that tells your agent the price before it renders (real estimates, 48 to 1,800 frames)

JANCTION Render — Wed, 21 Oct 2026 09:36:04 +0000

Update (2026-10-22): since the evening of 10/21, a key with no prepaid credit is no longer stopped for a small hold. When the estimate fits the free time left and only the 1.5x ceiling would not, the job runs free if that hold is 50 JPY or less, and the service covers any overrun. The 240-frame example below now runs with nothing held. Estimates also follow each key's own measured renders: on 10/22, another key that had rendered finals before got 488 GPU seconds ("about 2 minutes") for 240 frames and 3,661 GPU seconds ("about 15 minutes", 88 JPY held) for 1,800 frames.

If you let an AI agent render Blender scenes on a cloud GPU, the question you want answered first is not "how fast" but "what will this cost me, and can it run away". This is how JANCTION Render answers it, with estimates I took from the live service on 2026-10-21.

The order the agent follows

The MCP server's own instructions tell the agent to work in this order:

render_preview - a few frames in seconds, to check the scene
ask the user
render_estimate - when the job is long or the free time left is uncertain (no GPU used, nothing charged)
render_final - with max_yen as a ceiling if you want one

render_estimate takes the same arguments as the final render and returns time and money in one answer.

What the estimates look like

Same scene for all three (the public example ex12_logo_ring_spin.py), a new key with its welcome credit:

request	GPU seconds	expected wait	free time covers	held from credit (ceiling)	charged if it runs as estimated
48 frames, 1280x720	86	"about 20 seconds"	all of it	0 JPY	0 JPY
240 frames, 1920x1080	908	"about 4 minutes"	all of it	37 JPY	0 JPY
1,800 frames, 1920x1080	6,813	"about 30 minutes"	1,000 seconds	872 JPY	582 JPY

A few things in that table matter for an agent:

The hold is larger than the estimate. A render can take up to 1.5 times its estimate, so the service reserves that much from prepaid credit and only charges the time actually used. On the 240-frame job, the estimate fits the free time, but the 1.5x ceiling would not, so 37 JPY is held and 0 is expected to be charged.
The answer includes the per-job and per-day limits that apply to the key (3,000 JPY per job and 10,000 JPY per day on this key), so the agent knows before it asks.
When the scene has not been rendered as a final before, the estimate says so ("confidence": "preliminary") and asks for a short test render before trusting it.

How close was it? Earlier the same day I rendered the 48-frame version of this scene for real: 89.39 GPU seconds against the 86 estimated. End to end it took 39 seconds, not 20: the estimate covers the queue and the render on the farm, and the 39 also includes the upload check and downloading 44 MB.

Ceilings and what happens without credit

max_yen on render_final refuses the job before anything is reserved if its hold would exceed the ceiling. max_yen=0 means "only if it fits the free time".
If the key has no prepaid credit for the part beyond the free time, the job is not started (except the small holds of 50 JPY or less described in the update above). The agent gets a top-up link to show the user; it cannot pay by itself.
Prices are 0.1 JPY per GPU-second. A new key gets a welcome credit (100 JPY right away, 400 JPY more after saving a card that is not charged, valid 14 days); after that, previews are free up to 120 GPU-seconds a day per key.

Asking for an estimate yourself

Over HTTP it is one call:

curl -s https://render.janction.jp/v1/estimate \
  -H "X-API-Key: $JANCTION_RENDER_API_KEY" -H "Content-Type: application/json" \
  -d '{"scene_url": "https://render.janction.jp/samples/ex12_logo_ring_spin.py",
       "kind": "final", "frame_start": 1, "frame_end": 240,
       "width": 1920, "height": 1080, "output": "mp4"}'

The fields to read are human (the wait in words), seconds (GPU seconds), and in cost: covered_by_free_yen, max_charge_yen (the hold) and estimated_yen (the expected charge).

Limits worth knowing

A final can be up to 3,000 frames in one job, rendered in parts of 240 under one job id.
1920x1080 on free time, up to 3840x2160 with prepaid credit.
The farm has a small number of GPUs; when they are busy, the estimate's queue wait grows and the agent should tell the user rather than retry.

Connect it from Claude, ChatGPT or any MCP client at https://render.janction.jp/mcp. Current prices and limits: https://render.janction.jp/pricing and https://render.janction.jp/facts.json.

Render Blender in GitHub Actions without a GPU: a preview on every push, a 48-frame MP4 in 39 seconds (measured)

JANCTION Render — Wed, 21 Oct 2026 08:23:57 +0000

GitHub's hosted runners have no GPU, and installing Blender on every run is slow. This is how I render a Blender scene from a workflow with JANCTION Render, and what it cost when I measured it on 2026-10-21.

JANCTION Render is a cloud GPU render farm for Blender that AI agents call as an MCP server or HTTP API. A workflow can call the same API through a GitHub Action. You send a .blend file, a bpy script or a 3D file (glTF / FBX / USD) and get frames or an MP4 back. No Blender or GPU is needed on the runner.

The workflow

Add one secret, JANCTION_RENDER_API_KEY (a new key comes from curl -s -X POST https://render.janction.jp/v1/keys, no sign-up), and this file:

name: render
on:
  push:
    paths: ["scenes/**"]
jobs:
  preview:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: JasmyLab-JANCTION/render-action@v1
        with:
          api-key: ${{ secrets.JANCTION_RENDER_API_KEY }}
          scene-file: scenes/logo_ring.py
          kind: preview
          frames: "1,13,25,37"     # up to 4 frames in one contact sheet
          max-cost-yen: 0          # free preview time only
      - uses: actions/upload-artifact@v4
        with:
          name: render-preview
          path: render-output

For the video, switch to kind: final, give a frame range and a cap:

      - uses: JasmyLab-JANCTION/render-action@v1
        with:
          api-key: ${{ secrets.JANCTION_RENDER_API_KEY }}
          scene-file: scenes/logo_ring.py
          kind: final
          frames: "1-48"
          width: 1280
          height: 720
          output: mp4
          max-cost-yen: 30

The action estimates first and stops before anything starts if the job could cost more than max-cost-yen. The same cap goes with the job, so the service refuses it before any credit is held.

What I measured

Scene: the public example ex12_logo_ring_spin.py (a metal ring logo turning once in 48 frames; the script sets up its own lights and EEVEE). I ran the action's script, the same render.sh the action runs, from a Windows PC against the live service with a new key.

step	result	GPU seconds	time, end to end
estimate (no GPU)	"about 97 GPU seconds, about 25 seconds" for the final	0	-
preview, 4 frames, 1280x720	contact sheet + 4 PNGs	3.46	11 s
final, 48 frames, 1280x720, 128 samples	48 PNGs + MP4 (H.264, 24 fps, 48 frames)	89.39	39 s

The 39 seconds include the upload check (the same file was already uploaded, so nothing was sent again), the render (48 frames in 5 chunks), and downloading 44 MB. The MP4 checked out with ffprobe as 1280x720, 24 fps, 48 frames.

Cost: finals are 0.1 JPY per GPU-second, so the final was about 9 JPY of GPU time. With a new key it came out of the welcome credit (100 JPY right away, 400 JPY more after saving a card that is not charged, valid 14 days), so the job showed 0 JPY charged. After that, previews stay free up to 120 GPU-seconds a day per key, and finals use prepaid credit.

Two things the numbers do not show:

The first run on a fresh runner also installs the command line tool from PyPI into a virtual environment. That takes runner time (not GPU time) and is not in the table.
The farm has a small number of GPUs. When they are busy, your job waits in the queue, and the action keeps waiting until timeout-seconds (default 900). Only frames already rendered are charged if it times out.

Limits that matter in CI

A final can be up to 3,000 frames in one job; the service renders it in parts of 240 and returns one result.
1920x1080 on free time, up to 3840x2160 with prepaid credit.
Pull requests from forks: on pull_request they get no secrets; on pull_request_target the action refuses forks unless you set allow-fork-pull-requests: true, because a fork could spend your credit.

When this is not the right tool

If you need to edit a scene interactively, use Blender itself (or a local Blender MCP server).
If your runner already has an NVIDIA GPU, rendering locally is faster.
It renders with Blender's own engines (Cycles, EEVEE). Third-party renderers such as Arnold, Redshift or Octane are not available.

The action is on the GitHub Marketplace as "JANCTION Render - Blender cloud GPU" (source: https://github.com/JasmyLab-JANCTION/render-action). Pricing and the current limits are at https://render.janction.jp/pricing and https://render.janction.jp/facts.json.

I turned a GLB into a product video from an AI chat: 5 seconds, about 60 JPY, and you only pay the GPU seconds used

JANCTION Render — Tue, 13 Oct 2026 09:24:25 +0000

I run JANCTION Render, a cloud GPU renderer for Blender that AI assistants call over MCP. Today I added Product Video on top of it: you give it a product 3D model (.glb, .fbx, .obj, .usdz) and it sends back a finished short video with captions and an end card, a 360 turntable, or four product images.

What I measured on our GPUs today (Khronos sample models, CC0):

5 s video at 1920x1080: about 220 GPU-seconds, about 2 minutes from order to delivery when the GPUs are free
5 s 360 turntable, square: about 114 GPU-seconds
four product images (front, three-quarter, side, back): 15 GPU-seconds
caption or colour change on a delivered video: no re-render, 0 JPY

How the price works. The GPU is billed at cost, the same 0.1 JPY per GPU-second as JANCTION Render, plus a fixed production fee for the compositing, captions, checks and the saved project (40 JPY for 5 s, 90 for 15 s, 160 for 30 s, 30 for a 5 s turntable, 20 for four images). The quote shows a maximum; on delivery you pay the fee plus the GPU seconds actually used, and the rest goes back to your balance. My first paid order today was quoted at a 61 JPY maximum and charged 53 JPY. Nothing is charged if it fails, and shots rendered before are reused without GPU cost.

The flow an agent follows: plan_video (what can be made) -> quote_video (maximum, typical price, minutes) -> you say yes -> submit_video with the price you agreed to -> get_video_outputs. The server refuses an order whose price differs from the one shown, and you can set per-order and daily limits or require a human approval click above an amount. The MCP tools cannot change those limits.

For shop and asset-store pages there is also a listing pack: the four images plus a 360 turntable of the same model in one quote, about 64 JPY.

What it does not do: videos from text alone, people, live action. You need a 3D model; if you do not have one, try product=sample:water-bottle, which is free a few times per account.

https://render.janction.jp/video/

The cheapest way to render a 1-minute Blender animation without buying a GPU: six options, with measured numbers

JANCTION Render — Tue, 13 Oct 2026 05:51:45 +0000

Official JANCTION Render: https://render.janction.jp

Update (2026-10-13): one instruction now takes up to 3,000 frames and a long final comes back as one joined MP4, so the one-minute render below is a single command. The first version of this post said to send six 240-frame parts and join six MP4s.

Disclosure: this post comes from the team behind JANCTION Render, one of the six options below. The laptop and JANCTION Render numbers are our own measurements. For the other services we describe how they charge and what they ask of you, and link to them instead of quoting prices that change.

Short answer: if waiting costs you nothing, the free routes are your own computer and SheepIt's volunteer farm. If you want the minute back the same day without setting up a machine, you pay for GPU time somewhere. On JANCTION Render, one minute of a simple scene at 1920x1080 and 128 samples comes to about 7,800 GPU-seconds, about 780 JPY (around $5), and a heavier scene such as Blender's Classroom demo to about 1,290 JPY (around $8).

What "one minute" means

At 24 fps, one minute is 1,440 frames. Every option below comes down to how long one frame takes, times 1,440, and who pays for that time. Resolution and Cycles samples move the number more than anything else, so settle them before comparing: denoising with fewer samples often looks the same as many samples without it.

1. Your own computer first (free, slow)

Before paying anyone, make sure Cycles uses the GPU you already have: Edit > Preferences > System > Cycles Render Devices, then Metal on Apple silicon Macs, HIP on recent AMD GPUs, oneAPI on Intel Arc, CUDA or OptiX on NVIDIA, and set Render Properties > Device to GPU Compute. For drafts, EEVEE is much faster than Cycles.

What it costs in time, measured on a simple scene (a rotating cube) on a laptop with a Core Ultra 9 386H: 20.0 seconds per frame on the CPU at 1920x1080 and 128 samples, so about 8 hours for the minute, and 6.6 seconds per frame at 1280x720 and 64 samples, about 2.6 hours. The same laptop's GeForce RTX 5070 Ti took 6.0 and 2.5 seconds per frame: about 2.4 hours and 1 hour. These are single frames multiplied by 1,440; a real scene with more geometry, textures and light bounces takes longer.

2. SheepIt Render Farm (free, you wait)

SheepIt is a free, community-run farm: your frames render on volunteers' computers, and letting your own machine render for others earns points that move your projects up the queue. It costs nothing but waiting. Your .blend is opened on other people's machines, so it suits personal projects better than client work under an NDA. https://www.sheepit-renderfarm.com

3. Google Colab notebooks (free GPU when one is available)

Several open-source notebooks install Blender on a Colab GPU and render a .blend from your Google Drive. It is free when a GPU is available, but free-tier GPUs and session length are not guaranteed, long renders get disconnected, and you set up and watch each run. Read Colab's terms before relying on it.

4. Rent a GPU by the hour (RunPod, Vast.ai and similar)

You start a machine with a GPU, install Blender, upload the file, render, download and stop the machine. You pay for every hour the machine is on, including setup, uploads and the evening you forget to stop it, and everything on it is yours to manage.

5. Commercial render farms (GarageFarm, RebusFarm, Fox Renderfarm and others)

You upload the .blend through their site or plugin and they render on many machines at once, so a minute comes back fast. They charge by node-hour or GHz-hour, show an estimate before you start, and several offer trial credit. For heavy production scenes they are the strongest option; for a short one-off they can be more than you need.

6. A per-second GPU API (JANCTION Render)

JANCTION Render is a cloud GPU render farm for Blender that AI agents call as an MCP server or HTTP API, and that you can also call from a terminal or a script. You send a .blend, a bpy script or a 3D file (glTF / FBX / USD / OBJ), get a preview in seconds, then the frames or an MP4. You pay for the GPU-seconds actually used, 0.1 JPY per GPU-second.

Measured per frame on its GPU (from 24-frame batches, including Blender start-up and scene loading, so a long run comes out a little lower), times 1,440:

simple scene, 1280x720, 64 samples: 2.46 GPU-seconds per frame, 3,542 GPU-seconds for the minute, about 354 JPY (about $2.2)
simple scene, 1920x1080, 128 samples: 5.39 per frame, 7,762 for the minute, about 776 JPY (about $4.9)
Blender's Classroom demo, 1920x1080, 128 samples with denoising: 8.93 per frame, 12,859 for the minute, about 1,286 JPY (about $8.1)

Dollar figures use 158 JPY per USD (ECB reference rate, 2026-10-09); charges are in JPY.

Each new key gets 100 JPY of GPU time with no card, and 400 JPY more after saving a card on a page that charges nothing (once per card), for 14 days. That covers the 720p minute above. After it, previews stay free up to 2 GPU-minutes a day and finals are paid from prepaid credit.

Limits worth knowing before you start: 1920x1080 on free time and up to 3840x2160 on prepaid credit; one instruction takes up to 3,000 frames, rendered as 240-frame parts under one job id and joined into one MP4, so a one-minute animation comes back as one file; at most 10 GPU-hours per job; files are deleted 24 hours after last use (7 days for keys that have topped up). Jobs run on JANCTION's own GPUs and wait in a queue when they are busy, and https://render.janction.jp/status shows the wait.

From a terminal:

pip install janction-render
janction-render preview minute.blend
janction-render estimate minute.blend --frames 1-1440 --size 1920x1080
janction-render render minute.blend --frames 1-1440 --output mp4 --wait

The first janction-render command makes a free key, the preview comes back in seconds, the estimate shows the GPU-seconds and the price before anything runs, and the render waits for the whole minute and downloads it as one joined MP4.

From an AI agent: add https://render.janction.jp/mcp as a connector in Claude or ChatGPT, or run claude mcp add --transport http janction-render https://render.janction.jp/mcp in Claude Code, then ask for a preview of the scene and the minute.

Side by side

Option	Money for the minute	Your effort	Time until you have it
Own laptop, CPU (simple scene, 1080p, 128 samples)	none	set and leave	about 8 hours
Own laptop, RTX 5070 Ti (same scene)	none	set and leave	about 2.4 hours
SheepIt	none (you earn points)	upload	depends on the queue and your points
Colab notebook	none on the free tier	set up and watch each run	disconnections on long runs
Hourly GPU rental	per hour the machine is on	run the machine yourself	as fast as the GPU you rent
Commercial farm	per node-hour or GHz-hour	upload through their site or plugin	fast, many machines at once
JANCTION Render	about 354 to 1,286 JPY (measured scenes above)	a command or a chat	queue when the GPUs are busy

Measurements: https://render.janction.jp/benchmarks. Cost per frame and per animation: https://render.janction.jp/blender-render-cost. Prices: https://render.janction.jp/pricing. Checked on 2026-10-13.

Official JANCTION Render: https://render.janction.jp. Code and client: https://github.com/JasmyLab-JANCTION/janction-render

Add 3D product shots to your app in 40 lines: upload, a fixed-price order, a webhook (JANCTION Render, FastAPI)

JANCTION Render — Mon, 12 Oct 2026 06:25:47 +0000

Official JANCTION Render: https://render.janction.jp

Short answer: if your users upload 3D models, you do not need a GPU to show them rendered. Upload the file to a render API, order four product shots at a price you know before anything runs, and receive one webhook when the images are ready. JANCTION Render is a cloud GPU render farm for Blender that code and AI agents call as an HTTP API or an MCP server. Four 1440x1440 product shots of the Khronos WaterBottle sample took 13.9 GPU-seconds on it, about 1.4 JPY at 0.1 JPY per GPU-second; a 24-frame 720p turntable of the same file took 85.2 GPU-seconds, about 8.5 JPY.

This post is the complete server side: a FastAPI app that takes a GLB from a user, orders the shots, and stores the links when the webhook arrives. The same code is in the API guide at https://render.janction.jp/blender-render-api#embed.

The app

# pip install fastapi httpx uvicorn
import hashlib, os, httpx
from fastapi import FastAPI, Request, UploadFile

JR = "https://render.janction.jp"
KEY = os.environ["JANCTION_RENDER_API_KEY"]     # one key for your app: POST /v1/keys creates it, GET /v1/me shows the credit
H = {"X-API-Key": KEY}
app = FastAPI()
orders: dict[str, dict] = {}                      # your database in real life

@app.post("/products/{sku}/shots")               # your user uploads a GLB; you order 4 product shots
async def order_shots(sku: str, file: UploadFile, request: Request):
    data = await file.read()
    async with httpx.AsyncClient(timeout=120) as jr:
        up = await jr.post(f"{JR}/v1/files", headers=H, files={"file": (file.filename, data)})
        up.raise_for_status()                      # 100 MB per upload; a larger model goes in as a link (scene_url)
        r = await jr.post(f"{JR}/v1/outcomes/product-shot",
                          headers={**H, "Idempotency-Key": f"shots-{sku}-{hashlib.sha256(data).hexdigest()[:16]}"},
                          json={"scene_id": up.json()["scene_id"], "size": "square", "transparent": True,
                                "notify_url": str(request.url_for("jr_done"))})
    if r.status_code == 402:                       # credit is short: send the user to r.json()["checkout_url"], then retry
        return {"error": "credit", "pay_at": r.json().get("checkout_url")}
    r.raise_for_status()
    j = r.json()                                   # j["outcome"]["price_yen"] is the ceiling; you pay the GPU seconds used
    orders[j["job_id"]] = {"sku": sku, "status": j["status"], "ceiling_yen": j["outcome"]["price_yen"]}
    return {"job_id": j["job_id"], "ceiling_yen": j["outcome"]["price_yen"]}

@app.post("/jr/done", name="jr_done")             # JANCTION Render POSTs here once, when the job is done or failed
async def jr_done(request: Request):
    body = await request.json()                    # {"event": "job.done" | "job.failed", "job_id": ..., "artifacts": [...]}
    async with httpx.AsyncClient(timeout=30) as jr:
        j = (await jr.get(f"{JR}/v1/jobs/{body['job_id']}", headers=H)).json()   # read it back with your key; do not trust the body
    if j["status"] == "done":                      # view_url links last 24 hours: copy the images to your own storage
        orders[j["job_id"]].update(status="done", images=[a["view_url"] for a in j["artifacts"] if a["name"].endswith(".png")])
    else:
        orders[j["job_id"]].update(status="failed", why=(j.get("failure") or {}).get("reason"))
    return {"ok": True}

Run it with uvicorn app:app behind an https address (the webhook URL must be https), and curl -X POST https://render.janction.jp/v1/keys once to get the key for JANCTION_RENDER_API_KEY.

What each line relies on

POST /v1/outcomes/product-shot is a fixed-price order: four PNGs at 0, 90, 180 and 270 degrees on a plain backdrop, framed at the model's real size, studio light. The reply carries outcome.price_yen, the ceiling, before anything renders; the job then charges only the GPU seconds it used, never more than the ceiling. turntable is the other order, a 360-degree MP4.
Idempotency-Key makes a retried request return the first job instead of rendering twice. Here it is the SKU plus a hash of the file, so the same upload for the same product is always the same job.
notify_url gets exactly one POST when the job is done or failed, with the download links in the body. The handler reads the job back with the key anyway, so a forged POST to your webhook changes nothing.
The view_url links open without a key and expire after 24 hours. Copy the images to your storage in the handler; the orders dict here is a stand-in for that.
A 402 means the key's credit does not cover the order. The reply has checkout_url, a Stripe page for a top-up from 500 JPY, and after paying the same request goes through. For an app that must not stop, a saved card can top up by itself (POST /v1/billing/autocharge), and POST /v1/me/limits caps what a key may spend per job and per day.

Many models at once

POST /v1/batches takes up to 100 items, each with its own scene_url or scene_id, one outcome for all of them and one notify_url. Items that fail get their own error while the rest continue, and POST /v1/batches/{id}/retry sends only the failures again.

What it costs

A new key starts with 100 JPY of GPU time with no card, and 400 JPY more after saving a card on a page that charges nothing (once per card): up to 500 JPY, or 5,000 GPU-seconds, for 14 days. After that, previews stay free up to 2 GPU-minutes a day and everything else is 0.1 JPY per GPU-second from prepaid credit. At the measured 13.9 GPU-seconds per set of four shots, the welcome credit covers about 350 products; after it, a set is about 1.4 JPY. Prices: https://render.janction.jp/pricing. Per-order ceilings: https://render.janction.jp/products.

One thing to know before you plan around it: the service runs on a small number of GPUs today, so a burst of orders waits in a queue. GET /v1/health shows how many workers are free, and the job's eta says how long the wait is expected to be.

Official JANCTION Render: https://render.janction.jp

Rendering Blender without an NVIDIA GPU (MacBook, laptop, headless server): measured cost per frame

JANCTION Render — Fri, 09 Oct 2026 14:18:43 +0000

Official JANCTION Render: https://render.janction.jp

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): the welcome credit changed on 2026-10-12. A new key now gets 100 JPY of GPU time 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. The prices below were updated to match https://render.janction.jp/pricing.

Short answer: keep editing on your machine and send the render to a GPU somewhere else. JANCTION Render is a cloud GPU render farm for Blender that takes a .blend or a bpy script and returns frames or an MP4. On it, Blender's own Classroom demo scene rendered at 1920x1080 with 128 Cycles samples and denoising in 8.93 GPU-seconds per frame, which is 0.89 JPY per frame, and the Barcelona Pavillion demo in 10.55 GPU-seconds (1.05 JPY). A simple 24-frame 1280x720 animation at 64 samples took about 59 GPU-seconds. Each new key gets 100 JPY of GPU time free with no card, and 400 JPY more after saving a card on a page that charges nothing (once per card): up to 500 JPY, or 5,000 GPU-seconds, for 14 days.

If Cycles is slow on your MacBook

Try the free fixes on the Mac first. Cycles can use the Apple GPU through Metal (Preferences, System, Cycles Render Devices). EEVEE is much faster for drafts. Fewer samples with denoising often look the same as many samples without it.

When the final still takes hours, move only the final. You keep working while it renders, and you pay per GPU-second instead of keeping a machine busy.

If your laptop has no NVIDIA GPU

Send the file. There are three ways in, depending on where you work.

From a chat app such as Claude.ai or ChatGPT: add https://render.janction.jp/mcp as a connector, drop the .blend at https://render.janction.jp/upload (the link is valid for 12 hours), paste the link and ask for a preview, then the animation.

From a terminal:

pip install janction-render
janction-render preview scene.blend
janction-render render scene.blend --frames 1-48 --size 1280x720 --output mp4 --wait

The first command creates a free key. The preview comes back in seconds, and the render command waits for the MP4 and downloads it.

From a headless server or a script

blender -b scene.blend -a works on a server only if Blender is installed there and, for reasonable speed, a GPU that Cycles supports is attached. Without either, the same job goes to the HTTP API or the Python client:

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"))

A bpy script only builds the scene, the camera and the frame range; the service sets resolution, samples and the GPU. Blender 5.0 and 5.2 are available.

Is it cheap?

It costs 0.1 JPY per GPU-second, and the GPU seconds include Blender starting and loading the scene. From the measurements above, a 1080p frame of a demo-scene-sized file is about 1 JPY, and a 24-frame 720p clip of a simple scene is about 6 JPY. Previews are free up to 2 GPU-minutes a day after the welcome credit, so checking a scene usually costs nothing. Each key has a spending cap per job and per day, and a job that needs more credit than the key has is refused before it runs.

The numbers and the scripts that produced them: https://render.janction.jp/benchmarks

Limits

One instruction goes up to 3,000 frames (parts of 240 under one job id, so a one-minute animation comes back as one file), 1080p on free time and up to 4K on prepaid credit. Inputs and results are deleted 24 hours after last use (7 days for keys that have topped up). When JANCTION's GPUs are busy, a job waits in a queue, and the status page says so.

More: https://render.janction.jp/render-blender-without-gpu, https://render.janction.jp/render-blender-animation-online and https://render.janction.jp/blender-render-cost. Prices: https://render.janction.jp/pricing

Official JANCTION Render: https://render.janction.jp. Code and client: https://github.com/JasmyLab-JANCTION/janction-render

GLB to a 360-degree turntable MP4 and four product shots, one API call each (measured)

JANCTION Render — Fri, 09 Oct 2026 10:09:25 +0000

Official JANCTION Render: https://render.janction.jp

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.

Short answer: upload the model, then order a turntable or product shots from a render API. JANCTION Render is a cloud GPU render farm for Blender that code and AI agents call. On it, a 24-frame 720p turntable of the Khronos glTF sample Duck took 42.56 GPU-seconds, and four 1440x1440 product shots with a transparent background took 12.73 GPU-seconds. At 0.1 JPY per GPU-second that is about 4 JPY and about 1 JPY, and each new key gets 100 JPY of GPU time free with no card, and 400 JPY more after saving a card on a page that charges nothing (once per card).

The code

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()
scene = c.upload("product.glb")                  # .glb, .gltf, .fbx, .usd or .obj, or a .blend

job = c.outcome("turntable", scene["scene_id"], size="720p", frames=24)
print(job["outcome"]["price_yen"])               # the price ceiling, known before anything renders
job = c.wait(job["job_id"], timeout=900)
print(c.download(job["job_id"], "out", only="mp4"))

shots = c.outcome("product-shot", scene["scene_id"], size="square", transparent=True)
shots = c.wait(shots["job_id"], timeout=900)
print(c.download(shots["job_id"], "shots", only="frames"))    # 0, 90, 180 and 270 degrees

The same two orders exist in the HTTP API (POST /v1/files, then POST /v1/outcomes/turntable or POST /v1/outcomes/product-shot) and in the CLI (janction-render outcomes lists them).

What the two orders do

A turntable is one full rotation with an orbiting camera at 24 fps, in studio light unless you pick sunset, overcast or night. It comes in 720p or 1080p with 24, 48 or 96 frames. The camera sits 18 degrees above the model by default, and orbit_target centres it on one object when the file has several.

Product shots are four stills at 0, 90, 180 and 270 degrees, 1080p or square, with an optional transparent background.

The price is known before the render starts and works as a ceiling. A 720p turntable is at most 9, 16 or 30 JPY for 24, 48 or 96 frames, a 1080p one 16, 30 or 59 JPY, and product shots 6 JPY. The ceiling is reserved first, you pay the GPU seconds actually used up to it, and nothing is charged while the free GPU time covers the job.

Measured on the Duck

These are from one run on 2026-10-09, with the 120 KB Duck.glb from the Khronos glTF sample assets.

The upload took 0.8 seconds. The 720p, 24-frame turntable used 42.56 GPU-seconds. It waited 103 seconds behind three larger jobs that were already queued, then rendered in 18 seconds split across four workers, so the MP4 arrived 124 seconds after the order. The square product shots with a transparent background used 12.73 GPU-seconds, started at once and arrived 13 seconds after the order, as four 1440x1440 PNGs with an alpha channel.

An earlier measurement on the benchmarks page: a 48-frame full turn at 960x540 used 75.7 GPU-seconds (https://render.janction.jp/benchmarks).

From an AI agent instead of code

The service is also a remote MCP server at https://render.janction.jp/mcp for Claude, ChatGPT, Codex and Cursor, so "make a 360-degree video of this GLB" works in a chat. The agent can call render_preview with orbit=True first, which shows the model from 0, 90, 180 and 270 degrees, and then render_final with orbit=True, which renders the full turn as an MP4. Files on your disk go through https://render.janction.jp/upload when the chat app cannot read them.

Limits

One instruction goes up to 3,000 frames (parts of 240 under one job id), 1080p on free time and up to 4K on prepaid credit. Inputs and results are deleted 24 hours after last use (7 days for keys that have topped up). When JANCTION's GPUs are busy, a job waits in a queue, and the status page says so.

More: https://render.janction.jp/product-turntable, https://render.janction.jp/gltf-to-mp4 and https://render.janction.jp/product-shots-multi-angle. Prices: https://render.janction.jp/pricing

Official JANCTION Render: https://render.janction.jp. Code and client: https://github.com/JasmyLab-JANCTION/janction-render

Blender rendering from an OpenAI Agents SDK or LangChain agent, and the 5-second MCP timeout that breaks it

JANCTION Render — Fri, 09 Oct 2026 09:53:53 +0000

Official JANCTION Render: https://render.janction.jp

JANCTION Render is a cloud GPU render farm for Blender that AI agents call as an MCP server or HTTP API. It is free to start (100 JPY of GPU time with no card, 400 JPY more after saving a card that is not charged), then 0.1 JPY per GPU-second. This post is for people building their own agent: how to connect it from the OpenAI Agents SDK, LangChain or plain Python, and the one setting that makes the first call fail.

The error

McpError: Timed out while waiting for response to ClientRequest. Waited 5.0 seconds.

MCPServerStreamableHttp in the OpenAI Agents SDK (0.23.1) waits 5 seconds for a tool call by default (client_session_timeout_seconds=5). A render tool answers when the image exists, not when the job is queued. We called render_preview on the sample scene with four lighting presets, once with the default and once with 120 seconds:

default: failed after 5.1 s with the error above
120 s: the image came back after 7.3 s (4.03 GPU-seconds of rendering)

A lighter preview of the same scene (one preset) came back in 4.7 to 5.0 seconds, right at the edge, so the default can look fine in a quick test and then fail on the first real scene. Set the timeout explicitly.

OpenAI Agents SDK

The service is a remote MCP server at https://render.janction.jp/mcp. The key goes in as a bearer token; curl -s -X POST https://render.janction.jp/v1/keys gives one, with no sign-up.

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())

The agent sees 12 tools. The ones it uses in order are scene_info, render_preview, render_estimate, render_final, render_status and render_download. Long renders do not need a longer timeout: a short final returns its links in one call, a longer one returns a job id, and render_download(job_id, wait_seconds=45) waits up to 45 seconds per call. 120 seconds covers every tool.

LangChain

With langchain-mcp-adapters (0.3.2), the same server is one entry in MultiServerMCPClient. The transport name is streamable_http.

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())

Without an agent framework

If your code decides what to render and only needs the frames, the Python client is shorter. 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"))

For a service rather than a script: pass notify_url (https) to POST /v1/jobs and get one JSON POST when the job finishes instead of polling, and send an Idempotency-Key header so a retry does not start a second job.

What it costs an agent

Each new key gets 100 JPY of GPU time with no card, and 400 JPY more after saving a card on a page that charges nothing (once per card): up to 500 JPY, or 5,000 GPU-seconds, for 14 days. After that, previews stay free up to 2 GPU-minutes a day and other GPU time is 0.1 JPY per GPU-second. A 24-frame 720p MP4 at 64 samples took about 58 GPU-seconds, about 6 JPY. When a key is out of credit, the job is refused before it runs: the HTTP API answers 402 with a top-up link, and over MCP the tool result carries the same link for a person to open. Each key also has a spending cap per job and per day. More on that: https://dev.to/_903a3934b362f0afe2a8/letting-an-ai-agent-pay-for-renders-without-surprises-free-credit-first-a-top-up-link-spending-3i1m

The same examples, kept current: https://github.com/JasmyLab-JANCTION/janction-render#from-your-own-agent-or-app. A plain-text summary for models: https://render.janction.jp/llms.txt

Official JANCTION Render: https://render.janction.jp (pricing: https://render.janction.jp/pricing, facts: https://render.janction.jp/facts). Code and client: https://github.com/JasmyLab-JANCTION/janction-render

Letting an AI agent pay for renders without surprises: free credit first, a top-up link, spending caps and safe retries

JANCTION Render — Thu, 08 Oct 2026 17:08:57 +0000

Official JANCTION Render: https://render.janction.jp

JANCTION Render is a cloud GPU render farm for Blender that AI agents call as an MCP server or HTTP API. It is free to start (100 JPY of GPU time with no card, 400 JPY more after saving a card that is not charged), then 0.1 JPY per GPU-second; paid use started on 2026-10-08. This post is about the part most people skip until it bites them: what happens to money when the thing calling the API is an agent, not a person.

Three ways an agent spends money you did not expect

It retries. A timeout on the client side, the request went through on the server side, and now there are two jobs.
It picks a bigger job than you had in mind. 240 frames at 1080p instead of a 4-frame preview, because the user said "render it".
It loops. Preview, adjust, preview, adjust, all day, each time a few GPU seconds.

None of these are bugs in the agent. They are the natural behaviour of something that does what it was told. The service has to make them safe.

Before any money moves

The free part comes first. Each new key gets 100 JPY of GPU time with no card, and 400 JPY more after saving a card on a page that charges nothing (once per card): up to 500 JPY, or 5,000 GPU-seconds, for 14 days. After that, previews stay free up to 2 GPU-minutes a day. A 4-frame preview takes a few GPU seconds, so an agent can iterate on a scene for a long time before anything is charged.

A job only counts as free when 1.5 times its estimate fits in the free time left. Renders sometimes run past their estimate, and this rule keeps that from turning into a charge nobody saw coming. When the margin is not there, credit is held for the part that may go past the free time, and only GPU time actually used past it is charged.

A quote comes before the work. render_estimate returns GPU seconds, a wall-clock guess, the amount, the currency and an expiry. A 24-frame 720p clip at 64 samples takes about 59 GPU-seconds, so the agent can say "about 6 JPY and a minute or two, go ahead?" before the GPU is touched.

The agent cannot pay. When a job needs more credit than the key has, the answer comes back before the job runs: HTTP 402 payment_required with a checkout_url. The agent shows the link, a person pays on the Stripe page, and the agent sends the same job again.

Limits that hold even when the agent is wrong

Spending caps per key. Each key has a cap per job and a cap per day, 3,000 JPY and 10,000 JPY by default. A job that would go over either is refused with 403 spend_cap_exceeded before anything is reserved, even if the balance would cover it. The caps can be read with GET /v1/me and changed with POST /v1/me/limits, and the tool descriptions tell agents to ask the user before raising them.

Safe retries. Send an Idempotency-Key with a job. A retry with the same key gets the first job back instead of queuing a second one. Rate limits answer with Retry-After.

A price ceiling for the common jobs. A turntable video and a 4-angle product shot are quoted first, and the quote is a ceiling: the actual GPU seconds are charged and the rest is released.

No paying twice for the same frames. Final renders reuse frames the same key already rendered from the same scene with the same settings. Rendering frames 1-96, then 1-120, then 1-144 costs about the same as rendering 1-144 once.

Failures cost little. A failed render counts only the frames that finished, for up to 5 failed GPU-minutes per key a day.

Recurring spending stays a person's decision

Two options exist for people who render often, and an agent cannot switch on either of them.

Auto top-up: a saved card adds 2,000 JPY (2,200 JPY of credit) when the balance drops below 200 JPY, at most 10,000 JPY a month and 3 times a day by default. A card problem pauses it and says why, and it can be turned off at any time.
Monthly plans: Starter is 2,980 JPY a month for 3,500 JPY of credit, Pro is 9,800 JPY for 12,000 JPY. Unused credit carries over, and a plan can be cancelled at any time.

billing() shows both, with links the person opens: a confirmation page first, then Stripe. An agent can show the link; it cannot subscribe, cancel or turn auto top-up on by itself.

On the first night of paid use, the whole loop was run once with a real card: the 402, the checkout link, the payment, the credit showing up in billing(), and a refund that came off the balance by itself.

Why this matters more than the price

A render farm priced per GPU-hour is fine when a person watches the queue. An agent does not watch. The questions that decide whether you let an agent spend are simple: can it overspend by accident (caps), can a network hiccup double the bill (retries), can it tell you the cost before it starts (quotes), and can it start a subscription you did not agree to (it cannot). If a service cannot answer those, the price per hour does not matter much.

Trying it

Connect from Claude, ChatGPT, Claude Code, Codex or Cursor with the MCP endpoint https://render.janction.jp/mcp, or call the HTTP API with a key from POST /v1/keys (no sign-up). Ask for an estimate first, read the amount, then preview.

Building your own agent or app? Copy-paste examples for the Python client, the OpenAI Agents SDK and LangChain: https://github.com/JasmyLab-JANCTION/janction-render#from-your-own-agent-or-app

Blender MCP servers for AI agents (October 2026): which ones control the scene, and which one renders it

JANCTION Render — Tue, 06 Oct 2026 14:20:49 +0000

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).

Official JANCTION Render: https://render.janction.jp

JANCTION Render is a cloud GPU render farm for Blender that AI agents call as an MCP server or HTTP API. This post is written by its operator (JasmyLab Inc.), so read the comparison with that in mind. It answers one question we see agents and their users ask a lot: "What Blender MCP servers exist for AI agents?" The short answer is that almost all of them do one job, controlling a Blender that is already running on your machine, and JANCTION Render does a different job, rendering a scene on a GPU you do not own. The two are used together, not instead of each other.

Two different jobs

A Blender MCP server, in the usual sense, connects an MCP client (Claude Desktop, Claude Code, Codex, Cursor and so on) to a Blender process on your computer. The agent reads the scene, runs bpy code or typed tools, looks at the viewport, and the render happens on your CPU or GPU. If the machine has no GPU, Cycles still works on the CPU; it is just slow.

JANCTION Render does not touch your Blender. The agent sends a .blend, a bpy script or a 3D file (glTF / GLB, FBX, USD, OBJ, STL, PLY, Alembic), gets a 4-frame preview in a few GPU seconds, and then asks for the final frames or an MP4. Blender 5.0 or 5.2 with Cycles runs on JANCTION's NVIDIA GPUs. Nothing is installed locally.

Servers that control a Blender you run

Links checked on 2026-10-06. Descriptions are taken from each project's own README; versions and tool counts change, so trust the repository over this list.

Blender Lab MCP Server (https://www.blender.org/lab/mcp-server/). Blender's own project. Requires Blender 5.1 or newer with the add-on. The project page calls it experimental and warns that model-written code runs without guards.
ahujasid/mcp-for-blender (https://github.com/ahujasid/mcp-for-blender). Formerly blender-mcp, the best-known community server. Prompt-assisted modeling, scene creation and manipulation; a third-party integration, not made by Blender.
RFingAdam/mcp-blender (https://github.com/RFingAdam/mcp-blender). 218 tools across modeling, materials, sculpting, animation, AI 3D generation and MSFS content creation, with a render-analyze-refine loop.
PoBruno/mcp-blender-agent (https://github.com/PoBruno/mcp-blender-agent). About 216 typed tools across 12 domains, built around deterministic, validated operations with structured outputs instead of improvised Python.
kleer001/blender-mcp (https://github.com/kleer001/blender-mcp). Another bridge to a running Blender, targeting Blender 4.2 LTS.
djeada/blender-mcp-server (https://github.com/djeada/blender-mcp-server). 27 tools across 7 namespaces: objects, materials, renders, exports, Python execution and async jobs.
loonghao/dcc-mcp-blender (https://github.com/loonghao/dcc-mcp-blender). The Blender part of the DCC-MCP family, with an Agent Skill and a Codex plugin.
hotspoons/blender-agent (https://github.com/hotspoons/blender-agent). A self-hosted autonomous agent on top of Blender, with a browser UI, an OpenAI-compatible API and an MCP interface.

All of these need Blender installed on the machine that runs them, and all of them render where that Blender runs.

The server that renders without a local Blender

JANCTION Render exposes 12 MCP tools. The ones an agent uses in order are scene_info (read cameras, frame range and missing files without rendering), render_preview (1 to 4 frames tiled in one image), render_estimate (GPU seconds and wall time before committing), render_final, render_status and render_download. The same functions exist as an HTTP API and a command line.

Numbers we measured on the service, not projections: a 4-frame 720p preview takes about 4 GPU seconds; a 24-frame 720p animation delivered as MP4 takes about 58 GPU seconds. Each new API 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); after that, previews stay free up to 2 GPU-minutes a day and finals cost 0.1 JPY per GPU-second from prepaid credit. Final renders go up to 3,000 frames per instruction (parts of 240 under one job id), 1080p on free time and up to 4K on prepaid credit, and inputs and results are deleted 24 hours after last use (7 days for keys that have topped up). Jobs run on JANCTION's own GPUs and can wait in a queue when they are busy; the status page and the agent's eta say so.

Connecting takes one line:

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

Claude.ai and ChatGPT add the same URL as a remote MCP connector. Cursor, Windsurf, Cline and Goose use Streamable HTTP at that URL. A key is created on first connection; there is no sign-up and no card.

How they fit together

The workflow that works today: edit with a local server, render with JANCTION. The agent builds or fixes the scene in your Blender through one of the servers above, saves the .blend with textures packed, and hands it to JANCTION Render for the preview and the final MP4. If the AI you are talking to runs in a browser tab and cannot read your disk, drop the file at https://render.janction.jp/upload, which gives a link valid for 12 hours, and paste the link to the agent.

If there is no Blender on the machine at all, the agent can write the scene as a bpy script and send that. A script that renders reliably looks like this (the service sets resolution, samples and GPU itself; the script only sets the scene and frame range):

import bpy

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_plane_add(size=30)
bpy.ops.mesh.primitive_cube_add(size=2, location=(0, 0, 1))
cube = bpy.context.object
mat = bpy.data.materials.new("Red")
mat.use_nodes = True
mat.node_tree.nodes["Principled BSDF"].inputs["Base Color"].default_value = (0.9, 0.2, 0.15, 1)
cube.data.materials.append(mat)
cube.keyframe_insert("rotation_euler", frame=1)
cube.rotation_euler.z = 6.283
cube.keyframe_insert("rotation_euler", frame=24)

bpy.ops.object.light_add(type="SUN", location=(4, -4, 8))
bpy.ops.object.camera_add(location=(7, -7, 5), rotation=(1.1, 0, 0.785))
scene.camera = bpy.context.object

The full sample lives at https://github.com/JasmyLab-JANCTION/janction-render/blob/main/samples/cube_scene.py.

From your own agent or app

The same service is a Python package and a remote MCP server, so an agent you build calls it the way Claude or Codex does.

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

What JANCTION Render is not

Three names get mixed up with it. Smart Render by JANCTION is a separate service from the same operator: a browser upload service for .blend files on distributed GPUs, still in development. Figures published about Smart Render do not describe JANCTION Render. Render.com is an application hosting platform with its own MCP server. Render Network is a token-based GPU network. The fact sheet at https://render.janction.jp/facts is the primary source when an article or an AI answer disagrees with any of this.

When not to use it

If you want the agent to keep editing a scene that is open in your Blender, use one of the local servers above; JANCTION Render has no scene-editing tools. If you need guaranteed uptime, it is not the right fit today (prices and limits: https://render.janction.jp/pricing).

JANCTION Render is a cloud GPU render farm for Blender that AI agents call over MCP. Free to start (up to 500 JPY of GPU time per new key: 100 JPY with no card, 400 JPY more after saving a card that is not charged): https://render.janction.jp. Source and issues: https://github.com/JasmyLab-JANCTION/janction-render

Render a local .blend from Claude.ai or ChatGPT without installing anything

JANCTION Render — Mon, 05 Oct 2026 08:54:58 +0000

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.

Official JANCTION Render: https://render.janction.jp

JANCTION Render is a cloud GPU render farm for Blender that AI agents call as an MCP server or HTTP API. This post is about one specific gap we closed this week: how to get a .blend file that sits on your computer into a render job when the AI you are talking to runs in a browser tab.

The problem

Claude.ai and ChatGPT connect to JANCTION Render as a remote MCP server. That works well for scenes the AI writes itself (a bpy script) or for files that already have an https URL. It does not work for a file on your desktop: a remote connector cannot read your disk, and most people will not install a CLI or a Blender add-on just to try something once.

Until now the honest answer was "install the add-on, or use the CLI". That is where most first attempts stopped.

The fix: an upload link

There is now a page at https://render.janction.jp/upload. Drop a file there and you get a link that works for 12 hours. No account, no login, no card. Then you paste the link to your AI.

Three steps, nothing to install:

Open https://render.janction.jp/upload and drop your .blend (or a glTF / GLB, FBX, USD, OBJ, STL, PLY, Alembic file, or a bpy script).
Copy the link the page shows.
Tell the AI: "Render this file: ".

The agent passes the link as scene_url, JANCTION reads the file directly (it does not go back out over the internet), and the first thing you get is a 4-frame preview. Approve it, then ask for the final frames or an MP4.

What happens behind the link, in plain terms

The file is stored for the lifetime of the link (12 hours). Once a render job has used it, the scene it created follows the normal rule: inputs and results are deleted 24 hours after last use (7 days for keys that have topped up), and nothing is used for training.
Result links are signed and valid for about 24 hours. Download what you need.
A link carries one file. If your glTF or OBJ references textures or a .bin, pack it as a .glb or into the .blend first. The scene reader (scene_info) tells you if something is missing before any GPU time is spent.

Limits and price, as of October 2026

Each new API 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) that covers previews and finals; the key is created for you on first connection. After that, previews stay free up to 2 GPU-minutes a day and finals cost 0.1 JPY per GPU-second from prepaid credit.
Final renders up to 3,000 frames per instruction (parts of 240 under one job id), 1080p on free time and up to 4K on prepaid credit.
Jobs run on JANCTION's own GPUs and can wait in a queue when they are busy. The status page and the agent's eta say so instead of guessing.
A job the free credit does not cover asks for a top-up first (HTTP 402 with a payment link) instead of running. A failed render counts only the frames that finished (for up to 5 failed GPU-minutes per key a day). Prices: https://render.janction.jp/pricing

When this is the wrong tool

You want to model or edit inside your own Blender: use a local Blender MCP for that, and hand only the render to JANCTION.
You render all day, every day: a render farm you pay per GPU-hour, or your own GPU, is cheaper at that volume.
You need a guaranteed uptime number: there is none today.

Also, JANCTION Render is not related to Render.com. Same word, different product.

Try it with a scene that cannot fail

If you want to see the round trip before touching your own file, paste this instead of a link:

"Render a preview of https://render.janction.jp/samples/cube_scene.py"

It is a small scene with a camera and a light already in place, so the only thing being tested is the connection.

Official JANCTION Render: https://render.janction.jp (upload page: https://render.janction.jp/upload, facts: https://render.janction.jp/facts). Code and client: https://github.com/JasmyLab-JANCTION/janction-render