Has anyone ever integrated FileMaker and Nearmap?

My question is what the title says: has anyone ever integrated FileMaker and Nearmap?

Currently, we are using the Google Maps Javascript API inside a web viewer to measure out different areas of properties for estimating. It works really well; I was just asked to see if we could use Nearmap instead.

I have looked at their API documentation, but it frightened me. :sweat_smile: :grimacing: My only experience with API integrations is REST API's/Insert from URL & Google Maps, so doing this from scratch is beyond me at the present time.

I did a quick search, and found this: FileMaker Community (English). However, this poster says they used the Google App and Open URL, but I need it inside a web viewer.

Any help (even if it's a simple "this isn't possible") would be great!

Dive straight in - what could possibly go wrong? :grinning:

Seriously, they have a published API, so they've done most of the hard work for you. All you need to do is to figure out which bits you want. Then you use your data to generate a URL and use that URL in your web viewer.

If you don't already use it, download PostMan. Use it as a testing tool / sandpit. It's going to be your friend for any API work. Of course, FMP is really well suited to API development because it has a database engine that allows you to store parameters and data. You can use the built in web viewer or throw the URL out to your preferred browser.

You can do a lot of testing directly in your browser with the developer extensions window open. That's great for quick tests.


Just post your questions and we'll help!

I have done extensive API creation and usage with micro-services and other environments. Others here have similar backgrounds.

If you use a micro-service, you aren't stuck with FMP ONLY but you can use FMP if you want, or stop using it later, and your logic will KEEP WORKING!

Don't be intimidated by those saying "setting up a micro-service is too hard".

Instead, check out the cool video below showing how easy it is (in just about 2 minutes) to create a starting point micro-service:

FMPDUDE-VIDEO: Creating a micro-service in a couple minutes (with FMP example)

A micro-service is a (usually) small REST-based program that listens on a port for Requests (GET, POST, ...).

You create methods (functions) that implement the programming functionality you need.

Key benefits of micro-services include:

:black_small_square: FREE

:black_small_square: (if Java, Java-Compiled) Service Code Runs .... EXTREMELY FAST

:black_small_square: Uses industry standard protocols (HTTP verbs)

:black_small_square: Allows any application that can issue HTTP verbs to use the service (Terminal, FMP, Firefox, Opera, Chrome,....)

:black_small_square: Does not rely or need FileMaker (nor is FileMaker even required)

:black_small_square: Can reside on any operating system (Linux, Mac, Win)

:black_small_square: Can reside locally or anywhere on the Internet (Cloud Server, Linux Server, AWS, etc.)

:black_small_square: Can be used by multiple programs (or even other services) at once

:black_small_square: Supports multi-threaded/multi-processing (multiple-core) with declarative programming

:black_small_square: One user or 10,000 users....FREE

:black_small_square: No potentially costly FMP Plug-ins Needed (a service is not a plug-in)

:black_small_square: No per-machine configuration needed as with plug-ins

:black_small_square: NO restrictive FMP-only plug-in license agreements

:black_small_square: High Interoperability with other programs

:black_small_square: Enables you to tap into powerful modern languages

:black_small_square: Easy to Learn

:black_small_square: No need to "re-invent the wheel" in a proprietary FMP-only CF to duplicate existing tested/free library routines

:black_small_square: Extremely powerful (get the full power of Java + free third-party libraries like Apache and others.)

:black_small_square: Puts you in charge of the service code. Not a third party

:black_small_square: Externalize loops in Java to keep loops out of extremely slow, relative to Java, FMP scripts

:black_small_square: Email the service JAR file to others and they could use it right away (assuming Java installed, etc.)

:black_small_square: Install the service as a regular Java web (REST) application (via WAR file install) to an existing application server like Tomcat

:black_small_square: Service programming tools manage dependencies --- automatically

:black_small_square: Offers high abstraction. The caller of the micro-service doesn't need to know any details how the micro-service code works.

Parameters can almost always be passed simply letting the micro-service handle translations or other messy details.

(Note: Most modern programming languages, including Java and Python, support micro-services.)