Integration of AR Advertising Formats in Mobile Apps

AR advertising is 3-5 times better than static banners for user engagement when implemented correctly. Problem: load time of AR content on older devices kills conversion. We integrate such formats turnkey: from choosing the stack to publishing in App Store and Google Play. Below is the technical implementation of three main formats and optimization techniques to prevent lag.

Why AR advertising outperforms static banners?

Place-in-room AR gives 3x more engagement time (average 12 seconds) than face tracking (average 4 seconds) based on our data from 30 projects. Meanwhile, 70% of users who interact with an AR object for more than 5 seconds reach the CTA. This is 2x higher than regular video banners. Refer to Apple's ARKit documentation for details on plane detection algorithms.

Three main formats and their implementation

Place-in-Room: AR object in user's interior

The user points the camera at the floor or table — sneakers, a sofa, a TV appear in the room. The most common format for e-commerce.

Stack: ARKit + RealityKit or SceneKit. Models in USDZ (iOS) or GLB (Android + Sceneform / model-viewer). Integration with ad SDKs:

• Meta Audience Network supports AR ad units via Spark AR platform — ready effects are embedded via WebAR or through SDK
• Google AR Ads via Google Web Designer + model-viewer on WebAR
• Custom implementation via ARKit/ARCore without ad SDK — full control, but no built-in analytics

Handling occlusion and lighting estimation is crucial for realistic placement. We use spatial mapping to ensure objects sit on surfaces, and baked lighting for performance. To reduce initialization time, we show an animated overlay "Point at a flat surface" during plane detection, cutting time from 3-6 seconds to 2 seconds.

How does Face AR work?

Glasses, hats, makeup, masks. ARKit Face Tracking using ARFaceTrackingConfiguration:

let config = ARFaceTrackingConfiguration()
config.isLightEstimationEnabled = true
arView.session.run(config)

ARFaceAnchor provides 52 blend shape coefficients — facial expressions, blinking, mouth movement. Glasses are overlaid on ARFaceAnchor.transform, taking face geometry into account for correct fit on the nose bridge. Refer to Apple's ARKit Face Tracking documentation for more details.

Face tracking problem: it only works on devices with TrueDepth camera (iPhone X+). On non-TrueDepth devices, we use Vision Framework + face landmark detection — lower accuracy but broader reach.

Marker-based AR: activating ads through a physical object

Point the camera at product packaging or a printed banner — a 3D animation or video appears. ARImageTrackingConfiguration with ARReferenceImage:

let referenceImages = ARReferenceImage.referenceImages(inGroupNamed: "AdMarkers", bundle: nil)
config.trackingImages = referenceImages
config.maximumNumberOfTrackedImages = 3

The marker image must have high uniqueness (histogramContrastScore > 0.85 according to ARKit's internal metric). Packaging with large uniform areas (white boxes, minimalistic design) — perform poorly. Textured markers with good contrast are required.

Analytics of AR advertising

Standard ad analytics (impression, click) for AR are supplemented by specific metrics:

Firebase Analytics + custom events — the standard approach. We send events ar_session_started, ar_object_placed, ar_interaction, ar_cta_tapped with parameters (ad_id, placement_id, duration).

How to optimize AR models for fast loading?

Size of AR resources is the bottleneck. A USDZ model for place-in-room should not exceed 10–15 MB. Optimization:

1. Texture compression via TextureConverter — up to 80% without quality loss.
2. LOD with 3 levels of detail: high (close), medium (3-6 m), low (farther than 6 m).
3. Baked lighting instead of PBR realtime — saves 30% of render time.
4. Fallback for weak devices: if ARWorldTrackingConfiguration.isSupported = false — show a 2D/3D rotating object.

Additional techniques: normal maps for detail without high polygon count, texture atlas to reduce draw calls. For SLAM-based tracking, we fine-tune sensor fusion parameters to improve stability on devices with gyroscope drift.

How we implement AR advertising?

The process includes stages:

1. Analysis of target devices and OS versions.
2. Designing the AR scenario.
3. Preparation of 3D models (optimization, LOD).
4. Integration via ARKit/ARCore or ad SDKs.
5. Setting up analytics (Firebase custom events).
6. Testing on 10+ devices (iPhone 7, iPhone X, Samsung Galaxy S10, Pixel 4).
7. Publishing in stores.

At each stage, we record loading and engagement metrics. Average time to display AR scene is 2.1 seconds on iPhone X.

What is included in the work

Deliverables

• Documentation: description of the AR scenario, analytics scheme, instructions for updating models
• Access to ad accounts (Meta, Google) or custom SDK
• Training of the client's team in working with AR content
• Technical support for 1 month after launch

Typical budget ranges from $3,000 for a simple face filter to $20,000 for a full AR SDK suite with analytics and custom models.

Timelines

Cost is calculated individually. It is important to understand the target devices and required ad formats before starting. We guarantee compatibility with major iOS and Android versions, are certified for ARKit and ARCore, have 5 years of experience and 30+ completed projects. Request a consultation to choose the AR format for your tasks. Contact us — we will select the optimal stack and timelines.

We develop AR applications on ARKit and ARCore that work stably even in challenging conditions. Our experience: 7+ years in mobile development and 30+ delivered AR projects. Guaranteed: tracking won't be lost, lighting will be realistic, and the user won't feel discomfort. Certified Apple and Google developers.

Why does tracking get lost and how to fix it?

ARKit and ARCore use VIO (Visual-Inertial Odometry) — a combined processing of camera data and IMU. Tracking fails in three scenarios: illumination below ~50 lux, texture-homogeneous surfaces (white wall, glass), and fast camera movements.

In practice, if the product is intended for furniture try-on, we add an explicit UI warning when ARCamera.TrackingState.limited(.insufficientFeatures). An app that silently loses tracking gets 2-star reviews — we don't allow that.

Plane detection is configured via ARWorldTrackingConfiguration.planeDetection = [.horizontal, .vertical]. Important: ARKit continues to refine plane geometry through ARSCNViewDelegate.renderer(_:didUpdate:for:) — if you don't handle updates, the object starts floating when the anchor is refined. Our team solves this at the architecture stage, not during testing.

AR Foundation: cross-platform with nuances

Unity AR Foundation is an abstraction layer over ARKit and ARCore. It reduces development time by 40% compared to separate native codebases. But some features (e.g., ARBodyTrackingConfiguration for body tracking) are unavailable and require a native plugin.

For React Native and Flutter, direct AR Foundation is missing. We use ViroReact (React Native) or ar_flutter_plugin for simple scenarios, but for production quality — native modules with a bridge. Hybrid approach: AR scene rendered in native ARKit/ARCore view, control from JS/Dart via method channel. Included in our standard delivery.

Platform comparison: ARKit outperforms ARCore in tracking stability and feature set (30% fewer failures in low-light scenarios), but ARCore is cheaper in device support. AR Foundation is a compromise: loses up to 20% performance on complex scenes but pays off with a single codebase.

Try-on: product fitting via AR

Fitting glasses, jewelry, cosmetics — a separate class of tasks. Here, face tracking is needed, not plane detection.

ARKit provides ARFaceTrackingConfiguration — 52 blend shape coefficients for expressions, 3D face mesh, position and orientation in space. Works only on devices with TrueDepth camera (iPhone with Face ID).

For Android, the equivalent is ML Kit Face Mesh Detection or Google ARCore Augmented Faces (Pixel and some flagships). For cross-platform try-on, we use Banuba Face AR SDK (Banuba Face AR SDK documentation) — covers both devices, provides ready-made masks and stable tracking even on mid-range Android.

Try-on quality critically depends on 3D product models. Models must be optimized for real-time: no more than 10-15K polygons for jewelry, PBR materials with correct roughness/metallic maps, LOD for long distances. Within our engagement, we provide ready-made optimization guides.

How to achieve realistic lighting in AR?

ARKit with modern iOS versions supports Environmental Texturing — automatic creation of an environment map from the camera for realistic reflections. Enabled via ARWorldTrackingConfiguration.environmentTexturing = .automatic. Without it, metallic and glass materials look plastic.

ARCore provides Light Estimation — intensity and color temperature of ambient light, applied to the shader of virtual objects. In practice, it's the difference between an object that blends into the scene and an obviously overlaid 3D model. We guarantee that the final image doesn't betray virtuality.

What's included

• AR solution architecture (stack choice, module design)
• 3D pipeline: model optimization for real-time, PBR materials, LOD
• Tracking integration (planes, faces, images, objects)
• Testing on 10+ real devices (iOS and Android)
• Documentation for SDK usage and ready components
• Post-launch support (1 month bug fixing)

Timeline and estimation

Simple AR scene with placing one 3D model on a plane — 1-2 weeks. Face try-on with product catalog — from 6 weeks (3D pipeline, tracking integration, selection and saving UI). Full AR shopping with cloud anchors and multiplayer — from 3 months. We'll estimate your project in 1 day — contact us to discuss your AR idea.