diff --git a/lang/en/validation.php b/lang/en/validation.php
index 81ba24b56d8..7da06f8f783 100644
--- a/lang/en/validation.php
+++ b/lang/en/validation.php
@@ -218,6 +218,7 @@
     'invalid_two_factor_code' => 'The provided two factor authentication code was invalid.',
     'invalid_two_factor_recovery_code' => 'The provided two factor recovery code was invalid.',
     'bard_container_required_by_button' => 'This field is required by a toolbar button.',
+    'video_fieldtype_cloudflare_id' => 'Must contain only letters and numbers.',
 
     /*
     |--------------------------------------------------------------------------
diff --git a/resources/js/components/fieldtypes/VideoFieldtype.vue b/resources/js/components/fieldtypes/VideoFieldtype.vue
index 5282a8b1a3a..941dfee44fa 100644
--- a/resources/js/components/fieldtypes/VideoFieldtype.vue
+++ b/resources/js/components/fieldtypes/VideoFieldtype.vue
@@ -1,6 +1,27 @@
 <template>
     <div class="flex flex-col space-y-3 p-1.5 bg-gray-100 border border-gray-300 dark:bg-gray-900 dark:border-gray-700 rounded-xl">
-        <ui-input-group>
+        <ui-combobox
+            :model-value="isCloudflare ? 'cloudflare' : 'url'"
+            :options="meta.providers"
+            option-label="label"
+            option-value="value"
+            :read-only="isReadOnly"
+            :aria-label="__('Video Provider')"
+            @update:model-value="changeMode"
+        />
+        <ui-input-group v-if="isCloudflare">
+            <ui-input-group-prepend :text="__('ID')" />
+            <ui-input
+                :model-value="videoId"
+                :isReadOnly="isReadOnly"
+                :aria-label="__('Video ID')"
+                @update:model-value="updateCloudflareId"
+                @focus="$emit('focus')"
+                @blur="$emit('blur')"
+                input-class="border-s-0"
+            />
+        </ui-input-group>
+        <ui-input-group v-else>
             <ui-input-group-prepend :text="__('URL')" />
             <ui-input
                 :model-value="value"
@@ -13,7 +34,7 @@
                 input-class="border-s-0"
             />
         </ui-input-group>
-        <ui-description v-if="isInvalid" class="text-red-600">{{ __('statamic::validation.url') }}</ui-description>
+        <ui-description v-if="isInvalid" class="text-red-600">{{ invalidMessage }}</ui-description>
         <iframe
             v-if="shouldShowPreview"
             ref="iframe"
@@ -29,6 +50,10 @@
 <script>
 import Fieldtype from './Fieldtype.vue';
 
+const CLOUDFLARE = 'cloudflare';
+const CLOUDFLARE_PREFIX = 'cloudflare:';
+const URL_MODE = 'url';
+
 export default {
     mixins: [Fieldtype],
 
@@ -36,15 +61,21 @@ export default {
         return {
             isVisible: false,
             observer: null,
+            // Only consulted when there's no value; otherwise the value itself says which input to show.
+            mode: this.meta.video?.provider === CLOUDFLARE ? CLOUDFLARE : URL_MODE,
         };
     },
 
     computed: {
         shouldShowPreview() {
-            return !this.isInvalid && (this.isEmbeddable || this.isVideo);
+            return !this.isInvalid && (this.isCloudflare ? !!this.videoId : this.isEmbeddable || this.isVideo);
         },
 
         embedUrl() {
+            if (this.isCloudflare) {
+                return this.videoId ? `https://iframe.cloudflarestream.com/${this.videoId}` : null;
+            }
+
             let embed_url = this.value || '';
 
             if (embed_url.includes('youtube')) {
@@ -73,6 +104,16 @@ export default {
             return embed_url;
         },
 
+        invalidMessage() {
+            return this.isCloudflare
+                ? __('statamic::validation.video_fieldtype_cloudflare_id')
+                : __('statamic::validation.url');
+        },
+
+        isCloudflare() {
+            return this.value?.startsWith(CLOUDFLARE_PREFIX) || (!this.value && this.mode === CLOUDFLARE);
+        },
+
         isEmbeddable() {
             const url = this.value || '';
             const isYoutube = url.includes('youtube') || url.includes('youtu.be');
@@ -81,6 +122,8 @@ export default {
         },
 
         isInvalid() {
+            if (this.isCloudflare) return !!this.videoId && !/^[a-zA-Z0-9]+$/.test(this.videoId);
+
             let htmlRegex = new RegExp(/<([A-Z][A-Z0-9]*)\b[^>]*>.*?<\/\1>|<([A-Z][A-Z0-9]*)\b[^\/]*\/>/i);
             return htmlRegex.test(this.value || '');
         },
@@ -95,6 +138,25 @@ export default {
             const isVideo = url.includes('.mp4') || url.includes('.ogv') || url.includes('.mov') || url.includes('.webm');
             return !this.isEmbeddable && isVideo;
         },
+
+        videoId() {
+            return this.value?.startsWith(CLOUDFLARE_PREFIX) ? this.value.slice(CLOUDFLARE_PREFIX.length) : null;
+        },
+    },
+
+    methods: {
+        changeMode(mode) {
+            if (mode === this.mode) return;
+
+            this.updateDebounced.cancel();
+            this.mode = mode;
+
+            if (this.value) this.update(null);
+        },
+
+        updateCloudflareId(id) {
+            this.update(id ? `${CLOUDFLARE_PREFIX}${id}` : null);
+        },
     },
 
     mounted() {
diff --git a/resources/js/tests/components/fieldtypes/VideoFieldtype.test.js b/resources/js/tests/components/fieldtypes/VideoFieldtype.test.js
index 241092cdd86..f2a3d7fd375 100644
--- a/resources/js/tests/components/fieldtypes/VideoFieldtype.test.js
+++ b/resources/js/tests/components/fieldtypes/VideoFieldtype.test.js
@@ -5,10 +5,15 @@ import { publishContextKey } from '@/components/ui';
 
 window.__ = (key) => key;
 
+let intersect;
+
 beforeEach(() => {
     vi.useFakeTimers();
 
     window.IntersectionObserver = class {
+        constructor(callback) {
+            intersect = () => callback([{ isIntersecting: true, intersectionRatio: 1 }]);
+        }
         observe() {}
         disconnect() {}
     };
@@ -19,23 +24,24 @@ afterEach(() => {
     vi.restoreAllMocks();
 });
 
+const providers = [
+    { value: 'url', label: 'URL' },
+    { value: 'cloudflare', label: 'Cloudflare Stream' },
+];
+
 const stub = (tag) => ({
     props: ['modelValue'],
     emits: ['update:modelValue'],
     template: `<${tag} :value="modelValue" @input="$emit('update:modelValue', $event.target.value)" />`,
 });
 
-const mountVideoField = (props = {}) => {
+const mountVideoField = (value = null, video = null) => {
     return mount(VideoFieldtype, {
-        props: {
-            handle: 'video',
-            config: {},
-            meta: {},
-            ...props,
-        },
+        props: { handle: 'video', config: {}, meta: { providers, video }, value },
         global: {
             provide: { [publishContextKey]: {} },
             stubs: {
+                'ui-combobox': stub('select'),
                 'ui-input': stub('input'),
                 'ui-input-group': { template: '<div><slot /></div>' },
                 'ui-input-group-prepend': { template: '<span />' },
@@ -45,8 +51,68 @@ const mountVideoField = (props = {}) => {
     });
 };
 
+test('it shows the id input for a cloudflare value', () => {
+    const wrapper = mountVideoField('cloudflare:abc123');
+
+    expect(wrapper.find('input').element.value).toBe('abc123');
+});
+
+test('it shows the url input for a url value', () => {
+    const wrapper = mountVideoField('https://vimeo.com/1');
+
+    expect(wrapper.find('input').element.value).toBe('https://vimeo.com/1');
+});
+
+test('it stores the cloudflare id with a prefix', async () => {
+    const wrapper = mountVideoField('cloudflare:old');
+
+    await wrapper.find('input').setValue('abc123');
+
+    expect(wrapper.emitted('update:value')[0]).toEqual(['cloudflare:abc123']);
+});
+
+test('it previews a cloudflare video', async () => {
+    const wrapper = mountVideoField('cloudflare:abc123');
+    intersect();
+    await wrapper.vm.$nextTick();
+
+    expect(wrapper.find('iframe').attributes('src')).toBe('https://iframe.cloudflarestream.com/abc123');
+});
+
+test('it clears the stored value when switching provider', async () => {
+    const wrapper = mountVideoField('https://www.youtube.com/watch?v=1234');
+
+    await wrapper.find('select').setValue('cloudflare');
+
+    expect(wrapper.emitted('update:value')).toHaveLength(1);
+    expect(wrapper.emitted('update:value')[0]).toEqual([null]);
+});
+
+test('it does not emit when switching to the provider already in use', async () => {
+    const wrapper = mountVideoField(null);
+
+    await wrapper.find('select').setValue('url');
+
+    expect(wrapper.emitted('update:value')).toBeUndefined();
+});
+
+test('it rejects a malformed cloudflare id', async () => {
+    const wrapper = mountVideoField('cloudflare:abc"><script>alert(1)</script>');
+    intersect();
+    await wrapper.vm.$nextTick();
+
+    expect(wrapper.find('iframe').exists()).toBe(false);
+    expect(wrapper.find('p').exists()).toBe(true);
+});
+
+test('it uses the provider preloaded in meta for an empty field', () => {
+    const wrapper = mountVideoField(null, { provider: 'cloudflare', url: null });
+
+    expect(wrapper.vm.isCloudflare).toBe(true);
+});
+
 test('it debounces updates while typing', async () => {
-    const wrapper = mountVideoField({ value: null });
+    const wrapper = mountVideoField(null);
     const input = wrapper.find('input');
 
     await input.setValue('https://www.youtube.com/watch?v=1');
diff --git a/src/Fieldtypes/Video.php b/src/Fieldtypes/Video.php
index 5e12dbf48bf..7e21cc31c69 100644
--- a/src/Fieldtypes/Video.php
+++ b/src/Fieldtypes/Video.php
@@ -3,6 +3,7 @@
 namespace Statamic\Fieldtypes;
 
 use Statamic\Fields\Fieldtype;
+use Statamic\Fieldtypes\Video\Embed;
 
 use function Statamic\trans as __;
 
@@ -10,6 +11,23 @@ class Video extends Fieldtype
 {
     protected $categories = ['media'];
 
+    public function augment($value)
+    {
+        if (is_null($value)) {
+            return null;
+        }
+
+        return Embed::fromValue($value);
+    }
+
+    public function preload()
+    {
+        return [
+            'providers' => Embed::options(),
+            'video' => Embed::fromValue($this->field()->value())->toArray(),
+        ];
+    }
+
     protected function configFieldItems(): array
     {
         return [
diff --git a/src/Fieldtypes/Video/Embed.php b/src/Fieldtypes/Video/Embed.php
new file mode 100644
index 00000000000..304054bb61c
--- /dev/null
+++ b/src/Fieldtypes/Video/Embed.php
@@ -0,0 +1,233 @@
+<?php
+
+namespace Statamic\Fieldtypes\Video;
+
+use ArrayAccess;
+use Illuminate\Contracts\Support\Arrayable;
+use Illuminate\Support\Str;
+use JsonSerializable;
+use Statamic\Contracts\Support\Boolable;
+use Statamic\Support\FileTypes;
+
+use function Statamic\trans as __;
+
+class Embed implements Arrayable, ArrayAccess, Boolable, JsonSerializable
+{
+    const CLOUDFLARE = 'cloudflare';
+    const CLOUDFLARE_EMBED_URL = 'https://iframe.cloudflarestream.com/';
+    const CLOUDFLARE_ID_PATTERN = '/^[a-zA-Z0-9]+$/';
+    const CLOUDFLARE_PREFIX = 'cloudflare:';
+    const FILE = 'file';
+    const UNSUPPORTED = 'unsupported';
+    const URL = 'url';
+    const VIMEO = 'vimeo';
+    const YOUTUBE = 'youtube';
+
+    public static function fromValue(?string $value): self
+    {
+        if (blank($value)) {
+            return static::unsupported($value);
+        }
+
+        if (Str::startsWith($value, self::CLOUDFLARE_PREFIX)) {
+            $id = Str::after($value, self::CLOUDFLARE_PREFIX);
+
+            return preg_match(self::CLOUDFLARE_ID_PATTERN, $id)
+                ? new self(self::CLOUDFLARE, $value, self::CLOUDFLARE_EMBED_URL.$id, $id)
+                : static::unsupported($value);
+        }
+
+        if ($provider = static::oembedProvider($value)) {
+            return new self($provider, $value, static::embedUrl($value));
+        }
+
+        if (static::isVideoFile($value)) {
+            return new self(self::FILE, $value, $value);
+        }
+
+        return static::unsupported($value);
+    }
+
+    public static function options(): array
+    {
+        return [
+            ['value' => self::URL, 'label' => __('URL')],
+            ['value' => self::CLOUDFLARE, 'label' => __('Cloudflare Stream')],
+        ];
+    }
+
+    public static function unsupported(?string $value = null): self
+    {
+        return new self(self::UNSUPPORTED, $value);
+    }
+
+    public function __construct(
+        public readonly string $provider,
+        public readonly ?string $url = null,
+        public readonly ?string $embedUrl = null,
+        public readonly ?string $id = null,
+    ) {
+    }
+
+    public function isEmbeddable(): bool
+    {
+        return ! in_array($this->provider, [self::FILE, self::UNSUPPORTED]);
+    }
+
+    public function isSupported(): bool
+    {
+        return $this->provider !== self::UNSUPPORTED;
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'embed_url' => $this->embedUrl,
+            'id' => $this->id,
+            'provider' => $this->provider,
+            'url' => $this->url,
+        ];
+    }
+
+    public function toBool(): bool
+    {
+        return (bool) $this->url;
+    }
+
+    public function __toString(): string
+    {
+        return (string) $this->url;
+    }
+
+    #[\ReturnTypeWillChange]
+    public function jsonSerialize()
+    {
+        return (string) $this;
+    }
+
+    #[\ReturnTypeWillChange]
+    public function offsetExists(mixed $offset)
+    {
+        return array_key_exists($offset, $this->toArray());
+    }
+
+    #[\ReturnTypeWillChange]
+    public function offsetGet(mixed $offset)
+    {
+        return $this->toArray()[$offset] ?? null;
+    }
+
+    #[\ReturnTypeWillChange]
+    public function offsetSet(mixed $offset, mixed $value)
+    {
+    }
+
+    #[\ReturnTypeWillChange]
+    public function offsetUnset(mixed $offset)
+    {
+    }
+
+    /**
+     * Turn a link that's direct to a video's page into its embeddable equivalent.
+     */
+    public static function embedUrl(?string $url): ?string
+    {
+        if (blank($url)) {
+            return $url;
+        }
+
+        if (Str::contains($url, self::VIMEO)) {
+            return static::vimeoEmbedUrl($url);
+        }
+
+        if (Str::contains($url, 'youtu.be')) {
+            $url = str_replace('youtu.be', 'www.youtube.com/embed', $url);
+
+            // Check for start at point and replace it with correct parameter.
+            if (Str::contains($url, '?t=')) {
+                $url = str_replace('?t=', '?start=', $url);
+            }
+        }
+
+        if (Str::contains($url, 'youtube.com/watch?v=')) {
+            $url = str_replace('watch?v=', 'embed/', $url);
+
+            if (Str::contains($url, '&t=')) {
+                $url = str_replace('&t=', '?start=', $url);
+            }
+        }
+
+        if (Str::contains($url, 'youtube.com/shorts/')) {
+            $url = str_replace('shorts/', 'embed/', $url);
+        }
+
+        if (Str::contains($url, 'youtube.com')) {
+            $url = str_replace('youtube.com', 'youtube-nocookie.com', $url);
+        }
+
+        // This avoids SSL issues when using the non-www version
+        if (Str::contains($url, '//youtube-nocookie.com')) {
+            $url = str_replace('//youtube-nocookie.com', '//www.youtube-nocookie.com', $url);
+        }
+
+        if (Str::contains($url, '&') && ! Str::contains($url, '?')) {
+            $url = Str::replaceFirst('&', '?', $url);
+        }
+
+        return $url;
+    }
+
+    public static function isEmbeddableUrl(?string $url): bool
+    {
+        return filled($url) && Str::contains($url, ['youtu.be', 'youtube', self::VIMEO]);
+    }
+
+    protected static function isVideoFile(string $url): bool
+    {
+        if (blank($path = parse_url($url, PHP_URL_PATH))) {
+            return false;
+        }
+
+        return in_array(strtolower(pathinfo($path, PATHINFO_EXTENSION)), FileTypes::video());
+    }
+
+    protected static function oembedProvider(string $url): ?string
+    {
+        if (Str::contains($url, self::VIMEO)) {
+            return self::VIMEO;
+        }
+
+        if (Str::contains($url, ['youtu.be', 'youtube'])) {
+            return self::YOUTUBE;
+        }
+
+        return null;
+    }
+
+    // Unlisted vimeo urls are in the form vimeo.com/id/hash, but embeds pass the hash as a get param.
+    protected static function vimeoEmbedUrl(string $url): string
+    {
+        $url = str_replace('/vimeo.com', '/player.vimeo.com/video', $url);
+        $hash = '';
+
+        if (! Str::contains($url, 'progressive_redirect') && Str::substrCount($url, '/') > 4) {
+            $hash = Str::afterLast($url, '/');
+            $url = Str::beforeLast($url, '/');
+
+            if (Str::contains($hash, '?')) {
+                $url .= '?'.Str::after($hash, '?');
+                $hash = Str::before($hash, '?');
+            }
+        }
+
+        $paramsToAdd = '?dnt=1';
+
+        if ($hash) {
+            $paramsToAdd .= '&h='.$hash;
+        }
+
+        return Str::contains($url, '?')
+            ? str_replace('?', $paramsToAdd.'&', $url)
+            : $url.$paramsToAdd;
+    }
+}
diff --git a/src/Modifiers/CoreModifiers.php b/src/Modifiers/CoreModifiers.php
index 42e3d800704..1f04fcf8df8 100644
--- a/src/Modifiers/CoreModifiers.php
+++ b/src/Modifiers/CoreModifiers.php
@@ -28,6 +28,7 @@
 use Statamic\Fieldtypes\Bard;
 use Statamic\Fieldtypes\Bard\Augmentor;
 use Statamic\Fieldtypes\Link\ArrayableLink;
+use Statamic\Fieldtypes\Video\Embed;
 use Statamic\Statamic;
 use Statamic\Support\Arr;
 use Statamic\Support\Dumper;
@@ -35,6 +36,7 @@
 use Statamic\Support\Str;
 use Statamic\Support\Traits\ChecksDumpability;
 use Statamic\View\Antlers\Language\Runtime\GlobalRuntimeState;
+use Stringable;
 use Stringy\StaticStringy as Stringy;
 
 use function Statamic\trans;
@@ -1560,7 +1562,9 @@ public function length($value)
             return $value->count();
         }
 
-        if ($value instanceof Arrayable) {
+        // Value objects like ArrayableString are both Arrayable and Stringable.
+        // They stand in for a string, so measure the string, not the array.
+        if ($value instanceof Arrayable && ! $value instanceof Stringable) {
             $value = $value->toArray();
         }
 
@@ -3199,60 +3203,11 @@ public function yearsAgo($value, $params)
      */
     public function embedUrl($url)
     {
-        if (Str::contains($url, 'vimeo')) {
-            $url = str_replace('/vimeo.com', '/player.vimeo.com/video', $url);
-
-            [$url, $hash] = $this->handleUnlistedVimeoUrls($url);
-
-            $paramsToAdd = '?dnt=1';
-            if ($hash) {
-                $paramsToAdd .= '&h='.$hash;
-            }
-
-            if (Str::contains($url, '?')) {
-                $url = str_replace('?', $paramsToAdd.'&', $url);
-            } else {
-                $url .= $paramsToAdd;
-            }
-
-            return $url;
-        }
-
-        if (Str::contains($url, 'youtu.be')) {
-            $url = str_replace('youtu.be', 'www.youtube.com/embed', $url);
-
-            // Check for start at point and replace it with correct parameter.
-            if (Str::contains($url, '?t=')) {
-                $url = str_replace('?t=', '?start=', $url);
-            }
-        }
-
-        if (Str::contains($url, 'youtube.com/watch?v=')) {
-            $url = str_replace('watch?v=', 'embed/', $url);
-
-            if (Str::contains($url, '&t=')) {
-                $url = str_replace('&t=', '?start=', $url);
-            }
-        }
-
-        if (Str::contains($url, 'youtube.com/shorts/')) {
-            $url = str_replace('shorts/', 'embed/', $url);
+        if ($url instanceof Embed) {
+            return $url->embedUrl ?? $url->url;
         }
 
-        if (Str::contains($url, 'youtube.com')) {
-            $url = str_replace('youtube.com', 'youtube-nocookie.com', $url);
-        }
-
-        // This avoids SSL issues when using the non-www version
-        if (Str::contains($url, '//youtube-nocookie.com')) {
-            $url = str_replace('//youtube-nocookie.com', '//www.youtube-nocookie.com', $url);
-        }
-
-        if (Str::contains($url, '&') && ! Str::contains($url, '?')) {
-            $url = Str::replaceFirst('&', '?', $url);
-        }
-
-        return $url;
+        return Embed::embedUrl($url);
     }
 
     /**
@@ -3264,6 +3219,14 @@ public function embedUrl($url)
      */
     public function trackableEmbedUrl($url)
     {
+        if ($url instanceof Embed) {
+            $url = $url->url;
+        }
+
+        if (blank($url)) {
+            return $url;
+        }
+
         if (Str::contains($url, 'vimeo')) {
             return str_replace('/vimeo.com', '/player.vimeo.com/video', $url);
         }
@@ -3296,7 +3259,11 @@ public function trackableEmbedUrl($url)
      */
     public function isEmbeddable($url)
     {
-        return Str::contains($url, ['youtu.be', 'youtube', 'vimeo']);
+        if ($url instanceof Embed) {
+            return $url->isEmbeddable();
+        }
+
+        return Embed::isEmbeddableUrl($url);
     }
 
     /**
@@ -3381,24 +3348,6 @@ private function getFromContext($context, $params, $key = 0)
                 Arr::get($context, $params[$key], $params[$key]);
     }
 
-    // unlisted vimeo urls are in the form vimeo.com/id/hash, but embeds pass the hash as a get param
-    private function handleUnlistedVimeoUrls($url)
-    {
-        $hash = '';
-
-        if (! Str::contains($url, 'progressive_redirect') && Str::substrCount($url, '/') > 4) {
-            $hash = Str::afterLast($url, '/');
-            $url = Str::beforeLast($url, '/');
-
-            if (Str::contains($hash, '?')) {
-                $url .= '?'.Str::after($hash, '?');
-                $hash = Str::before($hash, '?');
-            }
-        }
-
-        return [$url, $hash];
-    }
-
     private function dumpingAllowed(array $params): bool
     {
         return $this->traitDumpingAllowed() || (Arr::get($params, 0) === 'force');
diff --git a/tests/Fieldtypes/Video/EmbedTest.php b/tests/Fieldtypes/Video/EmbedTest.php
new file mode 100644
index 00000000000..f386e8b5217
--- /dev/null
+++ b/tests/Fieldtypes/Video/EmbedTest.php
@@ -0,0 +1,96 @@
+<?php
+
+namespace Tests\Fieldtypes\Video;
+
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\Attributes\Test;
+use Statamic\Fieldtypes\Video\Embed;
+use Tests\TestCase;
+
+class EmbedTest extends TestCase
+{
+    #[Test]
+    #[DataProvider('valuesProvider')]
+    public function it_creates_a_video($value, $provider, $id, $embedUrl)
+    {
+        $video = Embed::fromValue($value);
+
+        $this->assertSame($provider, $video->provider);
+        $this->assertSame($id, $video->id);
+        $this->assertSame($embedUrl, $video->embedUrl);
+    }
+
+    public static function valuesProvider()
+    {
+        return [
+            'youtube' => ['https://www.youtube.com/watch?v=FK3dav4bA4s', 'youtube', null, 'https://www.youtube-nocookie.com/embed/FK3dav4bA4s'],
+            'youtube shorts' => ['https://www.youtube.com/shorts/FK3dav4bA4s', 'youtube', null, 'https://www.youtube-nocookie.com/embed/FK3dav4bA4s'],
+            'youtu.be' => ['https://youtu.be/FK3dav4bA4s', 'youtube', null, 'https://www.youtube-nocookie.com/embed/FK3dav4bA4s'],
+            'vimeo' => ['https://vimeo.com/22439234', 'vimeo', null, 'https://player.vimeo.com/video/22439234?dnt=1'],
+            'cloudflare' => ['cloudflare:1234', 'cloudflare', '1234', 'https://iframe.cloudflarestream.com/1234'],
+            'cloudflare without an id' => ['cloudflare:', 'unsupported', null, null],
+            'cloudflare with a malformed id' => ['cloudflare:1234"></iframe><script>alert(1)</script>', 'unsupported', null, null],
+            'cloudflare with a path traversal id' => ['cloudflare:../../evil', 'unsupported', null, null],
+            'mp4 file' => ['https://example.com/clip.mp4', 'file', null, 'https://example.com/clip.mp4'],
+            'uppercase file extension' => ['https://example.com/clip.MOV', 'file', null, 'https://example.com/clip.MOV'],
+            'file with a query string' => ['https://example.com/clip.webm?t=1', 'file', null, 'https://example.com/clip.webm?t=1'],
+            'unsupported' => ['https://example.com/nope', 'unsupported', null, null],
+            'empty' => ['', 'unsupported', null, null],
+            'null' => [null, 'unsupported', null, null],
+        ];
+    }
+
+    #[Test]
+    public function it_casts_to_the_original_value()
+    {
+        $this->assertSame('https://vimeo.com/22439234', (string) Embed::fromValue('https://vimeo.com/22439234'));
+        $this->assertSame('cloudflare:1234', (string) Embed::fromValue('cloudflare:1234'));
+        $this->assertSame('', (string) Embed::fromValue(null));
+    }
+
+    #[Test]
+    public function it_is_truthy_whenever_it_holds_a_value()
+    {
+        $this->assertTrue(Embed::fromValue('https://vimeo.com/22439234')->toBool());
+        $this->assertTrue(Embed::fromValue('https://example.com/nope')->toBool());
+        $this->assertFalse(Embed::fromValue('')->toBool());
+    }
+
+    #[Test]
+    public function it_knows_whether_it_is_supported_and_embeddable()
+    {
+        $this->assertTrue(Embed::fromValue('https://vimeo.com/22439234')->isEmbeddable());
+        $this->assertTrue(Embed::fromValue('https://vimeo.com/22439234')->isSupported());
+
+        // A file is something we can play, but not something we can put in an iframe.
+        $this->assertFalse(Embed::fromValue('https://example.com/clip.mp4')->isEmbeddable());
+        $this->assertTrue(Embed::fromValue('https://example.com/clip.mp4')->isSupported());
+
+        $this->assertFalse(Embed::fromValue('https://example.com/nope')->isEmbeddable());
+        $this->assertFalse(Embed::fromValue('https://example.com/nope')->isSupported());
+    }
+
+    #[Test]
+    public function it_is_arrayable_and_accessible_as_an_array()
+    {
+        $video = Embed::fromValue('cloudflare:1234');
+
+        $this->assertSame([
+            'embed_url' => 'https://iframe.cloudflarestream.com/1234',
+            'id' => '1234',
+            'provider' => 'cloudflare',
+            'url' => 'cloudflare:1234',
+        ], $video->toArray());
+
+        $this->assertSame('https://iframe.cloudflarestream.com/1234', $video['embed_url']);
+        $this->assertTrue(isset($video['provider']));
+        $this->assertNull($video['nope']);
+    }
+
+    #[Test]
+    public function it_serializes_to_json_as_the_original_value()
+    {
+        $this->assertSame('"cloudflare:1234"', json_encode(Embed::fromValue('cloudflare:1234')));
+        $this->assertSame('"https:\\/\\/vimeo.com\\/1"', json_encode(Embed::fromValue('https://vimeo.com/1')));
+    }
+}
diff --git a/tests/Fieldtypes/Video/ParityTest.php b/tests/Fieldtypes/Video/ParityTest.php
new file mode 100644
index 00000000000..e0de27ac11a
--- /dev/null
+++ b/tests/Fieldtypes/Video/ParityTest.php
@@ -0,0 +1,103 @@
+<?php
+
+namespace Tests\Fieldtypes\Video;
+
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\Attributes\Test;
+use Statamic\Fields\Field;
+use Statamic\Fields\Value;
+use Statamic\Fieldtypes\Video;
+use Statamic\Modifiers\Modify;
+use Tests\TestCase;
+
+/**
+ * An augmented video field has to behave like the string it was before it was
+ * augmented. Everything here would pass against a raw string, so each case
+ * asserts the augmented value agrees with it.
+ *
+ * Cloudflare values are deliberately absent: `cloudflare:<id>` is a new format
+ * with no prior behaviour to preserve. VideoTest covers it instead.
+ */
+class ParityTest extends TestCase
+{
+    public static function valuesProvider()
+    {
+        return [
+            'null' => [null],
+            'empty' => [''],
+            'unsupported' => ['https://example.com/nope'],
+            'youtube' => ['https://www.youtube.com/watch?v=FK3dav4bA4s'],
+            'youtube shorts' => ['https://www.youtube.com/shorts/FK3dav4bA4s'],
+            'youtu.be' => ['https://youtu.be/FK3dav4bA4s'],
+            'vimeo' => ['https://vimeo.com/22439234'],
+            'unlisted vimeo' => ['https://vimeo.com/22439234/abcdef'],
+            'vimeo progressive file' => ['https://player.vimeo.com/progressive_redirect/playback/123/rendition/1080p/file.mp4?loc=external'],
+            'video file' => ['https://example.com/clip.mp4'],
+        ];
+    }
+
+    #[Test]
+    #[DataProvider('valuesProvider')]
+    public function the_embed_url_modifier_matches_the_raw_value($value)
+    {
+        $this->assertSame(
+            Modify::value($value)->embedUrl()->fetch(),
+            Modify::value($this->augment($value))->embedUrl()->fetch(),
+        );
+    }
+
+    #[Test]
+    #[DataProvider('valuesProvider')]
+    public function the_trackable_embed_url_modifier_matches_the_raw_value($value)
+    {
+        $this->assertSame(
+            Modify::value($value)->trackableEmbedUrl()->fetch(),
+            Modify::value($this->augment($value))->trackableEmbedUrl()->fetch(),
+        );
+    }
+
+    #[Test]
+    #[DataProvider('valuesProvider')]
+    public function the_is_embeddable_modifier_matches_the_raw_value($value)
+    {
+        $this->assertSame(
+            Modify::value($value)->isEmbeddable()->fetch(),
+            Modify::value($this->augment($value))->isEmbeddable()->fetch(),
+        );
+    }
+
+    #[Test]
+    #[DataProvider('valuesProvider')]
+    public function it_casts_to_the_original_value($value)
+    {
+        $this->assertSame((string) $value, (string) $this->augment($value));
+    }
+
+    #[Test]
+    #[DataProvider('valuesProvider')]
+    public function it_is_as_truthy_as_the_original_value($value)
+    {
+        // A null value isn't augmented at all, so there's no object to ask.
+        if (is_null($augmented = $this->augment($value))) {
+            $this->assertNull($value);
+
+            return;
+        }
+
+        $this->assertSame((bool) $value, $augmented->toBool());
+    }
+
+    #[Test]
+    #[DataProvider('valuesProvider')]
+    public function it_serializes_to_the_original_value($value)
+    {
+        $field = (new Video)->setField(new Field('test', ['type' => 'video']));
+
+        $this->assertSame(json_encode($value), json_encode(new Value($value, 'test', $field)));
+    }
+
+    private function augment($value)
+    {
+        return (new Video)->setField(new Field('test', ['type' => 'video']))->augment($value);
+    }
+}
diff --git a/tests/Fieldtypes/VideoTest.php b/tests/Fieldtypes/VideoTest.php
new file mode 100644
index 00000000000..411bebb59a1
--- /dev/null
+++ b/tests/Fieldtypes/VideoTest.php
@@ -0,0 +1,78 @@
+<?php
+
+namespace Tests\Fieldtypes;
+
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\Attributes\Test;
+use Statamic\Fields\Field;
+use Statamic\Fieldtypes\Video;
+use Statamic\Fieldtypes\Video\Embed;
+use Tests\TestCase;
+
+class VideoTest extends TestCase
+{
+    #[Test]
+    public function it_augments_null_to_null()
+    {
+        $this->assertNull($this->fieldtype()->augment(null));
+    }
+
+    #[Test]
+    #[DataProvider('augmentProvider')]
+    public function it_augments_to_a_video($value, $provider, $id, $embedUrl)
+    {
+        $video = $this->fieldtype()->augment($value);
+
+        $this->assertInstanceOf(Embed::class, $video);
+        $this->assertSame($provider, $video->provider);
+        $this->assertSame($id, $video->id);
+        $this->assertSame($embedUrl, $video->embedUrl);
+    }
+
+    public static function augmentProvider()
+    {
+        return [
+            'url' => ['https://vimeo.com/22439234', 'vimeo', null, 'https://player.vimeo.com/video/22439234?dnt=1'],
+            'cloudflare' => ['cloudflare:1234', 'cloudflare', '1234', 'https://iframe.cloudflarestream.com/1234'],
+            'file' => ['https://example.com/clip.mp4', 'file', null, 'https://example.com/clip.mp4'],
+            'unsupported' => ['https://example.com/nope', 'unsupported', null, null],
+        ];
+    }
+
+    #[Test]
+    public function the_augmented_value_casts_to_the_original_value_for_backwards_compatibility()
+    {
+        $this->assertSame(
+            'https://vimeo.com/22439234',
+            (string) $this->fieldtype()->augment('https://vimeo.com/22439234'),
+        );
+    }
+
+    #[Test]
+    public function it_preloads_the_providers_and_the_current_video()
+    {
+        $meta = $this->fieldtype('cloudflare:1234')->preload();
+
+        $this->assertSame([
+            ['value' => 'url', 'label' => 'URL'],
+            ['value' => 'cloudflare', 'label' => 'Cloudflare Stream'],
+        ], $meta['providers']);
+
+        $this->assertSame('cloudflare', $meta['video']['provider']);
+        $this->assertSame('https://iframe.cloudflarestream.com/1234', $meta['video']['embed_url']);
+    }
+
+    #[Test]
+    public function it_preloads_an_empty_field()
+    {
+        $this->assertSame('unsupported', $this->fieldtype()->preload()['video']['provider']);
+    }
+
+    private function fieldtype($value = null)
+    {
+        return tap(new Video, fn (Video $fieldtype) => $fieldtype
+            ->setField(new Field('test', ['type' => 'video']))
+            ->field()->setValue($value)
+        );
+    }
+}
diff --git a/tests/Modifiers/EmbedUrlTest.php b/tests/Modifiers/EmbedUrlTest.php
index 6061c170f3f..645add32196 100644
--- a/tests/Modifiers/EmbedUrlTest.php
+++ b/tests/Modifiers/EmbedUrlTest.php
@@ -3,6 +3,7 @@
 namespace Tests\Modifiers;
 
 use PHPUnit\Framework\Attributes\Test;
+use Statamic\Fieldtypes\Video\Embed;
 use Statamic\Modifiers\Modify;
 use Tests\TestCase;
 
@@ -113,6 +114,20 @@ public function it_ensures_url_with_query_parameters_are_valid()
         );
     }
 
+    #[Test]
+    public function it_gets_the_embed_url_from_an_augmented_video_value()
+    {
+        $this->assertEquals(
+            'https://iframe.cloudflarestream.com/1234',
+            $this->embed(Embed::fromValue('cloudflare:1234')),
+        );
+
+        $this->assertEquals(
+            'https://player.vimeo.com/video/22439234?dnt=1',
+            $this->embed(Embed::fromValue('https://vimeo.com/22439234')),
+        );
+    }
+
     public function embed($url)
     {
         return Modify::value($url)->embedUrl()->fetch();
diff --git a/tests/Modifiers/LengthTest.php b/tests/Modifiers/LengthTest.php
index 826d7168dc6..117c39c43fe 100644
--- a/tests/Modifiers/LengthTest.php
+++ b/tests/Modifiers/LengthTest.php
@@ -6,6 +6,7 @@
 use Mockery;
 use PHPUnit\Framework\Attributes\Test;
 use Statamic\Contracts\Query\Builder;
+use Statamic\Fields\ArrayableString;
 use Statamic\Modifiers\Modify;
 use Tests\TestCase;
 
@@ -47,12 +48,26 @@ public function it_returns_the_number_of_items_in_a_query()
     #[Test]
     public function it_returns_the_number_of_items_in_an_arrayable()
     {
-        $arrayable = Mockery::mock(Arrayable::class)->shouldReceive('toArray')->andReturn(['one', 'two'])->getMock();
+        $arrayable = new class implements Arrayable
+        {
+            public function toArray()
+            {
+                return ['one', 'two'];
+            }
+        };
 
         $modified = $this->modify($arrayable);
         $this->assertSame(2, $modified);
     }
 
+    #[Test]
+    public function it_returns_the_number_of_chars_in_a_stringable_arrayable()
+    {
+        // Value objects like ArrayableString stand in for a string, so the
+        // string is what should get measured, not their array form.
+        $this->assertSame(19, $this->modify(new ArrayableString('https://vimeo.com/1')));
+    }
+
     #[Test]
     public function it_returns_the_numbers_of_chars_in_string(): void
     {