Connect

8 clients · secrets stay placeholders

JSON (mcpServers)Claude CodeCodexOpenCodeCursorVS CodeGemini CLIGoose

{
  "mcpServers": {
    "janction-render": {
      "type": "http",
      "url": "https://render.janction.jp/mcp?src=registry"
    }
  }
}

claude mcp add --transport http janction-render https://render.janction.jp/mcp?src=registry

[mcp_servers.janction-render]
url = "https://render.janction.jp/mcp?src=registry"

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "janction-render": {
      "type": "remote",
      "url": "https://render.janction.jp/mcp?src=registry",
      "enabled": true
    }
  }
}

{
  "mcpServers": {
    "janction-render": {
      "type": "http",
      "url": "https://render.janction.jp/mcp?src=registry"
    }
  },
  "deeplink": "cursor://anysphere.cursor-deeplink/mcp/install?name=janction-render&config=eyJ0eXBlIjoiaHR0cCIsInVybCI6Imh0dHBzOi8vcmVuZGVyLmphbmN0aW9uLmpwL21jcD9zcmM9cmVnaXN0cnkifQ%3D%3D"
}

{
  "servers": {
    "janction-render": {
      "type": "http",
      "url": "https://render.janction.jp/mcp?src=registry"
    }
  }
}

{
  "mcpServers": {
    "janction-render": {
      "httpUrl": "https://render.janction.jp/mcp?src=registry"
    }
  }
}

extensions:
  "janction-render":
    enabled: true
    name: "janction-render"
    type: streamable_http
    uri: "https://render.janction.jp/mcp?src=registry"
    timeout: 300

Quality 69 / 100needs work

protocol75 · weight 25

warn
protocol.modernnewest supported version is 2025-11-25; 2026-07-28 not supported, older versions are deprecated until 2027-07-28
n/a
protocol.statelessonly applies to 2026-07-28 servers
pass
protocol.transportstreamable HTTP
n/a
protocol.list_ttlonly applies to 2026-07-28 servers

authorizationn/a · weight 15

n/a
auth.prm, auth.as_metadata, auth.cimdno remote uses OAuth
n/a
auth.secret_in_urlno templated URL

tool hygiene86 · weight 30

pass
tools.descriptionsevery tool has a description
warn
tools.description_length2 tools have descriptions over 1,024 characters, which crowds the context
pass
tools.schemasevery tool has an object input schema
pass
tools.annotations16 of 16 tools declare readOnlyHint or destructiveHint
pass
tools.directory_hintsevery tool declares readOnlyHint, destructiveHint, idempotentHint and openWorldHint
warn
tools.token_costabout 10,722 tokens to load every tool
pass
tools.api_dumptools are not a one-to-one API dump

stability25 · weight 15

warn
stability.changes34 tool changes in 30 days
fail
stability.rug_pull3 tools kept their name but changed most of their description in 30 days; review before trusting them

dependenciesn/a · weight 15

n/a
deps.known_vulns, deps.mcp_sdk_version, deps.resolvabledependencies not resolved yet

16 tools, about 10,722 tokens to load them all · tool set bd3bb24f85b7 · tools last changed 2026-10-19 · checked 2026-10-20 12:13 UTC

Tool changes

2026-10-19render_finalchangeddescription, input schema
before
Render the final frames or video of a Blender scene on cloud GPUs, after the user approved a preview: 'render the final', 'make the video', 'export the turntable MP4'. Call render_estimate first when the time or the free GPU time left (the welcome credit, or 2 preview GPU-minutes a day after it) is uncertain, the job is longer than about 24 frames or above 720p, or the user asks how long it takes, and tell the user. For animations, keep the approved engine/look, test 10 contiguous final-path frames, then estimate again. Long jobs are rendered in chunks and joined into one video. Returns job_id and estimate.human at once (short jobs return the links directly); then call render_download(job_id, wait_seconds=45). Use the same environment and blender as the approved preview. Limits: up to 3,000 frames per call (over 240 runs as parts under one job id); 1920x1080 on free time, 3840x2160 with prepaid credit; each new key gets 100 JPY of GPU time free with no card (14 days) and 400 JPY more once the user saves a card on a page that charges nothing (once per card); after that, previews are free up to 2 GPU-minutes a day and finals cost 0.1 JPY per GPU-second (prepaid); ask before a render the free time does not cover; files are deleted 24 h after last use (7 days once topped up). preset='product' | 'turntable' | 'animation' fills the settings for that purpose. Options per parameter: output (png, exr, mp4, webm, prores, gif, webp), orbit, cameras, transparent, engine, notify_url, asset_urls ('polyhaven:<id>'). Pass scene_id from render_preview, or scene_script / scene_url for a new scene.
after · 96% of words in common
Render the final frames or video of a Blender scene on cloud GPUs, after the user approved a preview: 'render the final', 'make the video', 'export the turntable MP4'. Call render_estimate first when the time or the free GPU time left (the welcome credit, or 2 preview GPU-minutes a day after it) is uncertain, the job is longer than about 24 frames or above 720p, or the user asks how long it takes, and tell the user. For animations, keep the approved engine/look, test 10 contiguous final-path frames, then estimate again. Long jobs are rendered in chunks and joined into one video. Returns job_id and estimate.human at once (short jobs return the links directly); then call render_download(job_id, wait_seconds=45). Use the same environment and blender as the approved preview. Render only what the user approved at the shown price (max_yen caps it). Limits: up to 3,000 frames per call (over 240 runs as parts under one job id); 1920x1080 on free time, 3840x2160 with prepaid credit; each new key gets 100 JPY of GPU time free with no card (14 days) and 400 JPY more once the user saves a card on a page that charges nothing (once per card); after that, previews are free up to 2 GPU-minutes a day and finals cost 0.1 JPY per GPU-second (prepaid); ask before a render the free time does not cover; files are deleted 24 h after last use (7 days once topped up). preset='product' | 'turntable' | 'animation' fills the settings for that purpose. Options per parameter: output (png, exr, mp4, webm, prores, gif, webp), orbit, cameras, transparent, engine, notify_url, asset_urls ('polyhaven:<id>'). Pass scene_id from render_preview, or scene_script / scene_url for a new scene.
2026-10-19render_previewchangeddescription
before
Show what a Blender scene looks like: a fast, low-cost preview render on a cloud GPU, back as an image in seconds. Typical requests: 'render this .blend', 'show me the scene', 'preview the turntable', 'I have no GPU', 'Blender is too slow on my laptop', 'Blenderでレンダリングして', 'GPUがない', 'ターンテーブル', '商品の360度動画'. Also use it after writing a bpy script, to see what it builds. Each preview returns a critic verdict (ok / check / fix) with fix code: apply the fixes and preview again before any final render. It also returns final_estimate (the same scene as a 1080p final) and quota_left_today; tell the user both before asking to go on. A script that raises comes back as a failure with the line (nothing is rendered). When not to use: editing a scene open in the user's Blender belongs to a local Blender MCP, and a single still on a machine with its own NVIDIA GPU usually renders faster locally. This service is for CPU-only machines, animations, and scripts with no Blender installed. Limits: up to 1280x720; 1-4 frames tiled in one labeled image for the GPU time of one 720p frame. preset='product' | 'turntable' | 'animation' sets camera, light, backdrop and frames for that purpose. Other options are explained on each parameter: environment presets and 'compare', orbit (turntable), cameras (several named cameras), engine, transparent, asset_urls with 'polyhaven:<id>' CC0 assets. Give the scene as scene_script (bpy code as text), scene_url (an https link to a .blend, .py or 3D file) or scene_id; reuse the returned scene_id in render_final.
after · 95% of words in common
Show what a Blender scene looks like: a fast, low-cost preview render on a cloud GPU, back as an image in seconds. Typical requests: 'render this .blend', 'show me the scene', 'preview the turntable', 'I have no GPU', 'Blender is too slow on my laptop', 'Blenderでレンダリングして', 'GPUがない', 'ターンテーブル', '商品の360度動画'. Also use it after writing a bpy script, to see what it builds. Each preview returns a critic verdict (ok / check / fix) with fix code: apply the fixes and preview again before any final render. It also returns final_estimate (the same scene as a 1080p final) and quota_left_today; tell the user both before asking to go on. Prices come before rendering: final_offers give each next render's time and price, and a paid one needs the user's approval. A script that raises comes back as a failure with the line (nothing is rendered). When not to use: editing a scene open in the user's Blender belongs to a local Blender MCP, and a single still on a machine with its own NVIDIA GPU usually renders faster locally. This service is for CPU-only machines, animations, and scripts with no Blender installed. Limits: up to 1280x720; 1-4 frames tiled in one labeled image for the GPU time of one 720p frame. preset='product' | 'turntable' | 'animation' sets camera, light, backdrop and frames for that purpose. Other options are explained on each parameter: environment presets and 'compare', orbit (turntable), cameras (several named cameras), engine, transparent, asset_urls with 'polyhaven:<id>' CC0 assets. Give the scene as scene_script (bpy code as text), scene_url (an https link to a .blend, .py or 3D file) or scene_id; reuse the returned scene_id in render_final.
2026-10-16scene_revision_listadded
List revisions of one owned creation project, including the source hash, edit plan, job and validation state.
2026-10-16scene_editadded
Edit a source scene and save a NEW .blend. This is distinct from rendering. The accepted edit plan is allowlisted; arbitrary Python is not executed. Animation/rig preservation defaults to true, and the saved file is reopened in a separate Blender process before it can be delivered.
2026-10-16janction_resumeadded
Recover the latest durable project state after a disconnect. Omit project_id only when the authenticated account's most recent project is unambiguous. This never invents completion from conversation text.
2026-10-16janction_createadded
Start one durable creation workflow, or continue project_id. Use this for requests for an editable .blend, not render_final. The original is never overwritten. A supplied ChatGPT file is transferred directly by its temporary download_url. Returns project_id/job_id and a Web resume URL. Completion is reported only after the requested artifacts exist and validation succeeds. free_only enforces a zero-yen request cap server-side.
2026-10-15scene_infochangedinput schema
2026-10-15render_finalchangedinput schema
2026-10-15render_previewchangedinput schema
2026-10-15render_downloadchangeddescription
before
Get the download links of a job (no key needed, valid about 24 hours; call again for fresh links while the files are kept, 24 h after last use or 7 days for keys that have topped up) and show them to the user; in a terminal, fetch them with curl -o. A finished preview also comes back as an inline image. wait_seconds > 0 first waits for the job (the service waits at most 50 s per call; call again while it is still running). only picks the files: 'output' (default: the MP4 or the preview sheet, plus the first frames), 'mp4', 'sheet', 'frames' or 'all'.
after · 93% of words in common
Get the download links of a job (no key needed, valid about 24 hours; call again for fresh links while the files are kept, 24 h after last use or 7 days, normally, for paid keys) and show them to the user; in a terminal, fetch them with curl -o. A finished preview also comes back as an inline image. wait_seconds > 0 first waits for the job (the service waits at most 50 s per call; call again while it is still running). only picks the files: 'output' (default: the MP4 or the preview sheet, plus the first frames), 'mp4', 'sheet', 'frames' or 'all'.

Showing the latest 10. Full history: list_changes · trend: quality JSON.

Checks run on what our credential-free, read-only probes observe; tools are never called and no code audit is performed. How it is computed.

Trust 92 / 100

multi-version-spam

provenance90

liveness100

freshness100

hygiene75

+repository +namespace-matches-repo +website +reachable +uptime-100% +updated-0d-ago -multi-version-spam(123)

Derived from observable signals (official registry feed and our own credential-free probes); no code audit performed. How it is computed.

Dependencies

[email protected] PyPInot resolved yet; dependencies are read once a day

Dependency graphs from deps.dev; advisories from OSV.dev, including the GitHub Advisory Database and the PyPI Advisory Database; all CC BY 4.0. The graph is what a clean install of this version resolves today; nothing was installed or run. How it is checked.

Endpoints

remote	auth	reachable	uptime 30d	p50	protocol	last ok
`https://render.janction.jp/mcp?src=registry` streamable-http	none	yes	100%	614 ms	2025-11-25	2026-10-20

package	registry	version	runtime	secrets
`janction-render`	pypi	0.4.152	uvx	`JANCTION_RENDER_API_KEY`

Tools (16)

`asset_search`read-only	Find free CC0 3D models, PBR textures or HDRIs on Poly Haven by words ('wooden chair', 'forest hdri') to furnish a scene without uploading files; no GPU time. For product shots of something the user has no model for: asset_search('<item>'), then render_preview(scene_script='import jr_assets; jr_assets.import_model("<id>")', asset_urls=['polyhaven:<id>'], preset='product') gives 4 studio shots on a plain backdrop. Each result has a spec 'polyhaven:<id>' to pass in asset_urls, its size in metres and the entry file. In the scene script: import jr_assets, then jr_assets.import_model('<id>', location=(x, y, z), scale=1.0) returns the objects, jr_assets.material('<id>') builds a material and jr_assets.apply(obj, mat) assigns it, jr_assets.world_hdri('<id>', strength=1.0) lights the world. 'polyhaven:<id>@2k' fetches 2k textures (1k by default).
`billing`read-only	Check what this key can still render for free and its credit (no GPU time): the free GPU time left and when it expires or resets (each new key gets 100 JPY of GPU time free with no card (14 days) and 400 JPY more once the user saves a card on a page that charges nothing (once per card); after that, previews are free up to 2 GPU-minutes a day and finals cost 0.1 JPY per GPU-second (prepaid)), the balance in yen, the price per GPU-second, any pending checkout link, and card_offer / autocharge_offer when they apply. Relay tell_user to the user in their language when it is present.
`janction_create`	Start one durable creation workflow, or continue project_id. Use this for requests for an editable .blend, not render_final. The original is never overwritten. A supplied ChatGPT file is transferred directly by its temporary download_url. Returns project_id/job_id and a Web resume URL. Completion is reported only after the requested artifacts exist and validation succeeds. free_only enforces a zero-yen request cap server-side.
`janction_resume`read-only	Recover the latest durable project state after a disconnect. Omit project_id only when the authenticated account's most recent project is unambiguous. This never invents completion from conversation text.
`render_cancel`destructive	Stop a queued or running render job of this key (a j_... job, or a b_... job split into parts, which stops every part). Effects: queued frames are dropped; frames already rendered are charged and stay downloadable until the job expires; the rest of the GPU time held for the job is returned to the key at once. It cannot be undone or resumed: to render again, call render_final again (a new job). A job that is already done, failed or canceled is returned unchanged, and a job whose frames are all rendered and is being assembled into the video cannot be stopped (nothing more is charged). Only the key that started the job can stop it; any other job_id returns not_found. Ask the user before cancelling a render they asked for.
`render_download`read-only	Get the download links of a job (no key needed, valid about 24 hours; call again for fresh links while the files are kept, 24 h after last use or 7 days, normally, for paid keys) and show them to the user; in a terminal, fetch them with curl -o. A finished preview also comes back as an inline image. wait_seconds > 0 first waits for the job (the service waits at most 50 s per call; call again while it is still running). only picks the files: 'output' (default: the MP4 or the preview sheet, plus the first frames), 'mp4', 'sheet', 'frames' or 'all'.
`render_estimate`read-only	Estimate a render before starting it (no GPU time): GPU seconds, queue wait, the wall-clock time as text (estimate.human, e.g. 'about 3 minutes') and whether it fits the free GPU time left (the welcome credit, or 2 preview GPU-minutes a day after it) and the size limits. Call it before render_final when the time or quota is uncertain, the job is longer than about 24 frames or above 720p, or the user asks how long it takes; tell the user the result. With scene_id the estimate uses measured render times and returns calibration.final_path_measured. If false, treat it as preliminary: run a short contiguous final-path test and estimate again before the full animation. It also says when to split a job.
`render_final`	Render the final frames or video of a Blender scene on cloud GPUs, after the user approved a preview: 'render the final', 'make the video', 'export the turntable MP4'. Call render_estimate first when the time or the free GPU time left (the welcome credit, or 2 preview GPU-minutes a day after it) is uncertain, the job is longer than about 24 frames or above 720p, or the user asks how long it takes, and tell the user. For animations, keep the approved engine/look, test 10 contiguous final-path frames, then estimate again. Long jobs are rendered in chunks and joined into one video. Returns job_id and estimate.human at once (short jobs return the links directly); then call render_download(job_id, wait_seconds=45). Use the same environment and blender as the approved preview. Render only what the user approved at the shown price (max_yen caps it). Limits: up to 3,000 frames per call (over 240 runs as parts under one job id); 1920x1080 on free time, 3840x2160 with prepaid credit; each new key gets 100 JPY of GPU time free with no card (14 days) and 400 JPY more once the user saves a card on a page that charges nothing (once per card); after that, previews are free up to 2 GPU-minutes a day and finals cost 0.1 JPY per GPU-second (prepaid); ask before a render the free time does not cover; files are deleted 24 h after last use (7 days once topped up). preset='product' \| 'turntable' \| 'animation' fills the settings for that purpose. Options per parameter: output (png, exr, mp4, webm, prores, gif, webp), orbit, cameras, transparent, engine, notify_url, asset_urls ('polyhaven:<id>'). Pass scene_id from render_preview, or scene_script / scene_url for a new scene.
`render_info`read-only	Check the connection and the service before rendering (read-only, no GPU time, no charge): the server URL, whether GPU workers are online, the queue length and expected wait, and this key's usage. Use it before the first render or when renders seem stuck, and to decide whether to route a render here: workers_available > 0 means a preview comes back in seconds; gated means the GPU is lent out and gate says how long the wait usually is. It runs as the connected account (OAuth or the API key in the connector). Every call is rate-limited per key; a 429 response carries retry_after_s, wait that long. diagnose.tell_user says in plain words whether the connection, the key, the free credit and the GPUs are fine and what the last failed render said; relay it when the user asks why something does not work.
`render_preview`	Show what a Blender scene looks like: a fast, low-cost preview render on a cloud GPU, back as an image in seconds. Typical requests: 'render this .blend', 'show me the scene', 'preview the turntable', 'I have no GPU', 'Blender is too slow on my laptop', 'Blenderでレンダリングして', 'GPUがない', 'ターンテーブル', '商品の360度動画'. Also use it after writing a bpy script, to see what it builds. Each preview returns a critic verdict (ok / check / fix) with fix code: apply the fixes and preview again before any final render. It also returns final_estimate (the same scene as a 1080p final) and quota_left_today; tell the user both before asking to go on. Prices come before rendering: final_offers give each next render's time and price, and a paid one needs the user's approval. A script that raises comes back as a failure with the line (nothing is rendered). When not to use: editing a scene open in the user's Blender belongs to a local Blender MCP, and a single still on a machine with its own NVIDIA GPU usually renders faster locally. This service is for CPU-only machines, animations, and scripts with no Blender installed. Limits: up to 1280x720; 1-4 frames tiled in one labeled image for the GPU time of one 720p frame. preset='product' \| 'turntable' \| 'animation' sets camera, light, backdrop and frames for that purpose. Other options are explained on each parameter: environment presets and 'compare', orbit (turntable), cameras (several named cameras), engine, transparent, asset_urls with 'polyhaven:<id>' CC0 assets. Give the scene as scene_script (bpy code as text), scene_url (an https link to a .blend, .py or 3D file) or scene_id; reuse the returned scene_id in render_final.
`render_share`	Publish a finished render as a public web page anyone with the link can open (for X, Discord or a client): the image or video, the render settings, an optional title and note, the user's request in their words (prompt), and the bpy script only if include_script=True. The page keeps its own copy of the result after the job's files expire, until render_unshare. listed=True only asks to appear in the public gallery; the operator reviews it first. Public: ask the user before sharing and return the url to them. Only the key that rendered the job can share it.
`render_status`read-only	Check a render job: status (queued / running / done / failed / canceled), frames done, the ETA (eta.human, including queue wait), files ready, Blender warnings, and the error with the log tail if it failed. Use it to report progress to the user; render_download(job_id, wait_seconds=45) waits and returns the links in one call. Without job_id it lists this key's recent jobs and the scene_ids still kept, to pick up earlier work in a new conversation.
`render_unshare`destructive	Take down the public share page of a job made with render_share. Effects: the page URL stops working, its copy of the image or video, the shared script and the shown request are deleted, and the page leaves the public gallery. This cannot be undone: sharing again makes a new page with a new URL. The job's own files are not touched (they expire on their usual schedule). Only the key that shared the job can take the page down; a job without a share page returns not_found.
`scene_edit`	Edit a source scene and save a NEW .blend. This is distinct from rendering. The accepted edit plan is allowlisted; arbitrary Python is not executed. Animation/rig preservation defaults to true, and the saved file is reopened in a separate Blender process before it can be delivered.
`scene_info`	Read a Blender scene without rendering (a few seconds, no GPU time): cameras and the active one, frame range and fps, resolution, objects by type, lights, materials, whether it is animated, and missing linked files that would render pink. Use it for a .blend you did not write, or to check what a bpy script built. Returns scene_id; pass it to render_preview and render_final instead of sending the scene again.
`scene_revision_list`read-only	List revisions of one owned creation project, including the source hash, edit plan, job and validation state.

Schemas: list_tools.

Similar MCP servers

Official server.json

{
  "name": "io.github.JasmyLab-JANCTION/janction-render",
  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
  "remotes": [
    {
      "url": "https://render.janction.jp/mcp?src=registry",
      "type": "streamable-http"
    }
  ],
  "version": "0.4.152",
  "packages": [
    {
      "version": "0.4.152",
      "transport": {
        "type": "stdio"
      },
      "identifier": "janction-render",
      "runtimeHint": "uvx",
      "registryType": "pypi",
      "registryBaseUrl": "https://pypi.org",
      "environmentVariables": [
        {
          "name": "JANCTION_RENDER_SERVER",
          "description": "Service URL (default https://render.janction.jp; set http://127.0.0.1:8340 for a local server)"
        },
        {
          "name": "JANCTION_RENDER_API_KEY",
          "isSecret": true,
          "description": "API key. Optional: a temporary key is issued automatically on first use."
        }
      ]
    }
  ],
  "repository": {
    "url": "https://github.com/JasmyLab-JANCTION/janction-render",
    "source": "github"
  },
  "websiteUrl": "https://render.janction.jp",
  "description": "Blender and GLB/FBX/USD/STL rendered on cloud GPUs for AI agents: product shots, turntables, MP4"
}