How to Preview a .riv File Online and Test Its State Machines
By the Charmotion team · Updated · How we write guides

To preview a .riv file online, drop it into a viewer built on Rive's web runtime, such as our free Rive File Inspector, or open the source file in the Rive editor and press play above the state machine graph. Rive's old drag-and-drop page at rive.app/preview no longer loads, and its shareable embed links need a Voyager or Enterprise plan.
Key takeaways
- Rive's old rive.app/preview drag-and-drop page returned a 404 when we checked in November 2026.
- In the Rive editor, the play button above the graph runs a state machine so you can test it, but you need the source file and an account.
- Embed URLs share a snapshot of one artboard and state machine with a team; they need a Voyager or Enterprise plan.
- Browser inspectors read a .riv locally and let you fire triggers, flip booleans and set view model properties.
- Most blank previews come from a missing state machine name, wrong artboard, canvas sizing, CORS or assets the file expects you to supply.
Does Rive have an official .riv preview tool?
Not a standalone one any more. Years ago a Rive maker told Product Hunt users to "drag and drop your .riv file ... into our preview tool" at rive.app/preview. That address returned a 404 when we checked in November 2026. What Rive offers now (as of November 2026):
| Option | What you need | Can you test the state machine? | Best for |
|---|---|---|---|
| Rive editor, play button above the graph | The editable file and a Rive account | Yes, interactively | The designer, while building |
| Marketplace file page, "Preview in Rive" | A file someone published to the Marketplace | Opens it in Rive | Trying community files |
| Embed URL (hosted link, embed link or iframe code) | Voyager or Enterprise plan | Plays the one artboard and state machine chosen when the link was made | Sharing a snapshot with a team or client |
| Rive CLI preview window | A project your coding agent builds from Rive Markup Language | Shows the project as it is built | Agent workflows, not opening an existing .riv |
Two limits matter for a "team Rive preview". Rive's docs say an embed URL "is a snapshot of your file at the moment it's generated", so later edits need a new link, and that embeds "use iframes and don't provide access to Rive's runtime APIs." Viewers can't switch artboards or drive values from code. If a developer has only the exported .riv and no editor access, a runtime-based viewer is the practical choice.
How do I preview a .riv file in the browser for free?
Use a viewer that loads the file with Rive's open-source web runtime. Our free Rive File Inspector does this entirely in your browser: the file is never uploaded. Drop a .riv (up to 25 MB) and it:
- Lists the contents: every artboard with its timelines and state machines, each state machine's inputs with their type (number, boolean, trigger), every view model with its properties, types and instances, and the file's enums.
- Plays it live: pick an artboard, then a state machine or a single timeline, and it plays in a preview canvas.
- Gives you controls: trigger inputs become buttons, booleans become checkboxes and numbers become fields. If the file has a view model, the default instance is bound and its number, boolean, trigger and string properties get controls too.
- Runs an integration check: it says whether the file has a state machine, whether it has Data Binding view models, how many legacy inputs it uses, and flags files over 512 KB, which usually embed raster images.
- Exports a report: "Copy report as JSON" gives a developer the exact artboard, state machine and property names.
Limits, so you aren't surprised: the preview uses Rive's lightweight canvas runtime, so it does not draw Rive Text or play audio (the report still lists those files' contents), it doesn't fetch Hosted assets from Rive's CDN, and it rejects .rev backups because they lack the RIVE signature a runtime file starts with.
Other free viewers exist. Rive Playground is open source, with live boolean, number and trigger controls, view model editing and an event log. Preview Rive (rive.rip) lets you drag in a file, switch between animations and state machines, and change fit, alignment and background. Rive's awesome-rive list links more.
Disclosure: Charmotion is our product. We list it where it fits and say where other tools are better; every other fact links to its source.
The inspector's two sample files, Kiko and Gummo, are real Charmotion output: a character .riv generated from one image. If you need a file like that for your own character, see PNG to Rive.
How do I test state machine inputs, triggers and view models?
A state machine connects timelines with logic. Each artboard can hold several state machines, and a layer "plays one state at a time", so a character often runs a body layer and a blink layer side by side. The runtime picks which state machine to run; your code, or a viewer, then changes values that transitions listen to. More background is in Rive state machines explained.
There are two kinds of values to test:
- State machine inputs (older files): number, boolean and trigger. Rive's web docs now mark inputs as deprecated, but its migration guide says "You do not need to update existing files. Inputs and events will continue to work."
- View model properties (Data Binding, recommended for new work): numbers, booleans, triggers, strings, enums, colors, lists, images and more. With
autoBind: true, the runtime binds the default view model instance.
A quick test pass:
- Note which state plays on load. That is what users see before any code runs.
- Fire each trigger and confirm a reaction plays and returns where it should.
- Flip each boolean on and off, and step each number through the values the designer intended (for example 0, 1, 2, 3 for a mood).
- Set values that should do nothing, such as a number out of range, and check the file stays in a sensible state.
- Repeat for every artboard and state machine your app will load.
How do I preview a .riv on my own web page?
A plain HTML file is enough, which is also the simplest way to share a preview with a team: host one page and send the link. Serve it from a local server rather than opening it from disk, so the browser can fetch the .riv.
<canvas id="c" width="500" height="500"></canvas>
<script src="https://unpkg.com/@rive-app/canvas"></script>
<script>
const r = new rive.Rive({
src: "character.riv",
canvas: document.getElementById("c"),
stateMachine: "State Machine 1", // the exact name from the file
autoplay: true,
autoBind: true,
onLoad: () => r.resizeDrawingSurfaceToCanvas(),
});
</script>
- Name the state machine. Per Rive's docs, without
stateMachinethe web runtime "will currently play the first linear animation it finds on the artboard", so nothing reacts to input.stateMachine(singular) arrived in v2.41.0 and replaces the deprecatedstateMachines. - Artboard: add
artboard: "Name"to pick one; otherwise the file's default artboard plays. - Package: Rive recommends
@rive-app/webgl2, which supports every editor feature.@rive-app/canvaslacks some rendering features such as Layer Masks, and@rive-app/canvas-liteis smaller and suits files without Rive Text, audio, layouts or scripting.
For React and Next.js, see Rive in React and Next.js.
Why does my .riv file show blank or not animate?
Work down this list; the inspector answers the first two in seconds because it shows the real names inside the file.
- No state machine named, or the wrong name. The runtime falls back to the first timeline, which may be a still pose. Rive's FAQ: make sure you've specified the
stateMachineproperty and setautoplay: true. - Wrong artboard. If you omit
artboard, the default one plays, which may be an empty or test artboard. - Canvas size. With no width and height attributes the drawing is tiny or blurry. Call
resizeDrawingSurfaceToCanvas()on load and keep the attributes at least as large as the CSS size. - CORS. A .riv on a CDN or S3 needs CORS headers, or the browser blocks the fetch.
- Content Security Policy. A strict CSP can stop the WebAssembly from loading; Rive points to the
wasm-unsafe-evalsetting. - Missing assets. Images and fonts marked Referenced are not inside the .riv, so your app must load them with an asset loader; Hosted assets come from Rive's CDN.
- Runtime package or version. Canvas and lite builds skip some features. Rive says a newer file still loads in an older runtime, but a feature added later "may be skipped", so update the runtime.
- It's a .rev, not a .riv. A .rev is an editor backup. Export from the editor with Export, For Runtime (or Publish, To .riv).
Not blank but surprising: on Rive's Free plan, exported files play a Rive splash screen; paid plans export without it.
Preview a .riv file and test its state machines
- Check you have a .riv. Runtime files end in .riv. A .rev is an editor backup and must be imported into the Rive editor and exported For Runtime first.
- Open it in a browser viewer. Drop the file into a runtime-based viewer such as the Rive File Inspector. It is read locally and not uploaded.
- Read the names. Note the artboards, state machines, inputs and view model properties. These are the exact strings your code will need.
- Pick the artboard and state machine. Choose the pair your app will load and watch which state plays first.
- Drive every value. Fire each trigger, flip each boolean, step through each number and edit view model properties, checking each reaction returns to idle.
- Reproduce it in your page. Load the file with the web runtime, set the same artboard and stateMachine names, and call resizeDrawingSurfaceToCanvas on load.
Frequently asked questions
Can I preview a .riv file without a Rive account?
Yes. Runtime-based viewers such as the Rive File Inspector, Rive Playground or a small HTML page with the web runtime play a .riv without an account. The Rive editor needs an account, and embed links need a Voyager or Enterprise plan.
What is a .riv file?
It is the runtime export of a Rive file. Rive calls it the production-ready version: artboards, animations, state machines, data binding and scripts run exactly as built, and the same .riv works across Rive's web, mobile and game engine runtimes. It can't be edited like the source file.
How do I share a Rive preview with my team?
On Voyager or Enterprise, generate an embed URL and send the hosted link, remembering it is a snapshot. On any plan, send the .riv and let teammates open it in a browser viewer, or host a one-page HTML preview.
Why do my inputs show a deprecation warning?
Rive now recommends Data Binding view models instead of state machine inputs. Existing files with inputs keep working on the web, but new files should expose view model properties, which the inspector also lists and lets you edit.
Quick answers from this guide
Sources
- State Machine Overview, Rive
- Embed URLs, Rive
- Exporting for Runtime, Rive
- Web (JS) runtime, Rive
- Rive Parameters, Rive
- Web runtime: State Machine Playback, Rive
- Web runtime: Inputs (deprecated), Rive
- Web runtime: Data Binding, Rive
- Data Binding Migration Guide, Rive
- Web runtime FAQ, Rive
- Feature Support, Rive
- Web runtime: Loading Assets, Rive
- Rive, Rive
- Rive on Product Hunt (maker comment on the preview tool), Product Hunt
- Snake Game (Marketplace file by TeamRive), Rive Marketplace
- Rive Playground, nano-step (GitHub)
- Preview Rive, rive.rip
- awesome-rive, Rive (GitHub)