Google Maps Alternative for Tunisia: TMaps Compared

If you build an app for the Tunisian market, Google Maps is the default choice. Everyone knows it, it covers everything, and you've probably used it before. Then the first invoice arrives, in US dollars, charged to an international card, and you start wondering whether there's an alternative built for Tunisia.

We built TMaps to answer that question. But instead of a sales pitch, this post compares the two the way a developer would: the code, the billing model, real prices on three scenarios, and the cases where Google is still the better pick.

We'll stick to the two most common needs: showing a map and finding an address (geocoding). Routing deserves its own comparison.

1. The code: what does a migration look like?

Showing a map

With Google Maps, you load Google's JavaScript SDK:

<div id="map" style="height: 400px"></div>
<script>
  function initMap() {
    new google.maps.Map(document.getElementById('map'), {
      center: { lat: 36.8002, lng: 10.1815 }, // Tunis
      zoom: 12,
    });
  }
</script>
<script async src="https://maps.googleapis.com/maps/api/js?key=YOUR_GOOGLE_KEY&callback=initMap"></script>

With TMaps, you pick an open-source library (Leaflet here) and point it at the TMaps tiles:

<div id="map" style="height: 400px"></div>
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/leaflet@1.9.4/dist/leaflet.css">
<script src="https://cdn.jsdelivr.net/npm/leaflet@1.9.4/dist/leaflet.js"></script>
<script>
  const map = L.map('map').setView([36.8002, 10.1815], 12); // Tunis
  L.tileLayer('https://tiles.tmaps.tn/r-tile/{z}/{x}/{y}?api_key=YOUR_TMAPS_KEY', {
    maxZoom: 18,
    attribution: '© TMaps',
  }).addTo(map);
</script>

The real difference isn't the line count. With Google, your code depends on Google's SDK. With TMaps, it depends on Leaflet, OpenLayers or MapLibre, which are open source: if you ever switch tile providers, you don't rewrite your map, you change a URL.

Finding an address

On the Google side, you call the Geocoding API:

const url = new URL('https://maps.googleapis.com/maps/api/geocode/json');
url.search = new URLSearchParams({ address: 'Rue de Marseille, Tunis', region: 'tn', language: 'fr', key: GOOGLE_KEY });
const { results } = await fetch(url).then((r) => r.json());
const { lat, lng } = results[0].geometry.location;

On the TMaps side:

const url = new URL('https://api.tmaps.tn/geocoding/forward');
url.search = new URLSearchParams({ q: 'Rue de Marseille, Tunis', country: 'TN', lang: 'fr', api_key: TMAPS_KEY });
const { results } = await fetch(url).then((r) => r.json());
const { lat, lng } = results[0].geometry.location;

Good news if you're migrating: the coordinates live in the same place, geometry.location. Where they really differ is the address breakdown:

• Google returns a generic address_components array where each item has types (locality, administrative_area_level_1…). Mapping those types to Tunisian administrative levels is up to you.
• TMaps returns fields named after the Tunisian administrative structure:

"components": {
  "street": "Rue de Marseille",
  "commune": "Habib Thameur",
  "delegation": "Bab El Bhar",
  "governorate": "Tunis",
  "country": "TN"
}

If your delivery form asks for the delegation and the governorate, that's mapping code you don't have to write.

2. Billing: two different units

This is the part you really need to understand before comparing prices.

Google bills a map per load: when a page displays the map, that's one billable event, no matter how many tiles it loads afterwards. Geocoding is billed per request. Each product has a monthly free cap: 10,000 map loads and 10,000 geocoding requests. Beyond that, you pay per thousand, in US dollars.

TMaps counts every successful request as one call: a map tile or a geocoding request. Plans are monthly bundles priced in Tunisian dinars (TND), with a number of calls included. Past your quota, every extra 1,000 calls costs 0.5 TND, and the service is never cut off. The Free plan includes 50,000 calls a month, commercial use included.

So a TMaps map uses several calls per display. We measured it on our demos, with a 1500 × 963 pixel map:

• with raster tiles (Leaflet), the first display loads 35 tiles;
• with vector tiles (MapLibre), it loads 12.

Tiles already in the browser cache aren't requested again, but to stay on the safe side, we count every display as a first visit.

3. Prices on three scenarios

Sources: the Google Maps Platform price list (updated October 21, 2026) and the TMaps pricing page. To compare, we use about 3 TND per US dollar (Central Bank of Tunisia rate on October 8, 2026). Google prices exclude taxes and international payment fees.

Scenario 1: a small showcase site

3,000 map displays and 1,000 address searches per month, commercial use.

• Google: $0. Everything fits in the free caps.
• TMaps: 0 TND (Free plan, commercial use allowed). With vector tiles, 3,000 displays × 12 tiles + 1,000 geocoding requests is about 37,000 calls, under the plan's 50,000.

A tie, then. The difference shows up as traffic grows: the TMaps Free plan covers about 4,000 vector map displays a month (or 1,400 with raster tiles), while Google stays free up to 10,000 map loads. In between, Google costs nothing and TMaps moves to the Starter plan at 79 TND a month. No point pretending otherwise.

Scenario 2: a delivery app

200,000 geocoding requests per month (entering and checking customer addresses), not much map display.

• Google: $850/month, about 2,550 TND. The first 10,000 are free, then 90,000 at $5 per thousand and 100,000 at $4 per thousand.
• TMaps: 79 TND/month (Starter plan, 200,000 calls included).

This is where the gap is widest: geocoding is a big line item on a Google invoice, and it's part of the bundle with TMaps.

Scenario 3: an e-commerce site

30,000 map displays and 20,000 address searches per month.

• Google: $190/month, about 570 TND. 20,000 paid map loads at $7 per thousand, plus 10,000 paid geocoding requests at $5 per thousand.
• TMaps with vector tiles (MapLibre): 229 TND/month (Growth plan). 30,000 × 12 tiles + 20,000 geocoding requests is about 380,000 calls, under the plan's 750,000.
• TMaps with raster tiles (Leaflet): 599 TND/month (Business plan). At 35 tiles per display, you reach about 1,070,000 calls.

This one shows how much the technical choice matters: with vector tiles, TMaps costs about 2.5 times less than Google; with raster tiles, it ends up slightly more expensive. If your site shows a lot of maps, go vector.

Scenario	Google	TMaps
Small showcase site (3,000 maps a month)	$0	0 TND
Mid-size site (8,000 maps a month)	$0	79 TND
Delivery app	≈ 2,550 TND ($850)	79 TND
E-commerce, vector maps	≈ 570 TND ($190)	229 TND
E-commerce, raster maps	≈ 570 TND ($190)	599 TND

4. What the price list doesn't show

The street reference. This is probably the biggest difference, and no price list shows it. The TMaps database holds more than 120,000 roads, with a verified name for 72% of road segments on average. According to our coverage measurement, published and recomputed every week on the map coverage page (in French), TMaps shows on average twice as many named roads as Google Maps across Tunisia's 24 governorates, especially in suburban areas and new neighbourhoods. Streets are named in French and Arabic, including the informal local names people actually use.

For a delivery app, that's very concrete: a street with no name is an address your customer can't type, and a driver who has to call to ask for directions. This is our own measurement, not an independent audit, so check it on your area: the side-by-side pages show Google on the left and TMaps on the right, for example in Ben Arous.

Currency. Google bills in US dollars, through a billing account and an international payment method, so every move of the dinar changes your invoice. TMaps bills in dinars, with no exchange-rate exposure.

Overages. With TMaps, a traffic spike never takes the service down: it's billed at the overage rate on the next invoice. With Google, pay-as-you-go has no ceiling by default, so set quotas and budget alerts.

Arabic and Arabizi. Tunisian addresses get typed in French, in Arabic script and in Arabizi (nahj, 9asr said). Another post in this series shows how to build an address search that handles all three, and you can try it in the address search demo: type 9asr said.

Support. A team based in Tunis, working Tunisian hours, on one side; the support desk of a global platform on the other.

5. When to stay on Google Maps

An honest comparison also has to say when not to switch:

• Your traffic fits in Google's free caps but not in the TMaps Free plan (roughly 4,000 to 10,000 maps a month): with Google, you won't pay anything.
• Your app covers several countries, and Tunisia is just one market among others.
• You rely on services TMaps doesn't offer: Street View, Google's global places database with reviews and photos, or mobile SDKs your team already knows.

On the other hand, TMaps makes sense when Tunisia is your main market, when your customers live in new or suburban neighbourhoods where named streets make the difference, when you geocode a lot of addresses, when you want a fixed invoice in dinars, or when you'd rather build your map on open-source libraries.

See for yourself

• Compare both maps in Ben Arous, Sfax or Nabeul
• Road coverage, governorate by governorate: map coverage (in French)
• Try the API without writing code in the Postman collection
• Live demos and their code: examples.tmaps.tn

Prices quoted here are from October 2026 and can change: always check the official price lists before you decide. Questions about a migration? Leave a comment or write to [e-mail].