Vai al contenuto

Linee guida di revisione IAP di Android Play Store

GitHub

Ottenere l'approvazione della tua app Android su Google Play richiede il rispetto delle policy di Google, in particolare per le app con acquisti in-app e abbonamenti. Questa guida copre tutto ciò che serve per superare la revisione con successo.

Percorso di rilascio che funziona

Sezione intitolata “Release Path That Works”
  1. Crea un Android App Bundle firmato

    Le nuove app su Google Play devono essere caricate come Android App Bundle (.aab), non come APK di debug installato manualmente.

    Mantieni il tuo versionCode in aumento a ogni upload e conserva in sicurezza la chiave di upload se usi Play App Signing.

    Flusso Android App Bundle

  2. Crea il record dell'app in Play Console

    Se non hai ancora un account sviluppatore, inizia con Registrazione Play Console. Poi, in Home > Crea app, scegli la lingua, il tipo di app/gioco, lo stato gratuito/pagato, l'email di supporto e accetta le dichiarazioni obbligatorie.

    Scegli con attenzione l'impostazione gratuito/pagato. Google ti permette di passare da un'app pagata a una gratuita in seguito, ma una volta resa gratuita, un'app non può più essere convertita in pagata.

    Crea app in Play Console

  3. Completa i contenuti dell'app e la scheda store

    Prima della revisione in produzione, completa le dichiarazioni obbligatorie di Play Console:

    • Informativa sulla privacy
    • Annunci
    • Accesso alle app
    • Pubblico di riferimento e contenuti
    • Classificazione dei contenuti
    • Sicurezza dei dati
    • Dichiarazioni di permessi sensibili, se applicabile
  4. Esegui una traccia di test installata da Play

    Inizia con test interno per QA rapidi. Se il tuo account sviluppatore è un account personale creato dopo il 13 novembre 2023, devi anche completare un test chiuso con almeno 12 tester iscritti per 14 giorni consecutivi prima dell'accesso alla produzione.

    Test interno in Play Console

  5. Verifica del billing end-to-end

    Installa l'app da Google Play, non da un APK esportato localmente. Poi verifica che:

    • I prodotti vengano caricati correttamente da Play
    • Il pannello di acquisto mostra un acquisto di prova banner per i tester della licenza
    • Gli Entitlements si sbloccano dopo l'acquisto
    • I flussi di ripristino e gestione degli abbonamenti funzionano

Per i beni e i servizi digitali, devi devi usare il sistema di fatturazione di Google Play:

Beni digitali (Play Billing obbligatorio):

  • Abbonamenti a funzionalità premium
  • Valuta in-app o crediti
  • Contenuti digitali (ebook, musica, video)
  • Upgrade e power-up nei giochi
  • Sblocco app e livelli premium

Beni fisici (Play Billing non consentito):

  • Merchandising fisico
  • Servizi nel mondo reale
  • Donazioni una tantum a no-profit

:::note Configurazione abbonamenti In Play Console, configura gli abbonamenti Android usando l'attuale abbonamento -> piano base -> offerta model. In native-purchases, passa l'ID del piano base con planIdentifier. :::

import { NativePurchases, PURCHASE_TYPE } from '@capgo/native-purchases';
// Ensure billing is available on the device
const { isBillingSupported } = await NativePurchases.isBillingSupported();
if (!isBillingSupported) throw new Error('Google Play Billing not available');
// Fetch subscription products (Store data is required—never hardcode pricing)
const { products } = await NativePurchases.getProducts({
productIdentifiers: ['premium_monthly', 'premium_yearly'],
productType: PURCHASE_TYPE.SUBS,
});
// Plan identifiers are the Base Plan IDs you create in Google Play Console
const transaction = await NativePurchases.purchaseProduct({
productIdentifier: 'premium_monthly',
planIdentifier: 'monthly-plan', // REQUIRED on Android, ignored on iOS
productType: PURCHASE_TYPE.SUBS,
});
console.log('Purchase token for server validation:', transaction.purchaseToken);

Google Play richiede una chiara divulgazione di tutti i costi prima dell'acquisto:

Elementi obbligatori:

  • Prezzo esatto nella valuta locale dell'utente
  • Frequenza di fatturazione (mensile, annuale, ecc.)
  • Cosa è incluso nell'abbonamento
  • Costo totale per le offerte introduttive
  • Quando verranno addebitati i costi

Best practice per il design UI

Esempio di UI conforme:

function SubscriptionCard({ product }) {
return (
<div className="subscription-card">
<h3>{product.title}</h3>
{/* Show intro offer if available */}
{product.introductoryPrice && (
<div className="intro-offer">
<p className="intro-price">{product.introductoryPriceString}</p>
<p className="intro-period">
for {product.introductoryPricePeriod}
</p>
</div>
)}
{/* Regular price */}
<div className="regular-price">
<p className="price">{product.priceString}</p>
<p className="period">per {product.subscriptionPeriod}</p>
</div>
{/* Clear description */}
<p>{product.description}</p>
{/* Renewal terms */}
<p className="terms">
Renews automatically. Cancel anytime in Google Play.
</p>
<button onClick={() => handlePurchase(product)}>
Subscribe Now
</button>
</div>
);
}

Prima che un abbonamento si rinnovi automaticamente, Google richiede:

  • Notifica chiara che il rinnovo avverrà
  • Promemoria del prezzo
  • Accesso semplice alla disdetta

Se vendi la stessa entitlement su più piattaforme, mantieni allineati il nome del prodotto, il periodo di fatturazione, i benefici inclusi e la lingua relativa al rinnovo, in modo che gli utenti non siano sorpresi.

I prezzi possono legittimamente variare a causa di tasse, valuta locale o dinamiche del store, ma l'interfaccia di acquisto non deve mai nascondere queste differenze né implicare un costo di rinnovo diverso da quello che Google Play addebiterà.

Se la tua app include acquisti in-app, devi:

  1. Link nella scheda del Play Store

    • Aggiungere l'URL della privacy policy nella Play Console
    • Deve essere accessibile pubblicamente
    • Deve essere nella stessa lingua della tua app
  2. Link all'interno dell'app

    • Mostrare la privacy policy nelle impostazioni dell'app
    • Visualizzarla prima di raccogliere dati utente
    • Renderla facilmente reperibile

Esempio di implementazione:

function SettingsScreen() {
const openPrivacyPolicy = () => {
window.open('https://yourapp.com/privacy', '_blank');
};
const openTerms = () => {
window.open('https://yourapp.com/terms', '_blank');
};
return (
<div>
<h2>Settings</h2>
<button onClick={openPrivacyPolicy}>
Privacy Policy
</button>
<button onClick={openTerms}>
Terms of Service
</button>
<button onClick={() => NativePurchases.manageSubscriptions()}>
Manage Subscriptions
</button>
</div>
);
}

Google Play richiede una disclosure dettagliata nella sezione Sicurezza dei dati:

Per le app con IAP, dichiara:

  • Raccolta della cronologia acquisti
  • Indirizzi email (per le ricevute)
  • ID dispositivo (per la prevenzione delle frodi)
  • Gestione delle informazioni di pagamento
  • Raccolta di dati analitici

La sezione Sicurezza dei dati ha valore legale. Dichiarazioni inaccurate possono portare alla rimozione dell'app.

La revisione di Google Play non riguarda solo il binario. Prima di un rilascio in produzione, completa le dichiarazioni su Norme e programmi > Contenuti dell'app.

Elementi minimi da rivedere con attenzione:

  • Informativa sulla privacy: URL pubblico in Play Console e punto di accesso in-app se richiesto
  • Annunci: Dichiarare se l'app contiene annunci
  • Accesso alle app: Fornire ai revisori credenziali funzionanti o un percorso di test chiaro se alcune schermate sono protette
  • Pubblico di riferimento e contenuti: Rispecchiare il pubblico reale dell'app
  • Classificazione dei contenuti: Completare il questionario IARC per evitare che l'app risulti senza classificazione
  • Sicurezza dei dati: Dichiarare con precisione pratiche di raccolta, condivisione e sicurezza

1. Implementazione della fatturazione mancante o errata

Sezione intitolata “1. Implementazione dei pagamenti mancante o errata”

Perché viene rifiutato:

  • Non usare Google Play Billing per i beni digitali
  • Utilizzo di API di billing deprecate
  • Implementazione di soluzioni di pagamento custom per gli abbonamenti

Prevenzione:

// ✅ Correct: Use native-purchases (uses Google Play Billing)
await NativePurchases.purchaseProduct({
productIdentifier: 'premium_monthly',
planIdentifier: 'monthly-plan',
productType: PURCHASE_TYPE.SUBS,
});
// ❌ Wrong: Custom payment processor for subscriptions
// await CustomPayment.charge(user, 9.99);

Perché viene rifiutato:

  • Prezzo mostrato solo dopo il click su Acquista
  • Costi aggiuntivi non comunicati in anticipo
  • Termini di abbonamento poco chiari

Prevenzione:

function PurchaseScreen({ product }) {
return (
<div>
{/* Show ALL costs upfront */}
<h2>Premium Subscription</h2>
<div className="pricing">
<p className="price">{product.priceString}/month</p>
<p className="taxes">Taxes may apply based on location</p>
</div>
<div className="features">
<h3>Includes:</h3>
<ul>
<li>Ad-free experience</li>
<li>Unlimited cloud storage</li>
<li>Priority support</li>
</ul>
</div>
<div className="terms">
<p>
Subscription renews automatically unless cancelled at least
24 hours before the end of the current period.
</p>
<p>
Manage or cancel in Google Play Subscriptions.
</p>
</div>
<button onClick={handlePurchase}>
Start Subscription
</button>
</div>
);
}

3. Pattern di abbonamento ingannevoli

Sezione: “3. Pattern di abbonamento ingannevoli”

Perché viene rifiutato:

  • Preselezionare le opzioni premium
  • Nascondere le alternative più economiche
  • Rendere difficile la disdetta
  • Falsa urgenza (“Solo 3 posti rimasti!”)

Best practice per la descrizione

Linee guida di marketing

Prevenzione:

  • Mostra tutti i piani di abbonamento allo stesso modo
  • Rendi il recesso chiaro e accessibile
  • Evita timer di conto alla rovescia o scarsità fittizia
  • Non usare dark pattern per spingere opzioni costose

Perché viene rifiutato:

  • L'app si blocca durante l'acquisto
  • I prodotti non vengono caricati
  • La conferma dell'acquisto non viene visualizzata
  • Le funzionalità premium non si sbloccano dopo l'acquisto
  • I test sono stati eseguiti solo su build sideloaded, non su una track di test installata da Play

Prevenzione:

import { NativePurchases, PURCHASE_TYPE } from '@capgo/native-purchases';
// Comprehensive testing before submission
async function testPurchaseFlow() {
try {
// 1. Test product loading
const { products } = await NativePurchases.getProducts({
productIdentifiers: ['premium_monthly', 'premium_yearly'],
productType: PURCHASE_TYPE.SUBS,
});
console.log('✓ Products loaded:', products.length);
// 2. Test purchase flow
const transaction = await NativePurchases.purchaseProduct({
productIdentifier: 'premium_monthly',
planIdentifier: 'monthly-plan',
productType: PURCHASE_TYPE.SUBS,
});
console.log('✓ Purchase completed', transaction.transactionId);
// 3. Verify entitlements
const { purchases } = await NativePurchases.getPurchases({
productType: PURCHASE_TYPE.SUBS,
});
if (
purchases.some(
(purchase) =>
purchase.productIdentifier === 'premium_monthly' &&
['PURCHASED', '1'].includes(purchase.purchaseState ?? '') &&
purchase.isAcknowledged,
)
) {
console.log('✓ Premium features unlocked');
}
// 4. Test restore
await NativePurchases.restorePurchases();
console.log('✓ Restore works');
} catch (error) {
console.error('✗ Test failed:', error);
}
}

Perché viene rifiutato:

  • Link alla privacy policy assente nell'app
  • Privacy policy non accessibile
  • Raccolta dati non dichiarata
  • Sezione Data Safety inaccurata

Prevenzione:

  • Aggiungi la privacy policy alla scheda del Play Store
  • Includi il link nelle impostazioni dell'app
  • Compila correttamente la sezione Data Safety
  • Aggiorna la policy quando aggiungi nuove raccolte dati

I programmi di fatturazione alternativi di Google sono specifici per regione e possono cambiare. Se vuoi qualcosa di diverso dal Google Play Billing standard, verifica subito prima dell'implementazione l'idoneità esatta del mercato, le API richieste e il testo di disclosure in Play Console.

Gli utenti devono poter:

  • Visualizzare facilmente gli abbonamenti attivi
  • Cancellare senza contattare il supporto
  • Capire quando la cancellazione diventa effettiva

Implementazione:

import { NativePurchases } from '@capgo/native-purchases';
function ManageSubscriptionButton() {
const openManagement = async () => {
try {
// Opens Google Play subscription management
await NativePurchases.manageSubscriptions();
} catch (error) {
// Fallback to direct URL
const playStoreUrl = 'https://play.google.com/store/account/subscriptions';
window.open(playStoreUrl, '_blank');
}
};
return (
<button onClick={openManagement}>
Manage Subscription in Google Play
</button>
);
}

Informazione obbligatoria:

  • Quando diventa effettiva la cancellazione?
  • Do users keep access until period ends?
  • Sono disponibili rimborsi parziali?
function CancellationInfo() {
return (
<div className="cancellation-info">
<h3>Cancellation Policy</h3>
<ul>
<li>Cancel anytime in Google Play</li>
<li>Access continues until end of billing period</li>
<li>No refunds for partial periods</li>
<li>Resubscribe anytime to regain access</li>
</ul>
<button onClick={() => NativePurchases.manageSubscriptions()}>
Manage in Google Play
</button>
</div>
);
}

Checklist pre-invio

  1. Verifica l'implementazione del billing

    • Utilizzo di Google Play Billing (tramite native-purchases)
    • Tutti i prodotti in abbonamento creati su Play Console
    • Piani base e offerte configurati correttamente
    • Prodotti attivati e pubblicati
    • Prezzi impostati per tutti i paesi target
  2. Test dei flussi di acquisto

    • Crea un account di test della licenza
    • Installa la build da un canale di test di Play
    • Testa ogni livello di abbonamento
    • Verifica che i prodotti vengano caricati correttamente
    • Testa il completamento dell'acquisto
    • Conferma che il acquisto di prova banner venga visualizzato
    • Verifica che le funzionalità premium vengano sbloccate
    • Testa il ripristino dell'abbonamento
    • Testa su più dispositivi
  3. Rivedi tutti i testi

    • Prezzi visualizzati chiaramente prima dell'acquisto
    • Tutte le commissioni divulgate in anticipo
    • Termini di abbonamento chiari
    • Procedura di cancellazione spiegata
    • Nessuna dichiarazione fuorviante
  4. Contenuti e privacy dell'app

    • Informativa sulla privacy collegata in Play Console
    • Informativa sulla privacy accessibile nell'app
    • Dichiarazione sulla pubblicità completata
    • Istruzioni di accesso aggiunte se l'app è protetta
    • Sezione Data Safety compilata correttamente
    • Permessi giustificati e documentati
  5. Classificazione dei contenuti e pubblico

    • Completa il questionario sulla classificazione
    • Completa la sezione Pubblico di destinazione e contenuti
    • Assicura valutazione coerente con i contenuti
    • Dichiara gli acquisti in-app nel questionario
  6. Prepara la scheda del Play Store

    • Descrizione dell'app corretta
    • La descrizione breve non supera gli 80 caratteri
    • La descrizione completa non supera i 4000 caratteri
    • Almeno 2 screenshot del telefono caricati
    • Feature graphic 1024x500 caricata
    • Gli screenshot mostrano la versione corrente
    • Tutti gli asset richiesti caricati

Accesso alla produzione per i nuovi account personali: Solitamente 7 giorni o meno dopo la richiesta Prima revisione in produzione: Spesso diversi giorni, a volte di più se emergono dubbi su fatturazione o policy Aggiornamenti: Spesso più veloci di una prima release, ma comunque revisionati Ricorsi: Prevedi diversi giorni e fornisci fix precisi e istruzioni per i revisori

:::tip Revisioni continue A differenza di Apple, Google revisiona le app in modo continuo. La tua app può andare online in qualsiasi momento durante il periodo di revisione, non a un orario fisso. :::

  1. Aggiungi account di test:

    • Vai a Play Console
    • Impostazioni > Test della licenza
    • Aggiungi account Gmail per i test
  2. Test in Sandbox:

import { NativePurchases, PURCHASE_TYPE } from '@capgo/native-purchases';
// Test purchases with license test account
async function testInSandbox() {
const { isBillingSupported } = await NativePurchases.isBillingSupported();
if (!isBillingSupported) {
console.error('Billing not supported in this environment');
return;
}
// Fetch products (returns test pricing when using a license tester)
const { products } = await NativePurchases.getProducts({
productIdentifiers: ['premium_monthly'],
productType: PURCHASE_TYPE.SUBS,
});
console.log('Test products:', products);
// Make test purchase (no charge)
const transaction = await NativePurchases.purchaseProduct({
productIdentifier: 'premium_monthly',
planIdentifier: 'monthly-plan',
productType: PURCHASE_TYPE.SUBS,
});
console.log('Test purchase complete:', transaction.transactionId);
}
  1. Verifica banner di test:
    • Quando acquisti con un account di test
    • Dovresti vedere la notifica “Acquisto di test”
    • Nessun addebito reale

Prima del rilascio in produzione:

  1. Crea un test interno track per QA rapida o un test chiuso track per test più ampi
  2. Carica un file firmato .aab e pubblica il rilascio di test
  3. Aggiungi gli indirizzi email dei tester e condividi il link di opt-in
  4. Fai installare ai tester la build da Google Play
  5. Verifica i flussi di acquisto end-to-end sulla build installata da Play Store
  6. Se il tuo account sviluppatore personale è stato creato dopo il 13 novembre 2023, mantieni almeno 12 tester iscritti a un test chiuso per 14 giorni consecutivi prima di richiedere l'accesso alla produzione

Una build di debug sideloadata non sostituisce una build di test installata tramite Play per la validazione di Google Play Billing.

import { NativePurchases, PURCHASE_TYPE } from '@capgo/native-purchases';
async function handlePurchase(productId: string, planIdentifier?: string) {
try {
setLoading(true);
const transaction = await NativePurchases.purchaseProduct({
productIdentifier: productId,
planIdentifier,
productType: planIdentifier ? PURCHASE_TYPE.SUBS : PURCHASE_TYPE.INAPP,
});
console.log('Purchase token:', transaction.purchaseToken ?? transaction.receipt);
// Success - check entitlements from the store
const { purchases } = await NativePurchases.getPurchases({
productType: planIdentifier ? PURCHASE_TYPE.SUBS : PURCHASE_TYPE.INAPP,
});
const isOwned = purchases.some(
(purchase) =>
purchase.productIdentifier === productId &&
(purchase.purchaseState === 'PURCHASED' || purchase.purchaseState === '1') &&
purchase.isAcknowledged,
);
if (isOwned) {
unlockPremiumFeatures();
showSuccess('Premium activated!');
}
} catch (error: any) {
// Handle specific error cases
switch (error.code) {
case 'USER_CANCELLED':
// User backed out - no error needed
console.log('Purchase cancelled');
break;
case 'ITEM_ALREADY_OWNED':
// They already own it - restore instead
showInfo('You already own this! Restoring...');
await NativePurchases.restorePurchases();
break;
case 'ITEM_UNAVAILABLE':
showError('This subscription is currently unavailable. Please try again later.');
break;
case 'NETWORK_ERROR':
showError('Network error. Please check your connection and try again.');
break;
default:
showError('Purchase failed. Please try again.');
console.error('Purchase error:', error);
}
} finally {
setLoading(false);
}
}
import { NativePurchases, PURCHASE_TYPE } from '@capgo/native-purchases';
function RestorePurchasesButton() {
const [loading, setLoading] = useState(false);
const handleRestore = async () => {
setLoading(true);
try {
await NativePurchases.restorePurchases();
const { purchases } = await NativePurchases.getPurchases({
productType: PURCHASE_TYPE.SUBS,
});
const hasSubscription = purchases.some(
(purchase) => purchase.productType === 'subs' && purchase.isAcknowledged,
);
if (hasSubscription) {
unlockPremiumFeatures();
showSuccess('Subscriptions restored!');
return;
}
// Check one-time unlocks if needed
const { purchases: iaps } = await NativePurchases.getPurchases({
productType: PURCHASE_TYPE.INAPP,
});
const hasInApp = iaps.some((purchase) => purchase.productIdentifier === 'premium_unlock');
if (hasInApp) {
unlockPremiumFeatures();
showSuccess('Previous purchases restored!');
return;
}
showInfo('No previous purchases found.');
} catch (error) {
showError('Failed to restore purchases. Please try again.');
} finally {
setLoading(false);
}
};
return (
<button onClick={handleRestore} disabled={loading}>
{loading ? 'Restoring...' : 'Restore Purchases'}
</button>
);
}
import { NativePurchases, PURCHASE_TYPE } from '@capgo/native-purchases';
async function checkSubscriptionStatus() {
try {
const { purchases } = await NativePurchases.getPurchases({
productType: PURCHASE_TYPE.SUBS,
});
const subscription = purchases.find(
(purchase) =>
purchase.productIdentifier === 'premium_monthly' &&
(purchase.purchaseState === 'PURCHASED' || purchase.purchaseState === '1') &&
purchase.isAcknowledged,
);
if (!subscription) {
showPaywall();
return;
}
console.log('Subscription active:', {
productId: subscription.productIdentifier,
expiresAt: subscription.expirationDate,
willRenew: subscription.willCancel === false,
purchaseToken: subscription.purchaseToken,
});
unlockPremiumFeatures();
} catch (error) {
console.error('Failed to check subscription:', error);
}
}

Policy sui pagamenti:

  • Mancato utilizzo di Google Play Billing
  • Termini di abbonamento fuorvianti
  • Costi nascosti

Policy sui dati utente:

  • Privacy policy mancante
  • Dichiarazioni Data Safety inaccurate
  • Permessi eccessivi
  1. Esamina la notifica di violazione

    • Leggi la specifica policy citata
    • Comprendi cosa ha segnalato Google
    • Controlla gli esempi forniti
  2. Correggi il problema

    • Affronta la causa principale, non solo i sintomi
    • Testa accuratamente dopo la correzione
    • Documenta tutte le modifiche apportate
  3. Invia ricorso (se applicabile)

    Processo di chiarimento e ricorso

    Subject: Policy Violation Appeal - [App Name]
    Dear Google Play Review Team,
    I have received notification that my app violates [Policy X.Y].
    I have made the following changes to comply:
    1. [Specific change made]
    2. [Specific change made]
    3. [Specific change made]
    The updated version [version number] addresses all concerns raised.
    Test account for verification:
    Email: test@example.com
    Password: TestPass123
    Thank you for your consideration.

    Esempio di documentazione richiesta

  4. Rinvia o aggiorna

    • Carica la versione corretta
    • Rinvia per la revisione
    • Monitora lo stato in Play Console

Navigare nella revisione di Play Store può essere complesso, soprattutto quando devi combinare la conformità al billing, le dichiarazioni sui contenuti dell'app e la configurazione della track di test. Se hai bisogno di assistenza personalizzata:

Prenota una call di consulenza con il nostro team per assistenza su:

  • Preparazione completa alla revisione di Play Store
  • Configurazione della track di test e reclutamento dei tester
  • Revisione dell'implementazione IAP
  • Conformità alla sicurezza dei dati e alla privacy
  • Risoluzione dei problemi di rifiuto e appelli
  • Processo completo di invio dell'app

I nostri esperti hanno guidato centinaia di app verso un successo su Play Store e possono aiutarti a navigare i requisiti attuali.

Hai bisogno di aiuto con l'implementazione?

Continua dalle linee guida di revisione IAP di Android Play Store

Sezione intitolata “Continua dalle linee guida Android Play Store Review per IAP”

Se stai usando Linee guida di revisione IAP di Android Play Store per pianificare sicurezza e compliance, collegalo a Utilizzo di @capgo/native-purchases per la funzionalità nativa in Utilizzo di @capgo/native-purchases, Crittografia per i dettagli di implementazione della crittografia, Conformità per i dettagli di implementazione in Compliance, Security Scanner di Capgo per il workflow di prodotto in Capgo Security Scanner, e Sicurezza Capgo per il workflow di prodotto in Capgo Security.