page.title=Flexible Monetizing and Business Tools
page.metaDescription=

@jd:body
   
<div style="float:right;margin-left:18px;padding:1.5em;">
<img src="{@docRoot}images/gp-details-ww.png" style="width:180px">
<img src="{@docRoot}images/gp-details-ww-purchase.png" style="width:180px">
</div>
    
<p>Sell your app in more than 130 countries. Flexible monetization options with
in-app purchase, subscriptions, and more. </p>

<h2>Streamlined purchase flow for users</h2>

<p>When users find your app, they can purchase it instantly with a streamlined,
consistent purchasing process and convenient payment methods.</p>

<h3>Instant purchase from device or web</h3>

<p>Google Play makes it fast and easy for your customers to buy your products,
whether from a phone, a tablet, or a desktop computer. When users find an app or
game that they want to buy, they can purchase it in as few as two steps&mdash;one
to initiate the purchase and another to accept purchase details and permissions
and complete the transaction.</p>

<p>Google Play's convenient purchase experience is the same familiar process for
all products everywhere across Google Play&mdash;apps, games, in-app products and
subscriptions, and other digital content.</p>

<h3 id="cloud-connected-purchase">Cloud-connected</h3>

<p>Purchasing is even more convenient on Google Play because it’s
cloud-connected. Users can find and purchase your products from anywhere&mdash;from
their Android phones or using any web browser on any host computer. </p>

<p>When users find an app or game they want to buy, they purchase it and download
it instantly to their devices over-the-air. Users who sign in to the Google Play web site can also buy apps and games
and push them instantly to their phones, tablets, or other devices. Google Play
manages the application download.</p>

<h3 id="payment-methods">Convenient payment options</h3>

<p>Users can purchase your products on Google Play using several convenient
payment methods&mdash;credit cards, Direct Carrier Billing, and Google Play balance..</p>

<p><span style="font-weight:500">Credit card</span> is the most common method of payment. Users can pay using any credit card
that they’ve registered in Google Play. To make it easy for users to get started,
registration is offered as a part of initial device setup process.</p>

<div class="sidebox-wrapper" style="float:right;">
<div class="sidebox">
<h2>Payment methods on Google Play</h2>
<ul>
<li>Credit Card</li>
<li>Direct Carrier Billing</li>
<li>Google Play balance (stored value)</li>
</ul>
</div>
</div>

<p>Subscribers on many popular carrier networks worldwide can charge purchases
to their monthly mobile phone bills through <span style="font-weight:500">Direct
Carrier Billing</span>. This form of payment is convenient and simple and is
extremely popular in regions where credit cards are less common. More than 75
million users in key markets around the world can purchase
your products through Direct Carrier Billing. Many more will get the option in
the months ahead.</p>

<p><span style="font-weight:500">Google Play balance</span> is a stored account
balance in Google Play. Users can increase their balance through promotions and
offers in the store, and they can use their balanace to make purchases of apps,
games, or other content. 

<p>The payment methods available to users worldwide may vary, based on
location, carrier network, and other factors.</p>

<div style="float:left;margin-right:2em;margin-top:1em;width:220px;">
<img src="{@docRoot}images/gp-subs.png" style="width:220px">
</div>

<h2 id="billing-models" style="margin-top:1.5em;">Choice of billing models</h2>

<p>Google Play gives you a choice of billing models to let you monetize your
products. </p>

<p>You can offer apps to all users for free, or
you can set an initial price for the app, paid before download. You can also
sell one-time purchases and auto-renewing subscriptions from inside the app, and
you can take advantage of AdMob integration to monetize your app through
targeted advertising.</p>

<div class="sidebox-wrapper">
<div class="sidebox">
<h2>Billing models on Google Play</h2>
<ul>
<li>Free (no charge to download)</li>
<li>Priced (user charged before download)</li>
<li>In-App products and subscriptions</li>
</ul>
</div>
</div>

<p>You can combine these billing models in different ways, based on your business
needs or market conditions. </p>

<p>For example, you can use a freemium or ad-supported model by distributing
your app for free and selling in-app products or advertising. Alternatively you
could set a nominal price for your app at download and sell value add-ons,
gameplay levels, and upgrades as in-app products. The only restriction is that
free apps must remain free (to download) for the life of the app.</p>

<h2 id="buyer-currency" style="margin-top:1.5em;">Flexible pricing in the currencies of your customers</h2>

<div style="float:right;margin-left:18px;border:1px solid #DDD;">
<img src="{@docRoot}images/gp-buyer-currency.png" style="width:240px;padding:4px;margin-bottom:1em;">
</div>

<p>Google Play gives you complete control over how you price your products. You
can set prices in more than 130 countries, for millions of
users around the world. When users browse your app’s product page or initiate a
purchase, Google Play shows them the price they will be charged <em>in
their local currency</em>.</p>

<p>You can set and adjust your prices at any time, in any available currency. 
Your prices in available currencies are independent, so you can adjust one
price without affecting others. This gives you the ability to run
short-term promotions and discounts in specific countries and more easily
manage shifts in exchange rates.</p>

<p>You can set and manage prices for your apps and in-app products from the
Google Play Android Developer Console.</p>

<h2 id="payouts">Monthly payouts in your local currency</h2>

<p>To sell products in Google Play, all you have to do is register for a Google
Checkout merchant account and link it to your Google Play Android Developer
Console account (see <a
href="{@docRoot}distribute/googleplay/publish/register.html">Get Started with
Publishing</a> for details). Once you’ve set up your account and published your
apps, Google Play makes monthly payouts of sales proceeds to your merchant
account, in your local currency.</p>

<h2 id="reporting">Detailed financial reporting</h2>

<p>When you sell priced apps or in-app products on Google Play, you get a
variety of financial reports to help you track and project sales, optimize your
marketing campaigns, and support your customers.</p>

<p>To help you keep up-to-date with the current activity, you can download daily
reports summarizing recent purchases of your products. The reports include
estimated sales amounts and include a variety of other data for each
transaction.</p>

<p>At the close of the month, you can download a complete sales report that
gives you the final details of all transactions that closed in the month,
including the payout amounts and other data. Additional financial reports are
available in your Google Checkout merchant account.</p>
