WWDC 2025 – Enhance child safety with PermissionKit

With iOS 26, Apple introduces PermissionKit, a powerful framework designed to enhance child safety in communication apps. This framework provides a seamless way for children to request permission from their parents before communicating with unknown contacts, directly through Messages.

Core Requirements

Prerequisites

• Family Sharing: Users must be part of a Family Sharing group
• Communication Limits: Parents must enable Communication Limits for the child
• Age Detection: Apps need existing systems to determine if users are children
• Fallback Handling: API returns default responses when prerequisites aren’t met

When to Use PermissionKit

• Apps with communication functionality (messaging, calling, video chat)
• Multi-generational apps serving users of all ages
• Apps requiring parental oversight for child interactions
• Platforms wanting consistent permission experiences across Apple devices

Implementation Strategy

1. Age Range Detection

Before implementing PermissionKit, establish user age ranges using either:

• Existing account systems with age verification
• Apple’s new Declared Age Range API for apps without age systems

Critical: Only use PermissionKit APIs when confirmed the user is a child.

2. UI Adaptation for Children

Hide potentially sensitive content from unknown senders:

• Message previews
• Profile pictures
• User-generated content
• Any information not suitable for children

import PermissionKit

let knownHandles = await CommunicationLimits.current.knownHandles(in: conversation.participants)

if knownHandles.isSuperset(of: conversation.participants) {
    // Show content
} else {
    // Hide content
}

Key Points:

• knownHandles(in:) performs optimized system lookups
• Supplement with existing database information
• Only reveal content when all handles are known
• Default to hiding content for child safety

3. Creating Permission Questions

Basic Question Structure

import PermissionKit

var question = PermissionQuestion(handles: [
    CommunicationHandle(value: "dragonslayer42", kind: .custom),
    CommunicationHandle(value: "progamer67", kind: .custom)
])

Enhanced Questions with Metadata

import PermissionKit

let people = [
    PersonInformation(
        handle: CommunicationHandle(value: "dragonslayer42", kind: .custom),
        nameComponents: nameComponents,
        avatarImage: profilePic
    ),
    PersonInformation(
        handle: CommunicationHandle(value: "progamer67", kind: .custom)
    )
]

var topic = CommunicationTopic(personInformation: people)
topic.actions = [.message]

var question = PermissionQuestion(communicationTopic: topic)

Best Practices:

• Include maximum metadata possible (names, images, handles)
• Set appropriate actions (message, call, video)
• Metadata appears in parental review interface
• More context leads to better parental decisions

4. Presenting Permission Requests

SwiftUI Implementation

import PermissionKit
import SwiftUI

struct ContentView: View {
    let question: PermissionQuestion<CommunicationTopic>

    var body: some View {
        // ...
        CommunicationLimitsButton(question: question) {
            Label("Ask Permission", systemImage: "paperplane")
        }
    }
}

UIKit Implementation

import PermissionKit
import UIKit

try await CommunicationLimits.current.ask(question, in: viewController)

AppKit Implementation

import PermissionKit
import AppKit

try await CommunicationLimits.current.ask(question, in: window)

User Experience Flow:

• Child taps permission button
• System presents confirmation alert
• Options include “Ask via Messages” or “Get approval in-person”
• Messages compose window opens with pre-filled recipients
• Child can add context or names before sending

5. Handling Parental Responses

import PermissionKit
import SwiftUI

struct MessagingView: View {
    @State var isShowingResponseAlert = false

    var body: some View {
        List {
           // ...
        }
        .task {
            let updates = CommunicationLimits.current.updates
            for await update in updates {
                // Received a response!
                self.isShowingResponseAlert = true
            }
        }
    }
}

Response Handling Strategy:

• App launches in background when parents respond
• Obtain AsyncSequence from CommunicationLimits singleton
• Process responses on background tasks
• Update UI and local caches immediately
• Sync permission changes to servers
• Show notifications to inform children of decisions

Parental Experience

Review Process

• Parents receive permission requests in Messages
• Quick decline option available directly from message bubble
• Detailed review shows complete context and metadata
• Clear approve/decline interface with reasoning options

Decision Factors

• Child’s relationship to unknown contact
• Provided metadata (names, images, context)
• Communication type (messaging, calling, video)
• Historical permission patterns

Advanced Considerations

Cross-Platform Consistency

• Use PermissionKit as foundation for web-based experiences
• Sync permission data to servers for platform consistency
• Maintain permission states across all user touchpoints

Integration with Family Safety APIs

Sensitive Content Analysis API

• Detects and blocks inappropriate content in video calls
• Complements PermissionKit for comprehensive protection
• Essential for live streaming and video communication features

Screen Time Framework

• Provides parental supervision tools for web usage
• Integrates with PermissionKit permission patterns
• Enables comprehensive time and content management

Family Controls Framework

• Allows apps to implement custom parental controls
• Works alongside PermissionKit for complete safety solutions
• Enables app-specific restriction and monitoring features

Implementation Checklist

Phase 1: Foundation

• [ ] Implement age range detection system
• [ ] Audit UI for child-appropriate content filtering
• [ ] Test Family Sharing group requirements
• [ ] Verify Communication Limits dependencies

Phase 2: Core Integration

• [ ] Implement knownHandles content filtering
• [ ] Create permission question infrastructure
• [ ] Add platform-specific UI components (SwiftUI/UIKit/AppKit)
• [ ] Test permission request flow end-to-end

Phase 3: Response Handling

• [ ] Implement background response processing
• [ ] Add AsyncSequence monitoring for permission updates
• [ ] Create UI update mechanisms for permission changes
• [ ] Test notification delivery and app state management

Phase 4: Enhancement

• [ ] Add comprehensive metadata to permission requests
• [ ] Implement server-side permission synchronization
• [ ] Integrate with additional Family Safety APIs
• [ ] Add analytics for permission request patterns

Performance Considerations

Optimization Strategies

• Cache known handles to reduce API calls
• Implement efficient metadata loading for contacts
• Use background queues for permission response processing
• Minimize UI blocking during permission checks

Memory Management

• Properly manage AsyncSequence subscriptions
• Release permission question resources after use
• Cache contact metadata efficiently
• Handle app backgrounding during permission flows

Conclusion

PermissionKit represents a significant advancement in child safety for iOS apps. By providing a standardized, Messages-integrated permission system, it removes technical barriers while ensuring consistent user experiences across the platform.