Free cloud gaming gives you a session, not a file. When the timer runs out or the queue boots you, the great fight you just won exists only in your memory. OBS Studio 33.0.1 is the current stable build of the free recorder, and it can turn any free session into a shareable clip after about 50 minutes of setup, because all three big free routes (GeForce NOW Free, Xbox Cloud Gaming and Amazon Luna) arrive on your screen as a browser or app window that OBS can see.
This tutorial builds a repeatable clip pipeline in 12 steps. You will configure OBS with a replay buffer so one hotkey saves the last 45 seconds, tune audio so game sound and voice land on separate tracks, and write a small Python watcher that trims, normalizes and labels every clip. If you have not set up a free service yet, start with our free cloud gaming setup guide and come back here once you can launch a game.
Recording cloud games differs from recording a local game in three ways. The picture is already compressed once by the service before OBS touches it, so wasteful settings add nothing. Free sessions have clocks, which makes a replay buffer far more useful than a long recording. And every service wraps the stream in a browser or client that can fight your capture method, which is where most black-screen reports come from.
Don’t miss new tech stories on Google
Add Tech Insider once in the Google app and our stories appear in your news suggestions.
Add Now
What You Are Building and Why a Replay Buffer Beats Full Recording
The finished project has four parts. OBS runs a profile tuned for cloud streams. A replay buffer keeps the last 45 seconds in memory and writes a file when you press a hotkey. A folder watcher called Clipvault picks up each new file, trims dead air, evens out the loudness and renames it with the service and game. Finally, a log file records every clip so you can compare services later.
The replay buffer matters more on free tiers than anywhere else. A free session ends on someone else’s schedule, so you do not want a two-hour recording running in the background that eats disk space and forces you to scrub for the good 20 seconds. You also do not want to remember to press record before the moment happens. With a buffer, you play normally and save the moment right after it happens.
Disk and CPU cost stay low as well. The buffer holds a short window, and the hybrid MP4 format OBS added in version 30.2 protects the file if the app crashes. OBS describes that format as resilient against data loss like MKV while staying as widely compatible as regular MP4, which is exactly the property you want when a session can drop at any moment.
Who this tutorial is for
You should be comfortable installing desktop software and editing a text file. You do not need programming experience beyond running one Python script. The steps use Windows 11 as the reference, with notes where macOS and Linux differ. If you are on a Chromebook, the capture options are narrower, so read the pitfalls section before you start.
Free Cloud Gaming in November 2026: What You Can Actually Record
Free access shifted this autumn, and the changes affect how long you get to play and therefore how you plan clips. NVIDIA still lists three GeForce NOW plans (Free, Performance and a top tier), and it promoted day passes for the paid plans on October 8 and again on October 22. The company’s pages did not give us a confirmed session length or queue rule for the Free plan in today’s research, so check the limits shown inside your own account before you plan a long recording session. Our GeForce NOW free trial and day pass test walks through what the free queue looks like in practice.
Microsoft changed more. On October 21, 2026 the Xbox Insider program began testing Cloud Playtime, which lets people without Game Pass buy streaming time, and the same announcement said Insiders could test free cloud gaming with ads. TechPowerUp reported the introductory prepaid prices as $3.99 for 10 hours, $7.99 for 25 hours and $11.99 for 50 hours. Separately, Make Tech Easier reported monthly cloud limits of 5 hours for Game Pass Essential, 10 for Premium and 15 for the highest plan starting in November. Microsoft said in its September 3 announcement that the change would affect about 4% of subscribers.
Amazon Luna sits in a quieter spot. Amazon says Prime members get Luna Standard at no extra charge, with more than 80 games in the November lineup, and according to Amazon’s own announcement Luna reached Prime Video on Fire TV in Canada, France, Italy and Spain on October 19. Our walkthrough of the Amazon Luna free tier covers the account side. The table below summarizes what each route means for a clip workflow.
| Service | Free route (Nov. 9, 2026) | How it reaches your screen | Recording implication |
|---|---|---|---|
| GeForce NOW | Free plan beside Performance and a top tier, plus day passes | Desktop app, browser, handhelds, TVs | Capture the app window or browser tab. Limits vary, so log your own session length |
| Xbox Cloud Gaming | Ad-supported free access in Insider preview since Oct. 21 | Browser on PC and Mac, mobile, TV and VR apps | Browser capture is the main path. Ads can interrupt, so keep the buffer running |
| Xbox Cloud Gaming (paid packs) | Cloud Playtime in Insider test: $3.99, $7.99 and $11.99 packs | Same as above | Hours are metered, so short buffered clips save playtime |
| Amazon Luna | Luna Standard included with Prime, 80+ games | Browser, Fire TV, Prime Video integration | Browser capture on PC. Fire TV needs a hardware capture card |
One more current detail matters for quality. NVIDIA says its highest tier gets RTX 5080-class cloud performance, and on November 5 it highlighted DLSS 5 for Hogwarts Legacy. Free-plan streams do not get those perks, so do not expect the same sharpness in your free clips that you see in marketing footage. Judge your results against your own tier, which is what the comparison step later in this guide does.
Why Cloud Streams Record Differently From Local Games
When you record a local game, OBS sees clean frames straight from your GPU. With cloud gaming, OBS sees a decoded video stream that the service already squeezed through an encoder on its own server. That has three practical effects on your clips, and understanding them saves hours of fiddling with the wrong setting.
First, quality is capped upstream. If a free-plan stream shows soft textures or blocky shadows during fast motion, no OBS bitrate can restore them. Recording at a very high bitrate only stores the same blocks in a bigger file. This is why the settings in step 5 stop at 12000 Kbps and why we suggest judging each service at your own tier rather than against marketing footage from paid plans.
Second, the stream’s frame rate and resolution can change during a session. Services adapt to your connection, so a drop in available bandwidth can lower the picture quality in the middle of a clip. Keep OBS locked at 1080p60 and let the source vary inside it. If a clip looks softer in its second half, check your network at that moment before blaming the encoder. Most services show a stats overlay during play, and it is worth glancing at it when a clip looks off.
Third, the stream arrives with a small delay, and your recording inherits it. What you see on screen is already a fraction of a second behind the server, and OBS records what you see. That is fine for sharing highlights but matters if you plan to sync your voice commentary frame by frame. Record commentary on its own track, as step 6 does, and you can nudge it in an editor later.
Prerequisites and Versions
Gather the items below before you begin. Where we list “latest stable,” we could not confirm an exact number from a primary source today, and you should take whatever the download page offers rather than an older build from a mirror.
| Item | Version or requirement | Why you need it |
|---|---|---|
| OBS Studio | 33.0.1 (current stable since late October 2026) | Capture, replay buffer, hybrid MP4 output |
| FFmpeg | Latest stable build, with ffprobe | Trimming and loudness normalization in Clipvault |
| Python | Not listed | Runs the folder watcher (standard library only) |
| Operating system | Windows 11 (reference), macOS or Linux with notes | OBS runs on all three |
| Browser | Latest Chrome or Edge | Xbox Cloud Gaming and Luna in a browser tab |
| Free accounts | NVIDIA, Microsoft and Amazon (Prime for Luna) | One free route to record from |
| Disk space | At least 20 GB free on an SSD | Clips, temp files and processed copies |
| Network | Wired or 5 GHz Wi-Fi | Stable stream, so you record clean frames |
A heads-up for Mac users: OBS forum threads from late October and early November report black or blank capture output after the 33.0.1 update on some macOS setups, and a separate post warned that OBS 32.2.2 does not work with macOS 27.2. Treat those as user reports rather than confirmed bugs, but plan on testing your capture before you rely on it. Our OBS Studio setup guide covers general installation if you want a broader baseline first.
Steps 1 to 3: Check the Rules, Install the Tools, Build an OBS Profile
Step 1: Check what each service allows you to record
Before you capture anything, read the terms for the service you plan to use. Recording your own gameplay for personal clips is common practice, but publishing is a different matter, because publishers hold rights to the games and some titles restrict streaming or monetization. Open the terms page of each service, search for “record,” “capture” and “stream,” and write down the answer in a plain text note. Five minutes here prevents a strike later.
Also check whether the game itself is the problem. Some online shooters run anti-cheat that blocks capture hooks. Because cloud games run on the provider’s machine, your local OBS never touches the game process, which is why window capture of the stream works even for titles that block local recorders. That does not change the publisher’s rules about sharing footage, so keep your note handy.
Step 2: Install OBS Studio and FFmpeg
On Windows 11, the fastest route is the built-in package manager. Open Windows Terminal and run the commands below. The OBS package ID pulls the current stable installer, and the FFmpeg package from Gyan puts ffmpeg and ffprobe on your PATH.
winget install --id OBSProject.OBSStudio -e
winget install --id Gyan.FFmpeg -e
winget install --id Python.Python.3.12 -e
# Open a NEW terminal, then verify
ffmpeg -version | Select-Object -First 1
ffprobe -version | Select-Object -First 1
python --versionOpen a fresh terminal window after installing so the PATH update takes effect. On macOS use Homebrew (brew install --cask obs and brew install ffmpeg). On Ubuntu use your package manager or the official Flatpak. Then launch OBS and open Help, then Check for Updates, and confirm the version reads 33.0.1 or newer. A typical verification looks like this:
ffmpeg version (latest stable build) Copyright (c) the FFmpeg developers
ffprobe version (latest stable build) Copyright (c) the FFmpeg developers
Python 3.12.xIf you skipped an older release and installed from a random mirror, update through the in-app updater. The OBS forum has told users that anything older than 33.0.1 should update through Help and Check for Updates, so do not stay on a stale build just because it still launches. Our guide to OBS versus ShadowPlay and Xbox Game Bar explains why OBS is still the better pick here, since the other two cannot record a browser window as flexibly.
Step 3: Create a dedicated profile and scene collection
Use a separate profile so your cloud settings never disturb whatever you use OBS for elsewhere. In OBS, open the Profile menu, choose New, and name it CloudClips. Then open Scene Collection, choose New, and name it CloudClips too. Inside the collection, create three scenes: GFN, Xbox and Luna. One scene per service lets you keep a different capture source for each and switch with a click.
Name things consistently from the start. Clipvault labels each file with the service you pass on its command line (gfn, xbox or luna), so the three scene names double as a reminder of which flag to use. A scene called “Scene 4” tells you nothing at 2 a.m. when you wonder which service produced a clip.
Steps 4 to 6: Video, Output and Audio Settings
Step 4: Set the video canvas to match the stream
Open Settings, then Video. Set Base (Canvas) Resolution and Output (Scaled) Resolution to 1920×1080, and Common FPS Values to 60. Free tiers rarely stream above 1080p, so a larger canvas only wastes encoder time. If your service delivers 720p, OBS will upscale it inside a 1080p canvas, which is fine for sharing and avoids a mismatched frame size when you stitch clips from different services together later.
Pick Lanczos or Bicubic as the downscale filter if you ever record from a larger monitor. For a 1080p screen the filter does not matter, because no scaling happens. Keep your browser or app window at its native size, then check in the OBS preview that the capture fills the frame without black bars.
Step 5: Configure output for clips, not archives
Go to Settings, then Output, and switch Output Mode to Advanced. On the Recording tab, set Type to Standard, choose a folder you can find easily (for example D:\CloudClips\raw), set Recording Format to Hybrid MP4, and select your hardware encoder. NVIDIA GPU owners should pick the NVENC H.264 option, AMD owners the AMF option, and everyone else x264. Set Rate Control to CBR and Bitrate to 12000 Kbps for a clean 1080p60 clip. Because the service already compressed the picture, going far higher adds file size without adding detail.
| Goal | Encoder | Rate control | Bitrate | Format |
|---|---|---|---|---|
| Everyday clips for Discord | Hardware H.264 | CBR | 8000 Kbps | Hybrid MP4 |
| Sharp 1080p60 for social posts | Hardware H.264 | CBR | 12000 Kbps | Hybrid MP4 |
| Low-end PC without a GPU encoder | x264, preset veryfast | CBR | 8000 Kbps | Hybrid MP4 |
| Maximum safety against crashes | Hardware H.264 | CBR | 12000 Kbps | MKV, remux later |
The values in that table are our starting settings, not vendor specifications. They work well on a typical home setup and you can adjust them in step 12 once you see real results. Leave Keyframe Interval at 2 seconds so editors and platforms can seek cleanly.
Step 6: Split audio into separate tracks
Still in the Recording tab, tick Audio Track 1 and Audio Track 2. Then open Edit, Advanced Audio Properties. Assign game audio to Track 1 and your microphone to Track 2, and untick Track 2 for the game source. This split lets you lower or mute your voice later without touching the game mix, which is handy when you want to post a clip without commentary.
Add the audio sources when you build the scenes in the next step. If you use a headset, set the microphone to a noise suppression filter such as the built-in RNNoise option and add a limiter set near minus 1 dB so a sudden shout does not clip. Test by speaking and watching the meter. Peaks should sit in the yellow range, not touching red.
Steps 7 to 9: Capture Sources, the Replay Buffer and Your First Test Clips
Step 7: Add a capture source for each service
Each scene needs two sources: a picture and a sound. For the picture, use Window Capture. Click the plus under Sources, choose Window Capture, and name it after the service. Pick the window from the list while the stream is running, and set the capture method to Windows 10 (1903 and up) so OBS uses the modern graphics path. Untick Capture Cursor unless you want the pointer in the clip. For sound, add Application Audio Capture on Windows and pick the same window, which isolates the game from system sounds like notifications.
For Xbox Cloud Gaming and Luna, give the browser its own clean window. Launching Chrome or Edge in app mode removes tabs and the address bar, so the capture contains only the stream. Use these commands in PowerShell:
# Xbox Cloud Gaming in a borderless app window
Start-Process "chrome.exe" -ArgumentList "--app=
# Amazon Luna in its own window and profile
Start-Process "chrome.exe" -ArgumentList "--app=The separate --user-data-dir keeps each service signed in to its own browser profile, so cookies and extensions from your daily browsing never leak into a recording. For GeForce NOW, use the desktop app if you have it. Add a Window Capture source and select the GeForce NOW window by its title. The first time you do this, sign in and start a free session before you pick the window, because the stream window does not exist until a game launches.
Fix the black rectangle before it ruins a session
The most common failure is a black capture. Browsers use hardware acceleration to draw video, and in some GPU setups OBS cannot grab those frames through window capture. If you see black, try the fixes in this order. First, switch the capture method to Windows 10 (1903 and up) if it is not already. Second, change the OBS graphics adapter via Settings, Advanced, so OBS runs on the same GPU as the browser. Third, as a last resort, turn off hardware acceleration in the browser settings, restart it and check the preview again. Our guide to the OBS black-screen fix covers the multi-GPU case in more detail.
Step 8: Turn on the replay buffer and bind hotkeys
Go to Settings, Output, and find the Replay Buffer tab (in Advanced mode). Tick Enable Replay Buffer, set Maximum Replay Time to 45 seconds, and leave the memory limit at a value your PC can spare, such as 1024 MB. Then open Settings, Hotkeys. Bind Start Replay Buffer to F9 and Save Replay to F10. If your game or browser already uses those keys, choose a combination with Ctrl and Alt so nothing collides.
Click Start Replay Buffer in the Controls dock once, and confirm the button turns to a stop label. From that moment, OBS keeps a rolling window of the last 45 seconds. Press F10 after something good happens and OBS writes a file to your recording folder within a second or two. The file will contain the 45 seconds that came before the keypress, not what follows, so react quickly and do not wait for the replay.
Pick the length with the game in mind. Fast competitive rounds fit inside 30 seconds. Story moments and boss fights can need 60. A longer window uses more memory, so scale it to the clips you actually share and nothing more.
Step 9: Record one test clip on each free route
Now prove the setup. Start a free session on one service, pick a game you know well, and play for two minutes. Press F10 twice, once during calm play and once during fast action. Stop the session, open your raw folder and play both files. Check three things: the picture is smooth, the audio is in sync, and your microphone is on its own track. In VLC you can switch audio tracks from the Audio menu to verify the split.
Repeat on the second and third service. If one route is gated behind a queue, use the waiting time productively and check your audio meters. If Xbox shows an ad break in the free preview, notice that OBS still captures it, and decide whether you want to trim those seconds later. Clipvault will help with that in a few steps. If a service refuses to connect at all, our fixes for a GeForce NOW connection error and for Xbox Cloud Gaming not working cover the usual causes.
A healthy OBS log line after a save looks like the example below. The exact wording can differ by build, but you should see a saved path and no encoder warnings:
info: Output 'Replay Buffer': Saving replay
info: [ffmpeg muxer: 'adv_replay_file_output'] Writing file 'D:/CloudClips/raw/Replay 2026-11-09 14-22-07.mp4'...
info: Output 'Replay Buffer': Replay savedSteps 10 to 12: Build Clipvault, Run It and Compare the Services
Step 10: Write the Clipvault watcher
Clipvault is one Python file that uses only the standard library plus the FFmpeg tools you installed. It watches your raw folder, waits until OBS finishes writing a file, then produces a game-only clip with normalized loudness, a mixed clip with your voice if a second audio track exists, a JPEG thumbnail, and a line in a log. Save the code below as clipvault.py in a folder such as D:\CloudClips.
#!/usr/bin/env python3
"""Clipvault: post-process OBS replay-buffer clips from cloud gaming sessions."""
import argparse
import json
import shutil
import subprocess
import time
from datetime import datetime
from pathlib import Path
EXTS = {".mp4", ".mkv"}
def run(cmd):
return subprocess.run(cmd, capture_output=True, text=True, check=True).stdout
def probe(path):
out = run(["ffprobe", "-v", "error", "-print_format", "json",
"-show_format", "-show_streams", str(path)])
data = json.loads(out)
audio = [s for s in data["streams"] if s["codec_type"] == "audio"]
return float(data["format"]["duration"]), len(audio)
def is_stable(path, wait=2.0):
first = path.stat().st_size
time.sleep(wait)
size = path.stat().st_size
return size > 0 and size == first
def slug(text):
return "".join(c.lower() if c.isalnum() else "-" for c in text).strip("-")
def process(src, args):
duration, n_audio = probe(src)
start = max(0.0, duration - args.keep) if args.keep else 0.0
stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
base = f"{stamp}_{args.service}_{slug(args.game)}"
out_dir = Path(args.out)
out_dir.mkdir(parents=True, exist_ok=True)
loud = f"loudnorm=I={args.lufs}:TP=-1.5:LRA=11"
head = ["ffmpeg", "-y", "-v", "error", "-ss", f"{start:.2f}", "-i", str(src)]
clean = out_dir / f"{base}_clean.mp4"
run(head + ["-map", "0:v:0", "-map", "0:a:0", "-c:v", "copy",
"-af", loud, "-c:a", "aac", "-b:a", "192k",
"-movflags", "+faststart", str(clean)])
full = None
if n_audio >= 2:
full = out_dir / f"{base}_voice.mp4"
run(head + ["-filter_complex",
f"[0:a:0][0:a:1]amix=inputs=2:duration=longest,{loud}[a]",
"-map", "0:v:0", "-map", "[a]", "-c:v", "copy",
"-c:a", "aac", "-b:a", "192k",
"-movflags", "+faststart", str(full)])
clip_len = duration - start
thumb = out_dir / f"{base}.jpg"
run(["ffmpeg", "-y", "-v", "error", "-ss", f"{clip_len / 2:.2f}",
"-i", str(clean), "-frames:v", "1", "-q:v", "3", str(thumb)])
entry = {
"time": datetime.now().isoformat(timespec="seconds"),
"service": args.service,
"game": args.game,
"source": src.name,
"seconds": round(clip_len, 1),
"audio_tracks": n_audio,
"clean_mb": round(clean.stat().st_size / 1_048_576, 1),
"voice_file": full.name if full else None,
}
with open(out_dir / "clipvault-log.jsonl", "a", encoding="utf-8") as fh:
fh.write(json.dumps(entry) + "\n")
print(f"OK {src.name} -> {clean.name} ({entry['seconds']}s, {entry['clean_mb']} MB)")
def main():
p = argparse.ArgumentParser(description="Process OBS clips from cloud gaming.")
p.add_argument("--watch", required=True, help="OBS recording folder")
p.add_argument("--out", required=True, help="folder for finished clips")
p.add_argument("--service", required=True, choices=["gfn", "xbox", "luna"])
p.add_argument("--game", required=True)
p.add_argument("--keep", type=float, default=0, help="keep only the last N seconds")
p.add_argument("--lufs", type=float, default=-16)
p.add_argument("--interval", type=float, default=3)
args = p.parse_args()
watch = Path(args.watch)
done, failed = watch / "done", watch / "failed"
done.mkdir(exist_ok=True)
failed.mkdir(exist_ok=True)
print(f"Watching {watch} for {args.service} / {args.game}. Ctrl+C to stop.")
try:
while True:
for f in sorted(watch.iterdir()):
if f.is_file() and f.suffix.lower() in EXTS and is_stable(f):
try:
process(f, args)
shutil.move(str(f), done / f.name)
except subprocess.CalledProcessError as err:
print("FAIL", f.name, (err.stderr or "")[-200:])
shutil.move(str(f), failed / f.name)
time.sleep(args.interval)
except KeyboardInterrupt:
print("Stopped.")
if __name__ == "__main__":
main()Three design choices deserve a note. The script copies the video stream instead of re-encoding it, so processing a 45-second clip takes a couple of seconds and adds no quality loss. Because it copies video, a trim with --keep snaps to the nearest keyframe, which is why we set a 2-second keyframe interval in step 5. And failed files move to a failed folder, so one bad clip never traps the loop in an endless retry.
Step 11: Run it and check the output
Open a terminal in the project folder and start the watcher for the service you are about to play. Run one watcher per session and restart it with different flags when you switch services.
python clipvault.py --watch D:\CloudClips\raw --out D:\CloudClips\ready --service gfn --game "Sample Game" --keep 30Start your free session, play, and press F10 when something good happens. After a few seconds you should see output like this in the terminal:
Watching D:\CloudClips\raw for gfn / Sample Game. Ctrl+C to stop.
OK Replay 2026-11-09 14-22-07.mp4 -> 20261109-142211_gfn_sample-game_clean.mp4 (30.0s, 46.1 MB)
OK Replay 2026-11-09 14-31-48.mp4 -> 20261109-143152_gfn_sample-game_clean.mp4 (30.0s, 44.8 MB)Those file sizes are what a 12000 Kbps CBR clip of 30 seconds lands near, roughly 45 MB. Verify one result with ffprobe to confirm the loudness pass and both tracks worked:
ffprobe -v error -show_entries stream=codec_type,codec_name,channels -of csv=p=0 D:\CloudClips\ready\20261109-142211_gfn_sample-game_voice.mp4
h264,video
aac,audio,2Step 12: Compare services with your own data
After a week of play, the log file becomes a record of how the three free routes behave on your connection. Add the short report script below as clipvault_report.py and run it against the log. It groups clips by service and prints counts, average length and average size, so you can see how often each route actually produced a clip worth keeping under identical OBS settings.
import json
import sys
from collections import defaultdict
from pathlib import Path
log = Path(sys.argv[1])
rows = defaultdict(list)
for line in log.read_text(encoding="utf-8").splitlines():
entry = json.loads(line)
rows[entry["service"]].append(entry)
print(f"{'service':8} {'clips':>5} {'avg s':>7} {'avg MB':>8} {'MB/s':>6}")
for service, items in sorted(rows.items()):
secs = sum(i["seconds"] for i in items)
mb = sum(i["clean_mb"] for i in items)
print(f"{service:8} {len(items):5d} {secs / len(items):7.1f} "
f"{mb / len(items):8.1f} {mb / secs:6.2f}")A sample run on three days of clips might print this. These numbers are illustrative of the format, not benchmark results, and your own data will differ:
service clips avg s avg MB MB/s
gfn 9 30.0 45.3 1.51
luna 4 30.0 41.9 1.40
xbox 6 30.0 43.7 1.46Because OBS records at constant bitrate, file size alone tells you little about stream quality. Pair the log with a visual check. Pause a clip on a detailed scene, compare edge sharpness and watch for blocky shadows or smearing in fast pans. Our Amazon Luna versus GeForce NOW versus Xbox Cloud comparison covers the plan-level differences, and the table below lists the measurements worth tracking for your own comparison.
| Measurement | How to capture it | What it tells you |
|---|---|---|
| Session length | Note start and end time in your log | How much free play you really get per sitting |
| Queue wait | Stopwatch from pressing play to first frame | Whether peak hours make clips impractical |
| Dropped frames | OBS Stats dock (Missed, Skipped, Dropped) | Whether the problem is your PC or the stream |
| Visual sharpness | Pause on a detailed frame and compare | Real stream quality at your tier |
| Audio sync | Clap or fire a weapon, scrub frame by frame | Whether tracks drift over a long session |
| Ad interruptions | Count per session on ad-supported routes | How many clips an ad break costs you |
Quick Reference: Settings and Hotkeys at a Glance
Print this table or pin it next to your monitor. It repeats every setting the earlier steps changed, so you can rebuild the profile on a new PC in a few minutes.
| Where in OBS | Setting | Value |
|---|---|---|
| Settings, Video | Base and output resolution | 1920×1080 |
| Settings, Video | Common FPS | 60 |
| Settings, Output | Output mode | Advanced |
| Output, Recording | Format and encoder | Hybrid MP4, hardware H.264 |
| Output, Recording | Rate control and bitrate | CBR, 12000 Kbps |
| Output, Recording | Keyframe interval | 2 seconds |
| Output, Recording | Audio tracks | 1 (game) and 2 (microphone) |
| Output, Replay Buffer | Maximum replay time | 45 seconds |
| Hotkeys | Start Replay Buffer and Save Replay | F9 and F10 (or Ctrl+Alt variants) |
| Source | Window Capture method | Windows 10 (1903 and up) |
The Finished Project: Folder Layout and a Daily Routine
At this point you have every piece of the working project. The folder layout below is what your drive should look like after a few sessions. Keeping raw files, finished clips and scripts in separate places makes backups and cleanup trivial.
D:\CloudClips\
clipvault.py
clipvault_report.py
raw\ (OBS writes replay files here)
done\ (processed originals)
failed\ (files FFmpeg could not read)
ready\ (finished clips, thumbnails, clipvault-log.jsonl)A typical session then follows six moves. Launch the service’s window and sign in. Open OBS, select the matching scene and click Start Replay Buffer. Start Clipvault with the right service and game flags. Play, pressing F10 after good moments. Stop the watcher with Ctrl+C when you finish. Finally, open the ready folder, glance at each thumbnail, delete the weak clips and upload the keepers.
Keep the routine short enough that you actually follow it. The whole point of this pipeline is that a free session, which can end without warning, still leaves you with something you can keep. If you only remember one habit, make it starting the buffer before you press play.
Common Pitfalls That Ruin Free Cloud Gaming Clips
Most failed clips trace back to a handful of avoidable mistakes. Read this list once before your first real session.
- Recording the whole session. A two-hour capture of a free session produces a huge file and a tedious edit. Use the replay buffer and save moments after they happen.
- Capturing the wrong audio. Desktop audio capture also records chat pings, email alerts and music from other apps. Use Application Audio Capture on the stream window so only the game comes through.
- Minimizing the stream window. Window Capture often freezes on a minimized window, and browsers throttle background tabs. Keep the stream visible, or move it to a second monitor.
- Leaving personal details on screen. Account names, email addresses and notification pop-ups can land in a clip you post publicly. Turn on Do Not Disturb and check the first frame of every upload.
- Forgetting to start the buffer. Saving a replay with the buffer stopped does nothing. Add Start Replay Buffer to your pre-game checklist, or enable the option that starts it with OBS if your build offers one.
- Running a software encoder on a weak PC. Decoding the stream and encoding with x264 at the same time can make both choke. Use a hardware encoder when you have one, or drop to 8000 Kbps with a faster preset.
- Ignoring publisher rules. A clip that plays fine on your drive can still draw a copyright claim, especially when licensed music is in the game. Check step 1 notes before posting.
The pattern behind these errors is the same: cloud gaming moves the game off your machine but leaves the recording job on it, so your PC still has real work to do. Plan for that load and your clips will look like the stream you saw. If you want a refresher on tuning the network side first, our free cloud gaming data use tracker shows how much bandwidth a session pulls.
Troubleshooting: 10 Problems and Fixes
- The capture is a black rectangle. Switch Window Capture to the Windows 10 (1903 and up) method, run OBS and the browser on the same GPU, then disable browser hardware acceleration as a last resort.
- There is no game sound in the clip. Confirm you added Application Audio Capture and picked the live window. If the window was reopened, the source loses its target, so reselect it. Also check that Track 1 is ticked in Recording.
- Audio drifts out of sync over time. Set the audio sync offset in Advanced Audio Properties for the mic, and keep the sample rate at 48 kHz on both OBS and Windows. Clap on camera at the start of a session to measure drift.
- Pressing the save hotkey does nothing. The buffer is probably stopped, or another app swallowed the key. Start the buffer, rebind Save Replay to a Ctrl+Alt combination and check the Hotkeys list for duplicates.
- Clips are shorter than 45 seconds. You saved before the buffer filled, or the memory limit is too low for your bitrate. Raise the maximum memory in the Replay Buffer tab.
- The recording stutters or drops frames. Open View, Stats and watch Skipped Frames Due to Encoding Lag. If it climbs, lower bitrate, switch to a hardware encoder or close other GPU-heavy apps.
- On macOS the capture is blank after updating. Forum users have reported blank or black capture after 33.0.1 on some Macs. Re-grant Screen Recording permission in System Settings, restart OBS, and if it persists check the OBS forum for a newer build.
- Clipvault says ffmpeg is not recognized. The PATH change needs a new terminal. Close the window, open a fresh one and run
ffmpeg -versionbefore starting the script again. - Clipvault moves every file to the failed folder. Run the same ffmpeg command by hand to see the real error. A common cause is a clip with no audio stream, so confirm Track 1 recorded.
- An editor will not open the hybrid MP4. Some older editors dislike the format. In OBS choose File, Remux Recordings and convert the file to a regular MP4, or set the recording format to MKV and remux after each session.
When something fails that is not on this list, narrow it down with a simple rule: record the same moment with the service’s own capture option if one exists, or with Windows Game Bar for ten seconds. If those work and OBS does not, the problem is your OBS setup. If none of them work, the stream or the browser is the culprit.
Advanced Tips for Cleaner, Faster Clips
Once the basics run, a few upgrades pay off quickly. First, give each service its own OBS profile. GeForce NOW on a wired connection can sustain a higher bitrate than Luna on Wi-Fi, and separate profiles let you store the right numbers for each. Second, automate cleanup so your SSD does not fill. The PowerShell line below deletes processed raw files older than 14 days:
Get-ChildItem "D:\CloudClips\raw\done" -File |
Where-Object { $_.LastWriteTime -lt (Get-Date).AddDays(-14) } |
Remove-Item -WhatIfThe -WhatIf switch makes the command a dry run. Review what it would delete, then remove the switch to make it live. Schedule it weekly with Task Scheduler.
Third, plan clips around catalog drops. Mixed reported that GeForce NOW’s November lineup includes World of Warcraft: Forever, and launch weeks bring the most interesting footage. Whether a given game is playable on the Free plan depends on the title, so check your library before you promise anyone a clip.
Fourth, for Luna on a Fire TV, OBS cannot see the screen because the stream plays on the TV hardware. A capture card between the TV stick and your PC solves that. Fifth, add a Stream Deck or a spare controller button for Save Replay so you never take your hands off the game. Finally, treat the log as a quality record. If one service shows more dropped frames week after week, move your best sessions to the route that behaves best on your line. Browse more walkthroughs in our gaming section for setup guides on each service.
Frequently Asked Questions About Recording Free Cloud Gaming
Can I record GeForce NOW Free, Xbox Cloud Gaming and Luna with OBS?
Yes, on a PC or Mac. All three stream into an app or browser window that OBS can capture. Fire TV and other TV-only routes need a hardware capture card because the stream never passes through your computer.
Does recording use up my free cloud gaming time?
Recording runs on your own PC, so it should not add anything beyond the time you already spend streaming. On metered routes such as the Xbox Cloud Playtime test, the clock follows the session, which is why short buffered clips are a better fit than long captures.
Will OBS add input lag to my cloud game?
A hardware encoder adds very little load, so most players will not notice a difference. A software encoder on a weak CPU can cause stutter that feels like lag. Watch the Stats dock for skipped frames, and lower the bitrate if the numbers climb.
What replay buffer length should I choose?
Start with 45 seconds. Fast competitive rounds fit in 30 and story moments may need 60. A longer buffer uses more memory, so only extend it if you keep missing the start of the action.
Which bitrate is best for free-tier streams?
Use 12000 Kbps CBR for sharp 1080p60 clips and 8000 Kbps for Discord-sized shares. Free streams arrive compressed already, so going far above 12000 Kbps adds file size without adding visible detail.
Is it okay to post cloud gaming clips on YouTube or social media?
That depends on the game publisher and the service terms, not on OBS. Read the terms for the service and the game’s content policy, avoid licensed music, and keep personal details out of the frame.
Why does my Mac show a blank capture after the OBS update?
Forum users reported blank capture on some Macs after OBS 33.0.1 in late October and early November. Re-grant Screen Recording permission, restart OBS and watch the OBS forum for a fix. We have not confirmed a cause.
