page.title=Visibility for Your Apps
page.metaDescription=

@jd:body
    
<div style="float:right;margin:0px 0px 24px 0px;">
  <img src="{@docRoot}images/gp-tab.png" style="width:420px" style>
</div>

<p>A billion downloads a month and growing. Get your apps in front of millions
of users at Google's scale. </p>  


<h2 id="reach">Worldwide reach, rapid growth</h2>

<p>Google Play is the premier store for distributing Android apps. It’s
preinstalled on more than 400 million devices worldwide, a number growing by
more than a million every day. Android users have downloaded
more than <strong style="text-wrap:none;">15 billion apps</strong> from Google
Play, growing at a rate of more than 1.5 billion per month.</p>

<p>When you publish on Google Play, you put your apps in front of Android's huge
base of active customers, in more than 130 countries and territories across the
world. </p>

<p>Google Play is a central part of the Android experience. New users
personalize their devices with apps, games, and other Google Play content.
Existing users return regularly to see what's trending and new. Downloading new
apps is extremely convenient and fast&mdash; Google Play pushes  apps to the
user's devices instantly, over the air. No cable or sync is ever needed.</p>

<div style="float:left;margin:0px 20px 0px 0px;width:374px;">
<div  style="width:378px;padding:2px;">
<img src="{@docRoot}images/gp-growth-downloads.png" style="width:600px;margin-bottom:0em;">
</div>
<p class="image-caption" style="padding:.5em"><span
style="font-weight:500;">Growth in app consumption</span>: Users download more than
1.5 billion apps from Google Play each month.</p>
</div>

<div>
<p>Google Play is also a top destination for visitors from the the web. Anyone
with a browser can explore everything that Google Play has to offer from its <a
href="http://play.google.com/store">web site</a>. Android users can even buy and
install the apps they want and Google Play pushes them automatically to their
devices over the air. </p>

<p>The accessiblility and convenience of the Google Play web
site give you new ways to drive traffic to your products from online ads, web
search, cross-linking, and more.</p>
</div>

   <div style="clear:both;">
<h2>Built for app discovery</h2>

<p>Google Play is designed to connect users with great apps and games. It
provides key channels to help your app get noticed and gain traction in the
marketplace.</p>

<h3 id="ratings">User ratings and reviews</h3>

<p>When you develop a great app, Android users show their appreciation through
ratings and reviews. They rate your app (out of 5 stars) after downloading it
and can post a short description of their experience. When other users are
considering your app, they look at the ratings and reviews as key benchmarks of
the app’s quality. </p>

   </div>

<p>Your app’s rating is one of the most important factors influencing its
ranking in the various lists and search results in Google Play. It's also one of
the key signals that the editorial staff looks for, when curating apps and games
for promotion in the store.</p>

<div style="border:1px solid #DDD;padding:1px;margin-left:110px;width:504px;">
<img src="{@docRoot}images/gp-rating-web.png" style="width:500px;padding:0;margin:0;">
</div>

<h3 id="category" stdle="padding-top:2em;">Category browsing</h3>

<p>When you publish an app in Google Play, you pick the category in which you
want users to find your app. More than 30 categories are available. Inside each
category, apps are ranked based on a combination of ratings, reviews, downloads,
country, and other factors. Many popular categories also start with a collection
of featured apps selected by the Google Play editorial staff.</p>

<div style="clear:both;margin-top:2em;margin-left:10%;width:560px;">
<div style="clear:both;margin-top:2em;">
<img src="{@docRoot}images/gpp-cat-feature280-puzzle.png" style="width:180px">
<img src="{@docRoot}images/gpp-cat-feature280-photo.png" style="width:180px">
<img src="{@docRoot}images/gpp-cat-feature280-sports.png" style="width:180px">
</div>
<p class="image-caption"><span style="font-weight:500;">Featuring in
categories</span>: Most app and game categories include a featured list curated
by the editorial team.</p>
</div>

<h3 id="search">Search</h3>

<p>Search on Google Play lets users pinpoint an app or game quickly. Search uses
powerful heuristics to suggest terms as the user types, and it offers direct
links to apps as suggestions. In results, users find the most relevant, most
popular apps at the top. </p>

<div style="float:left;margin:12px 24px 0px 0px;">
<img src="{@docRoot}images/gp-top-new-paid.png" style="width:250px">
</div>

<h3 id="top-charts" style="padding-top:1em">Top charts and lists</h3>

<p>Top charts keep users in touch with what’s popular and trending with Android
users, right from the Apps and Games home pages. The charts are generated
several times each day based on recent download activity, keeping them fresh and
allowing new apps to move upward in the charts. To make the charts as relevant
as possible for users across the world, they are also country-specific.</p>

<p>As your apps get traction and build momentum in downloads and ratings,
they’ll climb one or more of the top charts and gain even more exposure.</p>

<div>
<table style="width:440px">
<tr>
<td style="width:100px">Top Free</td><td>Free apps and games</td></tr>
<td style="width:140px">Top Paid</td><td>Priced apps and games</td></tr>
<td>Top New Free</td><td>Less than 30 days old</td></tr>
<td>Top New Paid</td><td>Less than 30 days old</td></tr>
<td>Top Grossing</td><td>Gross proceeds, free or priced</td></tr>
<td>Best Selling</td><td>Popular priced games</td></tr>
<td>Trending</td><td>New arrivals growing quickly in installs</td>
</tr>
</table>
</div>

<div style="clear:both">
<h4 id="featured" style="padding-top:2.5em;">Featured, Staff Picks, Collections,
and Badges</h4>


<div style="float:right;margin-left:18px;">
<img src="{@docRoot}images/gp-apps-home.png" style="width:180px">
<img src="{@docRoot}images/gp-games-home.png" style="width:180px">
</div>

<p>The Google Play editorial team is dedicated to bringing the best apps to the
attention of users and setting the tone for app quality throughout the store. 
It constantly reviews apps from across Google Play to find
not only the best-known apps and games, but also the “diamonds in the rough” that
they want more people to see. </p>

<p>When the team finds great apps and games, it uses the <em>Featured</em>,
<em>Staff Picks</em>, and other collections to promote them to users.</p>

<p>You can't nominate your app for featuring, but the team is always
on the lookout for great apps through a number of signals and indicators. 
If you build an app that users love and that looks great on Android devices,
the editorial team will notice.</p>
</div>

<h4>Featured and Staff Picks</h4>

<p>Each week the the Google Play editorial staff selects a new set of apps to
promote in its popular <em>Featured</em> and <em>Staff Picks</em> collections.
</p>

The <em>Featured</em> collections highlight the latest and greatest app and game
titles available for Android. Category featuring highlights the best and most
popular apps in the top categories.

<em>Staff Picks</em> collects all recently featured apps and games on Google
Play. To better reach tablet users, there’s a special <em>Staff Picks</em>
collection that highlights the best apps for Android tablets.</p>

<div style="float:left;margin-right:18px;">
<img src="{@docRoot}images/gp-collectibles.png" stydle="width:180px">

</div>

<h4>App collections</h4>

<p>From time to time the editorial staff puts together a collection of apps and
games based on a theme or seasonal event. The collections are popular with
customers because they are timely and relevant, and they provide a new way to
showcase great Android apps to users.</p>

<p>The editorial staff chooses apps for collection promotions in a similar way
as for featuring&mdash;high-quality apps that show the best of Android on phones
and tablets. For collections the staff also looks for apps that can make an
interesting or unique contribution to the collection as a whole. </p>

<h4><img style="margin-right:.25em;margin-bottom:.5em;"
src="{@docRoot}images/editorschoice_ann.png"> EDITORS' CHOICE</h4>

<p><em>Editors’ Choice</em> is a curated collection of apps that highlights some
of the very best apps available on Android. These apps are chosen for high
quality and great UI, long-term popularity, and innovative use of Android
features.</p>

<p>Apps chosen for <em>Editors’ Choice</em> also receive a badge that is
displayed wherever the app name is seen in Google Play.</p>

<h4><img style="margin-right:.25em;margin-bottom:.5em;"
src="{@docRoot}images/topdev_ann.png"> TOP DEVELOPER</h4>

<p>Top Developer is a badge recognizing established, respected developers for
their commitment to launching high-quality and innovative apps on
Android. The Google Play editorial staff selects developers awards a Top
Developer badge from time to time, based on the cumulative work of the
developer.</p>

<p>The Top Developer badge appears next to the developer name wherever it is
displayed in Google Play. For a developer, the badge means long-term recognition
of all of your apps. For users, the badge signifies an additional level of trust
and confidence in your products.</p>

<h3 id="details">Rich, colorful product pages</h3>

<p>In Google Play, your app’s storefront is its <em>product details page</em>
&mdash; a rich and colorful page that lets you promote your app, highlight its
ratings and reviews, and show what your app can do. 

<p>Your product details page is the one page where your users come to find out
everything about your app. When they see your app listed in search results, top
charts, category listings, and collections, one tap takes them directly to your 
product details page.</p>

<div style="float:right;margin-left:10px;">
<img src="{@docRoot}images/gp-details-pages-magicpiano.png" style="width:500px">
</div>

<p>You can manage your product details page through the <span
style="font-weight:500">Google Play Android Develeper Console</span>, from any
web browser. Just sign in, upload or update your brand assets, and enter your
product details in the languages of your markets. </p>

<p>When you publish, Google Play adds your app’s ratings, reviews, links to your
other products, and more, and makes sure your product details page looks great
on phones, tablets, or in a web browser.</p>

<p>You can link web users directly to your product details page from outside
Google Play, such as from your web site, an ad campaign, reviews, social media
posts, and more. See <a href="{@docRoot}distribute/googleplay/promote/linking.html">Linking
to Your Products</a> to find out how. </p>

<p>To learn more about how to create your product details page, see
<a href="{@docRoot}distribute/googleplay/publish/index.html">Publishing on Google Play</a>.</p>
