How to send a screen recording to Slack, Discord, and GitHub in 2026 (the per-platform quirks)

Once you've recorded a screen capture, you have to send it somewhere. Each platform — Slack, Discord, GitHub, plus the dozen others — handles the upload differently, previews differently, caps differently. The result is that the same MP4 that plays beautifully in a Slack DM might bounce off Jira's attachment limit, render as a download link in Discord's free tier, and refuse to embed in a GitHub README. This post is the per-platform quirks guide for 2026: where to drag the file, what the cap is, what previews inline, and the workaround for each platform where the answer is "you can't, do this other thing".

TL;DR — the lookup table

The patterns to internalize: Discord's 10 MB free cap is the most restrictive of the chat apps; GitHub's PR/issue rendering and README rendering are completely different (PRs render <video>, READMEs render <img> only); Jira's 10 MB default cap is the most common workflow blocker. The rest is per-platform detail.

Slack: the easy case

Slack handles video attachments well in 2026. The workflow:

1. Open the channel or DM.
2. Drag the MP4 from your Finder/File Explorer onto the Slack window.
3. Slack uploads it, generates a thumbnail, and inserts an inline <video> preview into the message.
4. (Optional) Add a caption explaining what's in the video.
5. Hit Enter to send.

The recipient sees the video inline with a play button. Clicking plays it inline; clicking the expand icon opens it in Slack's media viewer.

Slack-specific quirks

• Recording uploads are tied to your workspace storage. Free Slack workspaces have a 1 GB total file storage cap; paid workspaces have 5 GB or 1 TB depending on tier. For a team that ships 5-10 videos a day, the free cap fills fast.
• Slack converts everything to MP4 for playback. If you upload a WebM, Slack re-encodes it server-side and serves an MP4 to viewers. The re-encoding is generally quality-preserving but adds 10-30 seconds of processing latency.
• Search doesn't index video content. A Slack search won't find videos by transcript or visual content. Pair the video with descriptive text in the message body for grep-ability.
• Slack's /zoom and /loom commands are integrations that can record directly into a thread. The output goes through the respective platform's pipeline — useful for share-link analytics, not for local-file workflows.
• Inline preview works on mobile Slack. iOS and Android apps both render inline <video> for MP4.

File size targets for Slack

The 25 MB number isn't a hard cap; it's the threshold above which Slack's inline preview gets slower (multi-second buffer before play). Keep individual recordings under 25 MB for the snappy-preview experience.

Discord: the cap problem

Discord's free tier is the most restrictive of the major chat apps for video — 10 MB per file, which a 1080p 60-second MP4 will exceed. The workflow:

1. Open the channel or DM.
2. Drag the MP4 onto the Discord window.
3. If the file is over 10 MB: Discord rejects the upload with an error. You'll need to either compress the file or use Discord Nitro.
4. If under 10 MB: Discord uploads and inserts an inline preview.

Discord-specific quirks

• The 10 MB cap is enforced per-file. Even on free Discord with Nitro-enabled friends in the same channel, the cap is set by the uploader's tier — not the channel's tier.
• Nitro Basic ($2.99/mo) raises the cap to 50 MB. Nitro Pro ($9.99/mo) raises it to 500 MB.
• Discord re-encodes uploads to MP4 for cross-device compatibility. WebM works but gets converted.
• Inline preview supports H.264 and VP9. No AV1 yet in the playback path.
• Embeds for video URLs work. Pasting a YouTube URL or a direct MP4 URL produces an inline preview without using upload quota.

How to get under 10 MB

The four-knob compression workflow (see the compression post) applies:

1. Trim. A 60-second clip at Medium tier is ~37 MB; trim to 15 seconds and you're at ~9 MB.
2. Drop tier. ClearRec's Low tier (720p / 30 fps / 2.5 Mbps) is 19 MB / minute — fits ~30 seconds under the cap.
3. Drop frame rate. Recording at 30 fps instead of 60 fps halves the file size.
4. Drop resolution. 720p instead of 1080p reduces by ~55%.

For a typical "send a quick screen capture to a Discord channel" workflow, the practical answer is ClearRec at Low tier, trim to under 30 seconds. That stays under the free Discord cap reliably.

Alternative: paste a YouTube or self-hosted URL

If the recording is genuinely longer than ~30 seconds and you can't pay for Nitro, the workaround is to upload the video to YouTube (unlisted) or to a personal CDN, and paste the URL in Discord. Discord auto-embeds the video; viewers play it inline through the embed.

GitHub: PR vs README is the whole story

GitHub's video handling has a critical asymmetry that costs a lot of developer time: PR/issue comments render <video> for MP4 uploads, but README.md files do not.

GitHub PR / issue comments

The workflow:

1. Open the PR or issue.
2. Drag the MP4 into the comment box.
3. GitHub uploads the file and inserts a Markdown link with a <video> tag: <video src="...">.
4. Submit the comment. The video plays inline in the rendered comment.

Inline playback works. The default cap is 10 MB for video files (uploads of larger video files are rejected with an error).

GitHub README.md (and any rendered Markdown file)

GitHub's Markdown renderer for .md files sanitizes <video> tags. The rendered README doesn't show a video player even if you embed one.

What does render in README files: GIF (as <img>), and static images. Animated GIFs autoplay in <img> tags.

So for a README "hero video", the format is not MP4 — it's GIF. The workflow:

1. Capture the recording in ClearRec (typically at Medium tier).
2. Open the editor, switch the export format to GIF.
3. Drop the GIF length to under 15 seconds and the resolution to 720p.
4. Export. The output is typically 2-10 MB.
5. Add the GIF to your repo (commonly in a /assets/ or /docs/ folder).
6. Reference it in the README: ![Demo](./assets/demo.gif).

For the GIF pipeline specifics: How to convert a screen recording to GIF in Chrome.

GitHub-specific quirks

• Video uploads in PRs and issues are hosted on GitHub's user-uploads CDN. The URLs look like https://github.com/<user>/<repo>/assets/<id>/<uuid>. They're stable for the life of the repo.
• Drag-and-drop only works in the web interface. Mobile GitHub apps don't support video upload yet.
• GitHub's <video> tag has no muted-autoplay like Twitter/Slack. The viewer clicks Play to start.
• GitHub Action runners can attach videos to issues programmatically via the API. Useful for CI-recorded test failures.
• Private repo videos require auth to view. A link to a video in a private repo won't work for someone outside the repo's collaborators.

Email: the universal but limited fallback

Email is the lowest-common-denominator. Every email client handles MP4 attachments, but inline preview is rare and attachment caps are tight.

Cap reality

For most workflows, target under 10 MB for email attachments. ClearRec at Low tier with aggressive trimming hits this comfortably.

What email previews

Most modern email clients (Gmail web, Outlook web, Apple Mail) show an attachment indicator but require the recipient to click to play. They don't render inline. Some webmail clients (Gmail in particular) have started to inline-preview MP4 in recent UI updates, but support is inconsistent.

For email workflows where the video is the message, the safe option is:

1. Keep the file under 10 MB.
2. Pair the email body with a one-line description of what the video shows.
3. Don't rely on inline preview — assume the recipient downloads and plays the file.

Gmail's "send via Drive" path

For files over 25 MB, Gmail automatically prompts to send a Google Drive link instead. The video uploads to Drive, the recipient clicks the link to view. Works fine; introduces a Drive round-trip and shares the file's metadata with Google.

Microsoft Teams: enterprise-friendly

Teams accepts video uploads up to ~250 MB and previews them inline.

Workflow

1. Open the channel or chat.
2. Drag the MP4 onto the conversation.
3. Teams uploads and inserts an inline preview.
4. The recipient clicks Play to watch.

Teams-specific quirks

• The video lives in SharePoint (associated with the team's site). Permissions follow the team's access controls.
• Compliance hold and retention policies apply. If your org has Microsoft Purview retention, the video falls under the same policy as other files.
• The 250 MB cap is the per-upload limit; there's no per-conversation limit beyond your tenant's overall storage.
• MP4 with H.264 is the format that previews reliably. WebM works but sometimes shows a download link instead of a preview.

For most enterprise Teams workflows, MP4 at Medium tier (37 MB / minute) is fine for clips up to ~6 minutes.

Twitter / X and LinkedIn: the re-encoded social path

Social platforms have their own video pipelines. The pattern:

1. Upload your MP4.
2. The platform re-encodes it for delivery (lower bitrate, sometimes lower resolution).
3. The video plays inline in the feed.

Twitter / X

• Cap (free): 512 MB / 2 minutes 20 seconds.
• Cap (Premium / X Plus): 8 GB / 4 hours.
• Accepted formats: MP4 (H.264) and MOV. WebM not supported.
• Re-encoding: aggressive — typically downscaled to 720p or 1080p, bitrate to ~3 Mbps.

Upload at the highest quality you can afford to lose; the platform's re-encoder degrades from your source.

LinkedIn

• Cap: 200 MB / 10 minutes for native video uploads.
• Accepted formats: MP4 (H.264), MOV, AVI, WebM (sometimes), MKV.
• Re-encoding: less aggressive than Twitter, but still re-encodes.

For both, the right strategy: shoot at ClearRec's High or Ultra tier (1080p / 60 fps / 10-20 Mbps) so the platform's re-encoder has high-quality source to work with. Don't pre-compress aggressively; the platform will compress regardless.

Notion: the format-restrictive case

Notion's video story varies wildly by plan:

• Free plan: 5 MB per upload. Genuinely tiny — barely enough for a 10-second 720p clip.
• Paid plans (Plus, Business, Enterprise): 5 GB per upload. Generous.

The drag-and-drop workflow:

1. On a Notion page, drag the MP4 onto the page (or type /video and upload).
2. Notion uploads and embeds the video inline.
3. Click to play.

For the free tier specifically, the 5 MB cap forces a different workflow for anything longer than ~10 seconds: upload to YouTube (unlisted) and paste the URL via /video. The recording lives on YouTube; the Notion page just shows a YouTube embed.

Full Notion-specific guidance: Screen recording for Notion, Linear, and Jira tickets.

The naming convention that helps everyone

A small habit that pays off across every platform: name your MP4 files clearly before sharing.

A file named screen-recording-2026-05-26-14-32-04.mp4 reads as "automated screen capture, contents unknown". A file named auth-login-redirect-bug-rc-12.5.mp4 reads as "this is a specific thing you can act on".

The convention that scales:

<area>-<symptom-or-content>-<build-or-context>.mp4

Examples:

• payment-stripe-webhook-500-rc-12.5.mp4
• mobile-nav-overflow-design-review-v2.mp4
• homepage-hero-demo-launch-2026-05.mp4

The 5 seconds of renaming saves the recipient the 30 seconds of "wait, which file is which" later.

Frequently asked questions

Q: What's the best way to send a screen recording to Slack? Drag the MP4 onto the Slack window. Slack uploads it and inserts an inline preview. For files under 25 MB, the preview is fast; for larger files, expect a couple seconds of buffering.

Q: Why won't Discord let me upload my screen recording? Discord's free tier caps file uploads at 10 MB. Your recording probably exceeds that. Either compress the file (see compression guide), use Discord Nitro to raise the cap, or upload the file to a host (YouTube unlisted, Drive) and paste the URL.

Q: Can I add a video to a GitHub README.md? Not as an MP4 with inline playback — GitHub's Markdown renderer for README files sanitizes <video> tags. The format that works: GIF, embedded as ![Demo](./demo.gif). For MP4 with playback, use a PR or issue comment (which does render <video>).

Q: What's the max video size for a GitHub PR comment? 10 MB for video files. Larger uploads are rejected with an error.

Q: How do I send a 60-second screen recording via email? ClearRec at Low tier (720p / 30 fps / 2.5 Mbps) produces ~19 MB for 60 seconds — under Gmail's 25 MB cap. For longer recordings, either drop further (resolution or frame rate) or use Gmail's automatic Drive-link path for files over 25 MB.

Q: Will my screen recording look the same after Twitter / LinkedIn re-encode it? Mostly. The platforms re-encode at lower bitrates, which can soften fine UI text. Upload at the highest quality your patience allows; the re-encoder degrades from there.

Q: What format should I export for social media? MP4 with H.264 + AAC. Both Twitter and LinkedIn require this. WebM uploads sometimes work but are inconsistent — MP4 is the safe default.

Q: Can I upload a WebM to Slack? Yes. Slack re-encodes WebM uploads to MP4 server-side and serves the MP4 to viewers. Works fine; introduces ~10-30 seconds of processing latency before the inline preview is available.

Q: How do I send a long screen recording to a team via Microsoft Teams? Drag the MP4 onto the conversation. Teams accepts up to ~250 MB and renders inline. The video uploads to the team's SharePoint document library; permissions follow the team's access controls.

Q: What's the best platform for sharing a screen recording with a remote team? For most workflows: the team's standing chat (Slack, Discord, Teams) for short clips and the team's ticket tracker (Linear, Jira) for bug-related videos. For longer recordings (>5 minutes), shared Drive folders or unlisted YouTube videos with the link in chat.

Q: Do I need to compress my screen recording before sharing? Usually no, if you record at the right tier upfront. ClearRec's Medium tier (1080p / 30 fps / 5 Mbps) produces ~37 MB per minute, which fits comfortably under most platform caps. Compress only when you specifically need to slip under a tight cap (Discord free, Jira Cloud default, email under 10 MB).

Q: Can I send a screen recording without uploading it anywhere? Yes — attach the MP4 file directly to an email, drop it onto a USB drive, share it over local network (AirDrop, Nearby Share, SMB). The file is self-contained; "uploading" is one option, not a requirement.

Q: Will the recipient need to install anything to play my MP4? No. H.264 + AAC inside MP4 is the default codec stack on every browser, every modern phone, and every desktop OS. If they can watch YouTube, they can play your MP4.

Q: How do I share a screen recording on Mastodon / BlueSky / Threads? All three accept MP4 uploads with platform-specific caps (Mastodon: per-instance, typically 40-100 MB; BlueSky: 50 MB / 60 sec; Threads: similar to Instagram, 250 MB / 5 min). The workflow is upload → inline preview → re-encoded for delivery. MP4 with H.264 is the format that works everywhere.

The summary

The per-platform sharing landscape in 2026:

• Slack, Linear, Teams: drag-and-drop MP4 works cleanly; previews inline; generous caps.
• Discord, Jira Cloud, Notion (free): tight caps (10 MB or less); compress or use Low tier; sometimes the workaround is external hosting.
• GitHub: PRs/issues render MP4 inline (10 MB cap); READMEs require GIF instead.
• Email: drag-attach works; rarely inline-previews; 10-25 MB cap depending on provider.
• Twitter, LinkedIn: upload-only; platforms re-encode aggressively; ship at high quality.

The single most reliable cross-platform format: MP4 (H.264 + AAC) at ClearRec's Medium tier (1080p / 30 fps / 5 Mbps). Stays under most caps for clips up to 30-60 seconds; previews inline on every platform that supports inline preview; re-encodes cleanly on platforms that re-encode.

If you want to skip the per-platform compression dance, install ClearRec from the Chrome Web Store — pick Medium tier as the default, MP4 export, trim to under 30 seconds. The resulting file is "the right size" for essentially every destination.

See also

• How to compress a screen recording without losing quality — for fitting Discord's 10 MB cap or Jira Cloud's 10 MB cap.
• Screen recording for Notion, Linear, and Jira tickets — per-tracker workflow detail.
• MP4 vs WebM vs GIF: which screen recording format should you use? — the format decision tree.
• How to convert a screen recording to GIF in Chrome — for the GitHub README case where MP4 doesn't render.
• Best screen recording quality settings in 2026 — the destination-driven tier picker.
• Async standups in 2026 — for the chat-channel-sharing workflow.
• Screen recording for bug reports: a developer's complete guide — the GitHub PR sharing workflow.
• Free vs paid screen recorders — when free actually wins — why ClearRec's free tier covers all the workflows above.