HTML5 API Documentation

Version 1.9

Current as of 11/14/2011. If you see or have any problems let us know!

Setting up the JavaScript/HTML5 API

Add the JavaScript to your page:

<script type="text/javascript" src="http://api.playtomic.com/js/playtomic.v1.9.min.js"></script>

Or download it: playtomic-html5-1.9.zip, or get it from GitHub

Initialize the API by logging the view

A view occurs when someone loads the game in any way. Begin by registering the view early in your game. You must log the view before anything else to initialize the Playtomic API.

Playtomic.Log.View(gameid, "guid", "apikey", document.location);

Check the API page for your game in the dashboard to get your codes. I'm not sure what options exist for protecting your HTML5 game source but you should try and obfuscate your game credentials.

Analytics

Views

A view occurs whenever somebody views your game. This should go somewhere very early in your code like before the preloader.

Because the View method initializes the entire Playtomic API it has several parameters that must be passed, and it must be called before you can log anything else.

Playtomic.Log.View(gameid, "guid", "apikey", document.location);

Plays

A play occurs when someone begins a game by clicking your play button or whatever action is relevant to your game. A person can get between 0 and many plays during a single view.

They're tracked seperately because the main menu is the first thing the player sees after loading and splash animations, and if they don't like it they'll leave.

Play time, countries and sources

This data is logged automatically when you send other events.

public function ClickedPlayButton()
{
    Playtomic.Log.Play();
            
    // continue starting game
    ...

Freezing, unfreezing and force-sending events

Note: This is inherited from the Flash version which runs on a single thread, and may not be necessary in HTML5 games depending on whether requests are sent truly asynchronously or asynchronously 'on the same thread' as with Flash which will be up to the browser/platform implementation.

Events are sent in batches each time the play timer updates (every 30 seconds after the first minute). If you want to ensure an event gets sent:

Playtomic.Log.ForceSend();

Some games are very resource-intensive and the API might send off a batch of events at exactly the wrong time. You can freeze and unfreeze the logging at any time by:

Playtomic.Log.Freeze();
Playtomic.Log.UnFreeze();

When logging is frozen all events are queued but not sent until you unfreeze the API.

Custom metrics

Custom metrics allow you to track how many people do something in your game, for instance how many play on easy, medium or hard, or how many play in English vs. Spanish, or how many view the tutorial or skip it. Anything you think can help you improve your game.

You can define custom metrics directly in your game and they will be added to Playtomic automatically. Groups can be automatically assigned via an optional second parameter or set up later in the dashboard.

You can also limit custom metrics to unique-per-view occurances with a third parameter.

Playtomic.Log.CustomMetric("ViewedCredits"); // metric, names must be alphanumeric
Playtomic.Log.CustomMetric("Credits", "Screens"); // metric with group, groups must be alphanumeric
Playtomic.Log.CustomMetric("ClickedSponsorsLink", "Links", true); // unique metric with group

Level metrics

Level metrics track events on a per-level basis so you can drill down into your difficulty and retention by identifying which levels have problems and what those problems are.

There are three types of level metrics - counters (like custom metrics), ranged-value and average-value.

Note that you can pass either an integer level number or a string name of the level. If your game is not using numeric levels (eg an escape game) then you would pass the name of each screen / area as a level.

You can define level metrics directly in your game and they will be added to Playtomic automatically.

Level metrics support unique-per-play occurrances via an optional second parameter. If the player starts a new game they will be tracked again.

Counter metrics

These metrics track how many times something occurs in your levels, for instance deaths and restarts.

One of the most valuable pieces of data you can track is how many people begin each level, this allows you to see where you lose players.

Playtomic.Log.LevelCounterMetric("Deaths", level_number); // names must be alphanumeric
Playtomic.Log.LevelCounterMetric("Restarts", "LevelName"); // level names must be alphanumeric
Playtomic.Log.LevelCounterMetric("Restarts", "LevelName", true); // unique only

Average metrics

These metrics track the average of something in your levels, for instance the average time to finish a level or the average number of retries. It also tracks the minimum and maximums.

Playtomic.Log.LevelAverageMetric("Time", level_number, seconds);
Playtomic.Log.LevelAverageMetric("Retries", level_number, retries);
Playtomic.Log.LevelAverageMetric("Retries", level_number, retries, true); // unique only

Ranged-value metrics

These metrics track metrics with values, for instance in a golf game you might track how many shots it takes to complete each level, or you might track the % of coins collected on each level.

Playtomic.Log.LevelRangedMetric("Shots", level_number, shots);
Playtomic.Log.LevelRangedMetric("PercentCoinsCollected", level_number, int(coins / coinstotal * 100));
Playtomic.Log.LevelRangedMetric("Shots", level_number, shots, true); // unique only

Heatmaps

Heatmaps allow you to map activity (clicks, deaths, first deaths, or anything else you want) against an image you upload in the dashboard.

Playtomic.Log.Heatmap("Metric", "Heatmap", x, y);

In the dashboard you upload a background image for the heatmap, and then it is shared by any metrics using it.

Link tracking

Link tracking allows you to keep track of how many people open URLs in your game, providing you information on unique, total and failed clicks that can fully audited to allow you to identify good sources of traffic.

Link tracking does not change your URL or redirect traffic through a different url!

How to track a link

You track a link by passing a URL and some other information to the API. The API will return true or false if the link opens, everything else is automatic.

Playtomic.Link.Open(url, name, group)

Playtomic.Link.Open("http://website.com/", "Website", "MyLinks");

If you do not want the Playtomic API to open the link for you you can open it yourself and:

Playtomic.Link.Track(url, name, group)

Playtomic.Link.Track("http://website.com/", "Website", "MyLinks");

Domain Totals

When you track a link it automatically also tracks the totals for the domain in a group it creates called DomainTotals. The DomainTotals allows you to see how many unique, total and failed clicks occurred for a single domain even if you have multiple, different links to it (eg walkthrough or differently-structured sponsor links).

Parse custom databases

This feature is provided in conjunction with Parse so you will need to create your account with them before you can use it.

Custom databases allow you to store and manipulate any data you want in any way you want, like:

• User registration
• Mailing list (and send through MailChimp)
• Saved games
• Surveys & feedback
• Messaging
• etc

The PFObject

This object represents a piece of data in your database. It has the following properties:

Property	Type	Description
ObjectId	String	If your object already exists in your database it will have this unique identifier.
ClassName	String	The 'type' of data this is - user, score, etc
Data	Object	Your actual data to save, eg po.Data.FirstName
UpdatedAt	Date	When the object was last updated in the database
CreatedAt	Date	When the object was created in the database
Password	String	If an object has a password when it is saved the password must be included to update it.

The PFQuery

This object allows you to construct a query to run against your database to find objects you've saved.

Property	Type	Description
ClassName	String	The 'type' of data to return - user, score, etc
WhereData	Object	Data to filter by, eg pq.WhereData.FirstName = 'ben'
Order	String	What field (from Data) to sort by
Limit	int	Number of results to return

Saving / updating an object

You can save any object you want by creating a PFObject and sending it to Parse.Save. An object will save if it does not have an ObjectId, if it does then it will update.

var po = new Playtomic.PFObject();
po.ClassName = "savedgames";
po.Data.Name = "Ben";
po.Data.Level = "1";
po.Data.Stage = "7";
Playtomic.Parse.Save(po, SaveComplete);

function SaveComplete(po, response)
{
    if(response.Success)
    {
        alert("Saved object: " + po.ObjectId);
    }
    else
    {
        alert("Failed to save: " + response.ErrorMessage);
    }
}

Loading an object

You can load any object as long as you know it's ClassName and ObjectId (which you might obtain from a PFPointer).

var po = new Playtomic.PFObject();
po.ClassName = "savedgames";
po.ObjectID = "asdfasdf";
Playtomic.Parse.Load(po, LoadComplete);

function LoadComplete(po, response)
{
    if(response.Success)
    {
        alert("Loaded object: " + po.ObjectId);
    }
    else
    {
        alert("Failed to load: " + response.ErrorMessage);
    }
}

Finding objects / querying your database

Using the PFQuery object you can locate data in your database:

var pq = new Playtomic.PFQuery();
pq.ClassName = "savedgames";
pq.WhereDate.Name = "Ben";
pq.Limit = 5;

Playtomic.Parse.Find(pq, FindComplete);

function FindComplete(results, response)
{
    if(response.Success)
    {
        alert("Loaded objects");

        for(var i=0; i<results.length; i++)
            alert(results[i].ObjectId);
    }
    else
    {
        alert("Failed to find: " + response.ErrorMessage);
    }
}

Deleting objects

You can delete an object easily:

// po is a PFObject you've previously loaded from somewhere
Playtomic.Parse.Delete(po, DeleteComplete);
            
function DeleteComplete(response)
{
    if(response.Success)
    {
        alert("Deleted object");
    }
    else
    {
        alert("Failed to delete: " + response.ErrorMessage);
    }
}

Level sharing

The level sharing API provides a way to store and retrieve user-generated content for your game. It can operate anonymously or authenticated via any 3rd party service you're already using.

The PlayerLevel object

Saving and listing levels uses this class to represent a level.

Property	Type	Description
PlayerName	String	The name of the player (or "anonymous", "guest", etc), or the name provided by any 3rd party API.
PlayerId	String	If you're working under a 3rd party API you can include the player's user id
PlayerSource	String	If you're working under a 3rd party API you can specify which, eg "gamersafe" or "mochicoins"
Name	String	The name of the level
Data	String	The data for the level. You can Base 64 encode a ByteArray to a string if necessary.
Votes	int	The number of votes the level has
Score	int	The sum of all votes the level has
Plays	int	The number of plays the level has
Rating	int	The rating the level has (score / votes)
SDate	Date	The date of the level, determined automatically by Playtomic
RDate	String	The relative date of the level eg "7 minutes ago", determined automatically by Playtomic
CustomData	Object	Any additional data you want to (or have) attached to a level.
Thumbnail	Func, ret. string	The URL of the thumbnail, unless you generate them from data (recommended)

Saving levels

Playtomic.PlayerLevels.Save(level, callback)

Parameter	Type	Description
level	PlayerLevel	An instance of PlayerLevel holding the level data
callback	Function	Optional function to pass the submission result to

Example saving level:

function SaveLevel()
{
    var level = {};
    level.Name = "My level";
    level.Data = level_data; // level data is a string and can be up to about 3 megabytes
			
    Playtomic.PlayerLevels.Save(level, SaveComplete);
}

function SaveComplete(level, response)
{
    if(response.Success)
    {
        alert("Level saved successfully, the level parameter is ready for use!");
    }
    else
    {
        // failed because of response.ErrorCode
    }
}

Rating levels

Levels can be rated 1 - 10 by players. Rating can be done anonymously with some protection against repeat voting, or bound to PlayerIds if you specify them.

Playtomic.PlayerLevels.Rate(levelid, rating, callback)

Parameter	Type	Description
levelid	String	a_player_level.LevelId
rating	int	1 - 10
callback	Function	Optional function to pass the submission result to

Example rating level:

function Rate()
{
    Playtomic.PlayerLevels.Rate(currentlevel.LevelId, rating_amount, RateComplete);
}

function RateComplete(response)
{
    if(response.Success)
    {
        alert("Rating complete"");
    }
    else
    {
        // Rating failed because of response.ErrorCode
    }
}

Listing levels

Listing levels can be done by popular or newest, with optional filtering by date ranges and/or custom Playtomic.Data.

Playtomic.PlayerLevels.List(callback, options)

Parameter	Type	Description
callback	Function	Function to pass the levels to
options	Object	Optional object which may contain these properties: mode (String): 'popular' or 'newest' datemin (String): 'mm/dd/yyyy' for the minimum date the level was created datemax (String): 'mm/dd/yyyy' for the maximum date the level was created data (Boolean): specify true if you want level data returned with the list customfilters (Object): filter by custom data you've saved with levels page (int): The page you want (default is 1) perpage (int): The number of scores to return (default is 20)

An example listing levels:

function ListLevels()
{
    Playtomic.PlayerLevels.List(ListLoaded, {mode: "newest", customfilters: {difficulty: "hard"}});
}
		
function ListLoaded(levels, numlevels, response)
{
    if(response.Success)
    {
        for(var i=0; i<levels.length; i++)
        {
            alert(" - " + levels[i].LevelId + ": " + levels[i].Name);
        }
    }
    else
    {
        // Level list failed to load because of response.ErrorCode
    }
}

Loading levels

If you do not include the data when you load lists of levels then you can request it seperately:

Playtomic.PlayerLevels.Load(levelid, callback)

Parameter	Type	Description
levelid	String	a_player_level.LevelId
callback	Function	Function to pass the level to

An example loading a single level

function Load()
{
    Playtomic.PlayerLevels.Load(level.LevelId, LoadComplete);
}
		
function LoadComplete(level, response)
{
    if(response.Success)
    {
        trace("Level has been loaded, now you can begin playing it");
    }
    else
    {
        // level failed to load because of response.ErrorCode
    }
}

Leaderboards

The leaderboards API gives you very flexible high and low score leaderboards. They can be created in your game dynamically or set up in the edit leaderboards page.

The PlayerScore object

The leaderboards use the PlayerScore object for representing the players' scores.

Property	Type	Description
Name	String	The player name. This can be by the player or provided by any 3rd party
FBUserId	String	If you're working with Facebook scores specify the player's user id
Points	Number	The player's score
Rank	Number	The player's rank based on your filtering options when you list
Website	String	The website the score occurred on, determined automatically by Playtomic
SDate	Date	The date of the score, determined automatically by Playtomic
RDate	String	The relative date of the score eg "7 minutes ago", determined automatically by Playtomic
CustomData	Object	Any additional data you want to (or have) attached to a score, like the level the player reached or what character they used

Submitting scores

Score submission is handled by:

Playtomic.Leaderboards.Save(score, table, callback, options);

Parameter	Type	Description
score	PlayerScore	An instance of PlayerScore which contains score information
table	String	The score table to submit to, alphanumeric
callback	Function	Optional function to pass the submission result to
options	Object	Optional object which may contain these properties: facebook (boolean): Set this to true if your score is for a Facebook leaderboard highest (boolean): Set this to false if your leaderboard is for lowest scores allowduplicates (boolean): Set this to false if you don't want players' scores to be overwritten

function SubmitScore()
{
    var simple_score = {};
    simple_score.Name = player_name;
    simple_score.Points = player_score;

    // submit to the highest-is-best table "highscores"
    Playtomic.Leaderboards.Save(simple_score, "highscores"); 

    // submit to the lowest-is-best table "besttimes"
    Playtomic.Leaderboards.Save(simple_score, "besttimes", null, {highest: false}); 

    // submit an advanced score with custom data and a callback function
    var advanced_score = {};
    advanced_score.Name = player_name;
    advanced_score.Points = player_score;
    advanced_score.CustomData = {}
    advanced_score.CustomPlaytomic.Data.Character = player_character;
    advanced_score.CustomPlaytomic.Data.Level = current_level;

    Playtomic.Leaderboards.Save(advanced_score, "highscores", SubmitComplete);
}

function SubmitComplete(response)
{
    if(response.Success)
    {
        alert("Score saved!");		
    }
    else
    {
        // submission failed because of response.ErrorCode
    }
}

Showing scores

Scores are loaded via a simple method that returns an array of PlayerScore objects to your function where you can display the data in your leaderboard.

Playtomic.Leaderboards.List(table, callback, options);

Parameter	Type	Description
table	String	Your leaderboard table name
callback	Function	Your function that receives the data
options	Object	Optional object which may contain: global (boolean): Show scores from all websites or only the website the player is on highest (boolean): Set this to false if your leaderboard is for lowest scores mode (String): Show scores from 'last7days', 'last30days', 'alltime' (default), 'today' or the special mode 'newest' which gives you a stream of unranked scores customfilters (Object): Filter by scores with specific CustomData page (int): The page you want (default is 1) perpage (int): The number of scores to return facebook (boolean): If it's a Facebook leaderboard set to true, otherwise ignore friendslist (array): If it's a Facebook leaderboard provide an array of friends' user ids to show friends scores

function ShowScores()
{
    Playtomic.Leaderboards.List("highscores", ListComplete);
}

function ListComplete(scores, numscores, response)
{
    if(response.Success)
    {
        alert(scores.length + " scores returned out of " + numscores);
				
        for(var i=0; i<scores.length; i++)
        {
            var score = scores[i];
            alert(" - " + score.Name + " got " + score.Points + " on " + score.SDate);
            
            // including custom data?  score.CustomPlaytomic.Data.Property
        }
    }
    else
    {
        // score listing failed because of response.ErrorCode
    }
}

Save and list

You can now submit scores and at the same time return the leaderboard page that that score is on.

This combines the Save and List approaches from above:

Playtomic.Leaderboards.SaveAndList(score, table, callback, options)

Some important notes:

• You don't specify a page, you specify the PerPage (default 20) and it will automatically decide which page to return based on the submitted score's rank. If you submit the 1187th best score at 30 per page then it will show you page 39, scores #1170 - #1200.
• Ranks are returned, so you are not viewing the top N scores you are viewing the top N scores from rank X onwards.

Private leaderboards (EXPERIMENTAL NEW FEATURE!)

You can now provide your players the ability to create their own leaderboard complete with a permalink and shortened URL they can give their friends to compete against each other.

Note: The permalink is going to append the leaderboard table's id, it should be like "http://site.com/game/?leaderboard=" or http://site.com/game?something=whatever&leaderboard=

Creating a leaderboard is simply:

Playtomic.Leaderboards.CreatePrivateLeaderboard(name, highest, permalink, callback);

Leaderboards.CreatePrivateLeaderboard(leaderboardname.text, true,  "http://mysponsorsite.com/mygame?leaderboard=", CreateComplete);

function CreateComplete(response)
{
    if(response.Success)
    {
        alert(response.Name);
        alert(response.Permalink); // full link, eg sponsorwebsite.com/play/my/game?leaderboard=asdfasfasdfasdf
        alert(response.Bitly); // bitly link to their leaderboard, eg bitly.com/blabla
        alert(response.Highest);
        alert(response.RealName); // internally used guaranteed unique name: user_RANDOMSTUFF_the name they provided
    }
    else
    {
        // leaderboard failed to save because of response.ErrorCode
    }
}

When a person visits the Permalink or the shortened Bitly link you can make them use that leaderboard by:

var leaderboardid = Leaderboards.GetLeaderboardFromUrl();
            
if(leaderboardid != null)
{
    Leaderboards.Load(leaderboardid, PrivateLeaderboarLoaded);
}

function PrivateLeaderboardLoaded(response)
{
    alert(response.Name);
    alert(response.Permalink);
    alert(response.Bitly);
    alert(response.Highest);
    alert(response.RealName);
}

When you save scores on a private leaderboard you must use the RealName, not the Name.

Showing Facebook scores

This is now merged with normal listing. Set the option property facebook to true, and optionally pass an array of the user's friend ids to only show their friends scores.

Embedding scores on your website

Scores are no longer available directly via URL as they expect POST data now. You will need to use the HTML5 / JavaScript API for showing scores on your web page, or the Flash or other APIs for embedding them in a SWF or other container.

GameVars

GameVars let you change the value of key variables in your game any time you want. They must be configured on the edit GameVars page in advance.

It is called via:

Playtomic.GameVars.Load(callback);

The callback parameter is your function that receives an object that has properties matching the variables you have configured here:

// our variables with default, original values
var BaseHitPoints = 100;
var BaseGold = 50;

function InitialiseGame()
{
    // load GameVars
    Playtomic.GameVars.Load(GameVarsLoaded);

    // carry on initializing your game
}

function GameVarsLoaded(vars, response)
{
    if(response.Success)
    {
        // sync the in-game variables
        BaseHitPoints = vars.BaseHitPoints;
        BaseGold = vars.BaseGold;
    }
    else
    {
        // request failed because of response.ErrorCode
    }
}

Geolocation

The GeoIP service identifies which country the player is from, returning their country code and name.

It is called via:

Playtomic.GeoIP.Lookup(callback);

The callback function receives an object that has Code and Name properties:

function SetPlayerCountry(country, response)
{
    if(response.Success)
    {
        // we have the country data
        trace("Player is from " + country.Code + " / " + country.Name);
    }
    else
    {
        // request failed because of response.ErrorCode
    }
}

Data lookup

Note: You must enable this functionality in each game's settings. By default it is disabled becaue it can expose your game Playtomic.Data.

The Data class in the API allows you to retrieve any of your game data to display in your game.

Each function for retrieving data takes an optional parameters object for day, month and year, with default values of 0.

• When day, month and year are specified you will receive data for that specific day.
• When month and year are specified you will receive data for that specific month.
• When day, month and year are unspecified or 0 then you will receive data for all time.

Views, Plays and Play Time

The Views, Plays and PlayTime functions returns this data to you for processing:

Playtomic.Data.Views(callback, options);

Parameter	Type	Description
callback	Function	Your function that receives the data
options	Object	Optional object which may contain day, month and year properties

Playtomic.Data.Views(OutputData); // views for all time
Playtomic.Data.Plays(OutputData, {day: 22, month: 3, year: 2010}); // plays on March 22, 2010
Playtomic.Data.PlayTime(OutputData, {month: 3, year: 2010}); // play time for March, 2010

function OutputData(data, response)
{
    if(response.Success)
    {
        // we have the data
        alert(Playtomic.Data.Name + " has value " + Playtomic.Data.Value + " for " + Playtomic.Data.Month + "/" + Playtomic.Data.Day + "/" + Playtomic.Data.Year);
    }
    else
    {
        // request failed because of response.ErrorCode
    }
}

Custom metrics

The CustomMetric function returns data about a custom metric to your function, which receives the same parameters as views/plays/play time above.

Playtomic.Data.CustomMetric(name, callback, options);

Parameter	Type	Description
name	String	The name of your custom metric
callback	Function	Your function that receives the data
options	Object	Optional object which may contain day, month and year properties

Playtomic.Data.CustomMetric("Clicked sponsor link", OutputData);

function OutputData(data, response)
{
    if(response.Success)
    {
        // we have the data
        alert(Playtomic.Data.Name + " - " + Playtomic.Data.Metric + " has value " + Playtomic.Data.Value + " for " + Playtomic.Data.Month + "/" + Playtomic.Data.Day + "/" + Playtomic.Data.Year);
    }
    else
    {
        // request failed because of response.ErrorCode
    }
}

Level metrics

There are three methods for retrieving level metrics. The functions that receive the data are different from the above examples.

Playtomic.Data.LevelCounterMetric(name, level, callback, options);
Playtomic.Data.LevelRangedmetric(name, level, callback, options);
Playtomic.Data.LevelAverageMetric(name, level, callback, options);

Parameter	Type	Description
name	String	The name of your custom metric
level	int or String	The level number or name
callback	Function	Your function that receives the data
options	Object	Optional object which may contain day, month and year properties

Playtomic.Data.LevelMetricCounter("Started level", level_number, OutputLevelCounter);
Playtomic.Data.LevelMetricRanged("Shots remaining", level_name, OutputLevelRanged, {month: 3, year: 2010});
Playtomic.Data.LevelMetricAveraged("Retries", level_number, OutputLevelAverage, {day: 22, month: 3, year: 2010});
            
function OutputLevelCounter(data, response)
{
    if(response.Success)
    {
        // we have the data
        alert(Playtomic.Data.Name + " - " + Playtomic.Data.Metric + "on level " + Playtomic.Data.Level + " has value " + Playtomic.Data.Value + " for " + Playtomic.Data.Month + "/" + Playtomic.Data.Day + "/" + Playtomic.Data.Year);
    }
    else
    {
        // request failed because of response.ErrorCode
    }
}

function OutputLevelRanged(data, response)
{
    if(response.Success)
    {
        // we have the data
        alert(Playtomic.Data.Name + " - " + Playtomic.Data.Metric + "on level " + Playtomic.Data.Level + " for " + Playtomic.Data.Month + "/" + Playtomic.Data.Day + "/" + Playtomic.Data.Year);

        for(var i=0; i<Playtomic.Data.Values; i++)
        {
            alert(" - Tracking value " + data[i].Value + " ocurred " + data[i].Occurances + " times");
        }
    }
    else
    {
        // request failed because of response.ErrorCode
    }
}

function OutputLevelAverage(data, response)
{
    if(response.Success)
    {
        // we have the data
        alert(Playtomic.Data.Name + " - " + Playtomic.Data.Metric + "on level " + Playtomic.Data.Level + " has min " + Playtomic.Data.Min + ", max " + Playtomic.Data.Max + ", average " + Playtomic.Data.Average + " for " + Playtomic.Data.Month + "/" + Playtomic.Data.Day + "/" + Playtomic.Data.Year);
    }
    else
    {
        // request failed because of response.ErrorCode
    }
}

ErrorCodes

When a Playtomic service is unreachable or has an error it will return a numeric error code. This table describes those errors:

General errors

These errors may be returned from any service.

Code	Meaning
0	No error
1	General error, this typically means the player is unable to connect to the Playtomic servers
2	Invalid game credentials. Make sure you use your SWFID and GUID from the "API" section in the dashboard.
3	Request timed out.
4	Invalid request. This means the request wasn't formed right, probably because the API key wasn't provided or was incorrect.

GeoIP errors

Code	Meaning
100	GeoIP API has been disabled. This may occur if your game is faulty or overwhelming the Playtomic servers.

Leaderboard errors

Code	Meaning
200	Leaderboard API has been disabled. This may occur if your game is faulty or overwhelming the Playtomic servers.
201	The source URL or name weren't provided when saving a score. Make sure the player specifies a name and the game is initialized before anything else using the code in the "Set your game up" section.
202	Invalid auth key. You should not see this normally, players might if they tamper with your game.
203	No Facebook user id on a score specified as a Facebook submission.
204	Table name wasn't specified for creating a private leaderboard.
205	Permalink structure wasn't specified: http://website.com/game/whatever?leaderboard=
206	Leaderboard id wasn't provided loading a private leaderboard.
207	Invalid leaderboard id was provided for a private leaderboard.
208	Player is banned from your leaderboard.
209	SaveAndList only. The score was not the player's best score. You can message the player, highlight their best via the SubmittedOrBest boolean property of scores, or override this by setting allowduplicates to true.

GameVars errors

Code	Meaning
300	GameVars API has been disabled. This may occur if your game is faulty or overwhelming the Playtomic servers.

Level sharing errors

Code	Meaning
400	Level sharing API has been disabled. This may occur if your game is faulty or overwhelming the Playtomic servers.
401	Invalid rating value (must be 1 - 10).
402	Player has already rated that level.
403	The level name wasn't provided when saving a level.
404	Invalid image auth. You should not see this normally, players might if they tamper with your game.
405	Invalid image auth (again). You should not see this normally, players might if they tamper with your game.
406	The level already exists. This is determined via a hash of the game id, level name, player ip address and name, and source url.

Data API errors

Code	Meaning
500	Data API has been disabled. This may occur if the Data API is not enabled for your game, or your game is faulty or overwhelming the Playtomic servers.

Parse Custom Database errors

Code	Meaning
600	You have not configured your Parse.com database. Sign up at Parse and then enter your API credentials in your Playtomic dashboard.
601	No response was returned from Parse. If you experience this a lot let us know exactly what you're doing so we can sort out a fix for it.
6021	Parse's servers had an error.
602101	Object not found. Make sure you include the classname and objectid and that they are correct.
602102	Invalid query. If you think you're doing it right let us know what you're doing and we'll look into it.
602103	Invalid classname.
602104	Missing objectid.
602105	Invalid key name.
602106	Invalid pointer.
602107	Invalid JSON.
602108	Command unavailable.