The complete developer guide as a PDF document with code examples, can be found here: Developer-Manual

The GpsNose platform is accessible to any developer through the GpsNose open JSON services. You can take the provided C# or PHP reference implementation from this page and:

  • Use it as-is, if you are developing for .NET or PHP, or
  • Write your own custom SDK version for your environment.

The provided SDK can be used:

  • As the source-code, i.e. you can put it into your project as sources and modify/debug/change as you wish, or
  • As a package, i.e. already compiled or packed as a ready-to-go module, available  from within your target environment. For C#, it’s the NuGet library, for PHP it’s (coming soon!)

When you agree, that nobody guarantees you anything and you use the platform at your own risk, you can download the reference implementation sources for:

The C# library is the very master of the SDKs – it holds the reference implementation, so you can always check for the latest state here. When porting for another environment, the best idea is to take this one.

The EULA you agree with when using the libraries, can be found here.

How it works

Your website can be joined to GpsNose by creating a mashup at the mashup admin. You can use the generated app-key within the GpsNose SDK calls to enable GpsNose functionality for your website’s users, like:

  • Login with the QR-code scanner, available in the mobile app
  • Read the news from your community, primary or sub-communities
  • Use bulletin boards from community comments
  • Show your users the stuff  available nearby, like other community members, impressions, tracks, events, points of interest
  • Use the mashup-tokens for anything you like, like who/what/where was found (scanned), so you can react on your website’s backend reading-in these scanned tokens.

CMS Plugins

We’ve created also a few ready-made CMS plugins, which use the underlying GpsNose SDK for your convenience, so you don’t have to write any custom code.
You are welcome to develop other modules for additional CMS platforms of course, so other web admins can take those without writing code calling the low-level SDK.

See the CMS page for more details.

Quick start

The API is object-oriented and your first class to get to the API calls is always the GnApi:

var api = new GnApi();

The GnApi instance can be reused as many times as you want. Having the GnApi object, you need to decide as who you would like to call the API:

  • As the end-user (your GpsNose SDK-calls on your website run impersonated as the user, which logged into your website with the QR-code or from the mobile APP with the mobile-browser), or
  • As the admin-user (the SDK-calls run as you, the mashup-administrator of your website).

For the administrative tasks, like resetting the mashup-site’s app-key, or adding sub-communities, you can use of course the developer’s console available at the GpsNose website here, but you might want to automate something, like adding and verifying a new mashup site for your account, so all such tasks can be accomplished also using the admin-API calls. Remember, that all such admin tasks require you to be logged-in of course.

On the other hand, the end-user can login into your website using his GpsNose mobile-app, scanning the QR-code (will be discussed later) from your website. Or, he can login directly from his GpsNose mobile-app, from within the community-details window: he is then redirected straight to your website on his mobile phone (i.e. using the mobile’s web-browser). Then your website can enter/read the data in his name, so he sees other users and things in his real nearby area, like impressions, tracks, events etc.

The end-user can also call some services as a guest, so the corresponding sink object GnLoginApiEndUser can be in a not-logged-in state.

Both the GnApi.GetLoginApiForAdmin() and GetLoginApiForEndUser() work similarly. When called, you can provide your own loginId for identifying the login-session, which is simply an alphanumerical random string, at least 10 chars long, or you can leave it empty, to get a new Guid string from the SDK. It’s just a session-id, which identifies globally (worldwide, not just within your website) a user, after he logs-in.

Both the GnLoginApiBase objects – GnLoginApiAdmin and GnLoginApiEndUser –  gets you  to the needed API services.

Here is an example of how to wait for a user-login from your website:

// get the GN platform api
var api = new GnApi();

// get the end-user login-api
var loginApi = api.GetLoginApiForEndUser(_site.AppKey);

// generate the QR-code for login
var qrCode = loginApi.GenerateQrCode();

// TODO: here, you must show the user the QR-code so he can scan it

// set max wait-time as 1 minute for example
var cancelSource = new CancellationTokenSource(1 * 60 * 1000);

// wait for the end-user to log-in with scanning the QR-code
var task = loginApi.WaitForLogin(cancelSource.Token);
catch (OperationCanceledException)
    // cancelled by time-out or user-cancelled: do nothing..
    throw new Exception("user didn't log-in");

// in the result, the user-data is returned for your needs
var userData = task.Result;

When you need to show some general data to the anonymous user, who is currently not logged-in, you can do it like in this news-reading example:

// get the GN platform api
var api = new GnApi();

// get the end-user login-api, which will stay in a not-logged-in state in this example
var loginApi = api.GetLoginApiForEndUser(_site.AppKey);

// get the news-api, which is an guest-enabled api
var newsApi = loginApi.GetNewsApi();

// get the news
var news = newsApi.GetNewsPage();

To sum it up, some services need:

  • An administrative login (for an automated mashup management), other need
  • An end-user login (such as the GnNearbyApi services), as there must be an already logged-in user (for example, to explore his real nearby area) and some service even
  • Don’t need a login at all (like reading the news) and thus they can be called without having the LoginApi been in a logged-in state.

The service-calling steps:

  1. Use the GnApi to get to the GnLoginApiBase, for both the admin and end-user API call-areas,
  2. Wait for the user-login if needed so,
  3. Access the underlying services, which are either administrative, or user-scoped, or even guest-enabled.

Caching and Quotas

Most of the SDK API-calls are cache-enabled, which means: if the same API-request parameters were already been used a short time ago (default is 15 minutes), the response is read from the SDK’s cache, instead of contacting the GpsNose server.

The advantage of this is:

  • Saving time/traffic costs needed for contacting the external web service and
  • Saving your monthly calling quotas on the GpsNose server side.

As GpsNose is free for anybody (well, as long as we can pay for it ourselves..), we must ensure some website with high traffic won’t make us bankrupt ;-). So there are some calling-quotas applied for your website, which can be seen and monitored in the developer console here.


A lot of APIs use the time-based paging, like in the aforementioned reading-news example. The data-page you get contains a data-segment from a given time-point, let’s say 20 items in the page. Then, you can page-through to the next-page supplying the API the lastKnownTicks parameter, which is the first item’s creation ticks you have received before, as the first item is the very latest one.

Consider the following read-news example, this time paging through all the available news:

// get the GN platform api
var api = new GnApi();

// get the end-user login-api, which will stay in a not-logged-in state in this example
var loginApi = api.GetLoginApiForEndUser(_site.AppKey);

// get the news-api, which is an guest-enabled api
var newsApi = loginApi.GetNewsApi();

// get the news
var news = newsApi.GetNewsPage();

// continue reading, until more news-data keeps coming
while (news.Count > 0)
    news = newsApi.GetNewsPage(lastKnownTicks: news[0].CreationTicks);

How you can help

When you write your own SDK for other systems (Java, Node.JS etc.), you’re welcome to publish your code somewhere (e.g. GitHub) and tell us we can link it from this page.

We have no available resources to code or maintain more code as we already do already. But when you can help with creating new libraries, we can support you more focused using GpsNose API/SDK and maybe give you some goodies, like more relaxed API calling quotas for example.

SDK Versioning

– ADD: AddSubCommunity() now supports ACLs specification

– FIX: GnAdminApi ctor, GnLoginApiAdmin access

– ADD: GnMailsApi, GnMail: sending and reading mails

– FIX: https links for NuGet

– UPD: API calls examples/params set to
– ADD: GnMashupTokensApi.GetMashupTokensPage() lastKnownScanTicks default = 0
– UPD: readme.txt

– FIX: GnAdminApi.UpdateCommunityWeb(): added the missing mashupTokenCallbackUrl

– UPD: readme.txt

– ADD: readme.txt

– ADD: GnMashupToken.CallbackResponseHttpCode, GnMashupToken.CallbackResponseMessage
– DEL: GnMashupToken.CallbackResponse
– ADD: UpdateCommunityWeb() -> mashupTokenCallbackUrl param for defining the optional scan-callback-url

– ADD: GnMashup.MashupTokenCallbackUrl optional property for sync-calling mashup’s callback-url
– ADD: GnMashupToken.CallbackResponse the response from the mashup’s callback

– DOC: NuGet package metadata

– REF: GenerateQrCode() available as separate functions for admin/endUser login-apis

– REF: GnLoginApi -> GnLoginApiBase + GnLoginApiEndUser + GnLoginApiAdmin

– REF: GnMashupTokensApi

– ADD: GnAdminApi.GenerateQrTokenForMashup(): validToTicks

– ADD: GnAdminApi.GetMashupTokensPage()

– ADD: GnAdminApi.GenerateQrTokenForMashup() for generating a QR-code for a mashup

– REF: error-handling in GnApiModuleBase.ExecuteCall()
– ADD: GnCommunityApi.InviteMemberToCommunity()

– REF: GnCreatedEntity -> GnAroundObject

– FIX: nearby-noses: no-caching

– UPD: nearby-items are not cached at all

– FIX: err-responses (httpErr, jsonErr) and null-responses are now not cached

– REF: GnNose derived from GnCreatedItem => Noses-around now have:
.. .Creator instead of .LoginName
.. .CreationTicks for last-touch
– ADD: created-items around API calls: now having DistanceExact if available


– FIX: HandleCallQuota(): if (_quota_CallCounter > QUOTA_MAX_CALLS): comparison fixed to “>=”

– ADD: GenerateQrCodeForCommunityJoin caching-ttl=1day

– ADD: GnCommunityApi.GenerateQrCodeForCommunityJoin

– ADD: GnUtility.ToExpando()

– ADD: GnApiModuleBase.ClearCacheForActionNames()
– FIX: GnCommentsApi.UpdateComment()/AddComment() clearing the GetCommentsPage()
– FIX: GnApiModuleBase.ExecuteCall() overload now using cacheTtl

– ADD: GnApiModuleBase.ClearCacheForActionName()
– UPD: GnCommentsApi.UpdateComment()/AddComment() clearing the cache

– ADD: GnCache.ClearCache + optional key-pattern matching for delete-in-scope

– FIX: caching turned off for GnCommentApi.AddComment/UpdateComment and GnLoginApi.GetVerified/CheckIfIsStillLoggedId

– ADD: caching-policy for GnApiModuleBase.SimpleResultCall
– ADD: no-caching option: TimeSpan.MaxValue
– FIX: caching-policy for GnAdminApi: GetOwnMashups = 1sec, other calls: no-caching

– UPD: default langId: current instead of “en”

– ADD: caching for GnApiModuleBase.ExecuteCall()

– ADD: GnUtility.GetQueryStringFromKeyVals
– ADD: GnLogin.LangId
– UPD: GnApiModuleBase.Execute: langId scope

– ADD: JsonTool.QuickJson()

– ADD: IsLoggedIn: nullable<bool> for tri-state

– ADD: GnSettings.CurrentLangId

– ADD: GnCommunity.Admins

– UPD: PageNews: int->int? pageSize
– REF: MembersPage -> GetMembersPage

– ADD: GnSettings.IsSuperNoseMachine dev-helper

– ADD: GnLocalSettings

– REF: GnPaths: details/images

– DEL: GnPaths: LoginQrImage path: deprecated, use API call to generate it

– UPD: WaitForLogin is async now

– UPD: ex message on GenerateQrCode(): if comm is not provided for normal user

– UPD: async WaitForLogin

– UPD: WaitForLogin can be aborted from outside

– UPD: QR-code received test on calling login methods

– ADD: Initial Release