SharePlay is a framework you adopt, and the work is native iOS code, not a setting.
SharePlay lets people use your app together, in sync, from their own devices. You build it with Apple's Group Activities framework, and that means three pieces: a capability you add in Xcode, a Swift type that describes the activity, and a session object that keeps every device in step. There is no toggle and no JavaScript API. The framework has been there since iOS 15.0, and it is an Apple feature only: iOS, iPadOS, Mac Catalyst, macOS, tvOS and visionOS are on Apple's list, and watchOS is not. Every version number and screen name below comes from Apple's own documentation, read on 10 October 2026. Most people meet SharePlay partway through building an app, once the single-player version already works.
What follows is what the framework actually gives you, whether a FaceTime call has to be running, the exact steps to turn it on, and which kinds of app it suits. Then the line Apple states plainly and most write-ups skip. If your content is paid, every participant needs their own copy or subscription before they can join.
Start hereThe short version
Two questions decide it. Is it real time, and is everyone on an Apple device.
SharePlay is for things people do at the same moment. Watching together, drawing on one canvas, playing a round, following a class. The system keeps the activity in sync across devices and lets people talk over FaceTime or Messages while they do it. If your users contribute on their own schedule instead, SharePlay is the wrong tool and a shared document with a link is the right one.
The second question is harder to argue with. Group Activities is an Apple framework. There is no Android half, and nothing you write here ships in a Google Play build. If your app is cross-platform, SharePlay is a feature some of your users get and the rest never see. That is fine for co-watching on iPhone. It is a problem when the shared activity is the product.
What is SharePlay, and which framework do you build it with?
SharePlay is the name users see. Group Activities is the framework you write against. Apple describes the job as providing your app's content in SharePlay experiences: your app handles the playback, or the drawing, or whatever the activity is, on each device, and the framework synchronizes that behaviour and carries messages between the devices. The documentation is blunt about how it travels. It leverages the FaceTime infrastructure to synchronize activities and to invite other participants to join them.
Three types do most of the work. A struct conforming to GroupActivity describes what is being shared and advertises it to other people. A GroupSession object represents the activity once it is running and keeps content in step across the participants. A GroupSessionMessenger sends your own app data over the same channel, which is how a drawing app gets one new stroke onto five screens. Media has a separate path: coordinated playback in AVFoundation, so one person hitting pause pauses it for everyone.
Two facts about the data are worth having ready before anyone asks them in a privacy review. Apple states that the framework uses end-to-end encryption on all session data the session object synchronizes between devices, and that Apple does not have the keys to decrypt it. It also states that the Apple servers facilitating Group Activities sessions do not know the identity of your app. That is a stronger answer than most third-party real-time services can give you, and it costs you nothing to adopt.
The platform list in the framework reference is short and worth reading before you promise the feature to anyone. iOS 15.0, iPadOS 15.0, Mac Catalyst 15.0, macOS 12.0, tvOS 15.0 and visionOS 1.0. watchOS is absent, and Apple's design guidance for SharePlay says it is not supported there. So a watch companion cannot join, and neither can a browser, beyond the fallback URL you can put in your activity metadata for people who have no other way in.
Apple, Group Activities framework reference, read 10 October 2026
Does SharePlay only work inside a FaceTime call?
No, but something always has to be connecting the people. Apple states that starting an activity requires an active FaceTime call or Messages conversation. You find out which you are in by checking the isEligibleForGroupSession property on a GroupStateObserver. If it is true, call prepareForActivation or activate on your activity and the session begins. If it is false, the answer is not to hide the button. You present a GroupActivitySharingController, which shows the system interface for starting the activity, puts a people picker in front of the person, and starts the FaceTime call itself if none is running. That controller has been available since iOS 15.4.
Two more ways in feel more natural than a button, and both reuse something people already know. In SwiftUI, a ShareLink whose item is your activity puts SharePlay inside the share sheet, so starting a shared session uses the same panel people use to send a link. In UIKit you register the activity on an NSItemProvider before presenting the sheet, and a SharePlay button appears in it. Both routes need your activity type to conform to Transferable, so decide that early rather than retrofitting it.
SharePlay over AirDrop is the route most people have never seen. A person opens your app on their iPhone, goes to the thing they want to share, and brings their phone close to other iPhones. Their phone offers to start the activity, the people nearby get a prompt to join, and the system creates a Messages conversation for the group. Anyone in that group can then invite people who are not in the room. For a game or a quiz in a room full of people, this is the shortest path from idea to a session with four players in it.
This is also the answer to the question people arrive with from the other direction. Sharing your screen in FaceTime and SharePlay are not the same feature. Screen sharing mirrors one device's display to everyone and needs nothing at all from you as a developer. SharePlay runs your app on every participant's own device, with their own account, their own copy of the content and their own view of it. If all you want is for someone to watch what you are doing, you do not need any of this. If you want them to play, draw or watch along, you do.
What does it take to add SharePlay to an app?
Start with the capability, because nothing works without it. Open your Xcode project, select your app target, go to the Signing and Capabilities pane, and add the Group Activities capability. Xcode then adds the entitlements your app needs and updates its provisioning profile. The entitlement behind that switch is com.apple.developer.group-session, a Boolean value saying the app may implement shared group experiences. Apple notes it applies only to apps, so configure it on app targets and leave extensions alone.
Then the activity itself. Define a struct that conforms to GroupActivity, keep the data inside it small, and make that data Codable. Conform to Transferable as well if you want the share sheet and AirDrop routes. Apple's advice on the payload is the part worth copying: store a link to a video rather than the file itself, and share state rather than detailed changes. Each activity also carries a GroupActivityMetadata value with a concise title, a short description, an image and an optional fallback URL for joining from a browser. If your app offers more than one activity, every GroupActivity type needs its own unique activityIdentifier.
The session half is where the real engineering sits, and where estimates go wrong. You join the session, hold a strong reference to it for as long as it lasts, and decide what each participant sees. GroupSessionMessenger carries the time-sensitive traffic, a move or a stroke or a scroll position. GroupSessionJournal, available from iOS 17.0, carries files and data objects and makes them available to everyone regardless of when they joined, which is the fix for the person who arrives ten minutes late. Getting that latecomer right usually takes longer than everything before it.
One thing the messenger is not. It is a synchronization channel for an activity running right now, not a message store. What it sends does not survive the session, and someone who joins later sees none of it unless you put it in the journal yourself. If what you actually want is a conversation that persists between sessions, that is adding chat, which is a different build with a database behind it and no Apple capability involved.
Apple, configure the Group Activities capability, read 10 October 2026
Which apps suit SharePlay, and which do not?
Apple's own list of examples is a good filter, because the system interface was designed around it. Watching or listening to content together. Taking part in an online fitness class. Creating content on a shared whiteboard or a painter's canvas. Shopping for food, clothes or other online products. Planning a trip or browsing the web. Reading a book or taking an online class. The common shape is easy to see once it is spelled out: two or more people, the same thing, the same moment, each on their own device.
Four kinds of app should skip it. Anything asynchronous, where people contribute on their own schedule, because the session ends when the conversation does. Anything whose users are mostly on Android or the web, for the platform reason above. Anything where the real need is handing over one file or one link, which the system share sheet already covers in a line of code. And anything solo, where adopting this means building and supporting a second multiplayer product beside the one that works.
There is a fifth case that catches content apps in particular. Apple states that if your activity involves content people buy or subscribe to, each participant needs their own copy or subscription, and that the system prompts anyone without access to download or subscribe. A co-watching feature over a thin catalogue behind a hard paywall converts badly for that reason. Apple's design guidance suggests lowering the barrier with provisional access for non-subscribers or support for Family Sharing, and getting people into the shared content before you ask them for anything.
Two smaller things that come up in review conversations. Use the word SharePlay the way Apple does, as a noun or as a verb in your interface, and do not pair it with an adjective or bend it into SharePlayed or SharePlaying. And give people a visible way in: a control carrying the SharePlay symbol from SF Symbols, placed next to the thing being shared rather than buried in a settings screen. The system will also invite anyone who does not have your app to download it from the App Store, so a joiner who has never heard of you is a real case to design for.
Apple, defining your app's SharePlay activities, the example activity list, read 10 October 2026
Check yours
Does SharePlay fit what you are building?
Pick the shape closest to your app. The verdicts follow what Apple documents, not what sounds exciting.
Apple designed the system interface around this one
Co-watching is the first example in Apple's own list. Coordinated playback in AVFoundation does the hard half, so one person pausing pauses everyone.
What each piece gives you, and the first version that has it
| Piece | What it gives you | First iOS | Also on |
|---|---|---|---|
| Group Activities framework | The whole thing. Activities, sessions, participants | iOS 15.0 | iPadOS 15.0, macOS 12.0, tvOS 15.0, visionOS 1.0 |
| GroupActivity | The struct that describes and advertises your activity | iOS 15.0 | iPadOS 15.0, macOS 12.0, tvOS 15.0, visionOS 1.0 |
| GroupSessionMessenger | Your own messages between joined devices, as they happen | iOS 15.0 | iPadOS 15.0, macOS 12.0, tvOS 15.0, visionOS 1.0 |
| GroupStateObserver | Tells you whether a session can start right now | iOS 15.0 | iPadOS 15.0, macOS 12.0, tvOS 15.0, visionOS 1.0 |
| GroupActivitySharingController | System picker that starts the activity, and the call, from your UI | iOS 15.4 | iPadOS 15.4, visionOS 1.0, separate class on macOS |
| GroupSessionJournal | File and data transfer that late joiners also receive | iOS 17.0 | iPadOS 17.0, macOS 14.0, tvOS 17.0, visionOS 1.0 |
| SystemCoordinator and spatial templates | Seating and placement for shared spatial content | Not on iOS | visionOS 1.0 only |
Availability read from Apple's framework reference on 10 October 2026. watchOS appears on none of these.
Where this lands if a builder generated your app
Nothing about SharePlay gets easier because an AI wrote the app. Group Activities is a Swift framework with an Xcode capability and no JavaScript API. In a React Native project it arrives as native module work: Swift types on the iOS side, a bridge to your screens, and a build that compiles your own native code. No prompt produces it, and a tool that claims otherwise is describing screen sharing or a web room instead.
Newly is an AI app builder. You describe an app in plain English and it writes a real React Native and Expo project that you own. It uploads iOS builds to TestFlight, publishes to Google Play internal testing, builds a standalone Android APK, and keeps two-way GitHub sync. It is paid from $25 a month, with no free tier. The GitHub sync is the part that matters here. Have the agent build the screens, the data model and the single-player version, then open the project in Xcode, add the Group Activities capability and the Swift side by hand, and push it back.
Two limits worth saying out loud. SharePlay is an Apple feature, so the Android build you get from the same project gains nothing from that work, and you will be maintaining a feature half your users cannot see. And on iOS you are the one who submits: App Store Review Guideline 4.2.6 rejects apps created from a commercialized template or app generation service unless the provider of the app's content submits them, which is you. If you want a sense of how much native iOS work a feature like this is before you commit, Live Activities is the same shape of problem at a smaller scale, and a good place to learn the pattern.
Questions people ask about SharePlay
SharePlay is the Apple feature that lets people take part in your app's activities together, in sync, from their own devices while they are on a FaceTime call or in a Messages conversation. Watching a video at the same time, drawing on one canvas, following a class, playing a round. Your app runs on each device and the system keeps the activity in step. SharePlay is the name people see. Group Activities is the framework you build it with.
Build the app first, then decide whether it needs SharePlay
The one-person version has to be worth using before a shared one matters. Describe the app in plain English, get a real Expo project you own, and keep the Xcode door open for the native parts.
Start building