Factual Debuts Two New Tools for Geofencing and Audience Targeting, Putting Location Data in the Hands of the Client

Factual is excited to launch two new product features to make it easier for marketers to take advantage of the power and flexibility of our Geopulse Proximity and Geopulse Audience products. The Geopulse Proximity Designer and Geopulse Audience Builder are transparent and powerful self-serve tools that enable our partners to craft their campaigns – using geofencing or location based audiences – to reach precisely the right audience.

Geopulse Proximity Designer enables our partners to quickly and easily design their geofenced ad campaigns by selecting their targeted places and setting their desired radius. The underlying data comes from our leading Global Places data, which covers over 65 million businesses and other points of interest in 50 countries, in 29 languages and with 467 categories. This data drives the powerful search functionality, enabling users to select places by any combination of business name, merchant chain, category, or geography. Users can also specify any radius or combination of radii, and design advanced targeting that differentiates between, say, targeting your own store, targeting competitors’ stores, and targeting your locations that are close to those of your competitors’. All of this is done on an interactive map providing complete transparency into the campaign’s targeting.

For a guided tour of the Geopulse Proximity Designer tool check out this video

Geopulse Audience Builder enables our partners to mix and match the hundreds of audience segments provided by Geopulse Audience to build their ideal audience. Geopulse Audience builds user profiles by analyzing where they spend time and the places they visit, assigning each user to a series of audience segments that covers geography, demographics, behavior, and brand affinity. Airlines can build one audience of business travelers who live in LA and spend time in NYC to promote one type of services, and build another audience of leisure travelers who live in the Northeast and visit the Caribbean. Retailers can build separate audiences of consumers who frequent their stores, consumers who frequent their competitors, and consumers who frequent both. This tool allows for any number of combinations of segments along with AND and OR logic controls so that advertisers can go as wide or as deep as they wish to reach their precise audience.

For a guided tour of the Geopulse Audience Builder tool check out this video

We’ve partnered with a number of media partners so that advertisers can run campaigns with our data and targeting technology on their preferred media providers. These two tools are currently being used by DSPs and networks such as StrikeAd, Turn, Manage, Deep Forest Media, EQ Works, MdotM, Juice Mobile, Adsmovil, TAPTAP, as well as publishers like The Weather Company and trading desks including Cadreon, and Horizon (HX).

Our current clients who have utilized these tools have had remarkable experiences. Here is what they have to say…

“Factual provides an important stream of best-in-class location data to our clients on a global basis which allows them to harness some of the most unique capabilities of mobile marketing,” said Emily Del Greco, VP of Sales for Adelphic. “Of all our data partnerships, Factual’s stands apart because of the quality of their location data, the diversity of its application and the sheer scalability – which is highly differentiated.”

“Factual’s tools allow us to easily plan campaigns with precise location targeting that’s optimized to the specific needs of our clients,” said Alex Rahaman, CEO of StrikeAd. “We have clients around the world and having global tools is wonderful from an internal organization / operations perspective and gives our multinational clients consistency across their markets.”

“We partner with the best data and technology providers to enable market leading mobile advertising solutions for advertisers,” stated Alberto Pardo, CEO of AdsMovil. “The data and tools provided by Factual enable us to bring our clients location targeting techniques that were not previously available in Latin America and that significantly enhance the ability of advertisers to reach Hispanic consumers in the United States.”

Contact sales to learn more about Factual’s mobile ad targeting products http://www.factual.com/contact?subject=sales

The Humongous nfu Survival Guide

Github: github.com/spencertipping/nfu

A lot of projects I’ve worked on lately have involved an initial big Hadoop job that produces a few gigabytes of data, followed by some exploratory analysis to look for patterns. In the past I would have sampled the data before loading it into a Ruby or Clojure REPL, but increasingly I’ve started to use nfu for these last-mile transformation tasks:

$ history | nfu -F '\s+' -f2gcOT5
96 ls
61 nfu # nfu at #2! booyah!
49 gs
48 vim
25 cd

This humongous survival guide covers nearly every aspect of nfu, from simple text-based data aggregation to module loading, JSON parsing, local map/reduce, and inner and outer joins.

What is nfu?

nfu is a command-line Perl tool that builds shell pipelines to transform text data. Conceptually, it does two things:

  1. Provides shorthands for common idioms of UNIX shell commands like sort
  2. Wraps Perl to be more directly applicable to text data

Before diving into how nfu works, here are a couple of use cases that illustrate what it does at a high level.

Testing correlation

As words get longer, do they tend to contain more “e”s? Probably, but let’s find out empirically by looking at all English words. Specifically, we’ll generate a plot whose X axis is cumulative length and whose Y axis is cumulative “e” count. Using standard UNIX tools:

$ perl -ne 'chomp;
            $_ = lc;
            print $x += length, "\t", $y += length(s/[^e]//gr), "\n"' \
  < /usr/share/dict/words \
  | gnuplot -e 'plot "-" with lines' -persist

Using nfu:

$ nfu /usr/share/dict/words \
      -m lc%0 \
      -m 'row length %0, length %0 =~ s/[^e]//gr' \
      -s01p %l

We can easily change this command to get a scatter plot. To see densities better, let’s add a bit of randomness to each data point:

$ nfu /usr/share/dict/words \
      -m lc%0 \
      -m 'row length %0, length %0 =~ s/[^e]//gr' \
      -m 'row %0 + rand(), %1 + rand()' \
      -p %d

The first three lines are identical, so we can generate an intermediate file. nfu transparently loads compressed data, so let’s gzip the file to save some space:

$ nfu /usr/share/dict/words \
      -m lc%0 \
      -m 'row length %0, length %0 =~ s/[^e]//gr' \
  | gzip > points.gz
$ nfu points.gz -s01p %l
$ nfu points.gz -m 'row %0 + rand(), %1 + rand()' -p %d

Joint analysis of JSON files

Suppose you’ve got two files, one a TSV of user-id, tweet-json and the other a TSV of user-id, user-json. You’d like to measure the differences between tweets of people with many vs few followers by building a list of most-used words faceted by log(followers). Using standard tools (including the indispensable jq) you might do this:

$ cut -f2 tweet-jsons \
  | jq -r '.text' \
  | sed 's/[\t\n]//g' \
  | paste <(cut -f1 tweet-jsons) - \
  | sort -k 1b,1 \
  > sorted-tweet-text
$ cut -f2 user-jsons \
  | jq -r '.followers_count' \
  | perl -ne 'print int(log($_ || 1)), "\n"' \
  | paste <(cut -f1 user-jsons) - \
  | sort -k 1b,1 \
  | join - sorted-tweet-text \
  | cut -f2-3 \
  | sort -n \
  > follower-counts-and-texts
$ perl -ne 'my ($count, $text) = split /\t/;
            print "$count\t$_\n" for split /\W+/, $text' \
  < follower-counts-and-texts \
  | sort \
  | uniq -c \
  | perl -ane 'print "@F[1,0,2]\n"' \
  | sort -n \
  > sorted-logfollowers-word-histogram

Of course, an easier way to do most of this would be to use SQLite or local map/reduce, but these introduce their own overhead, particularly when interoperating with other tools. Here’s how to do all of the above using nfu:

$ nfu tweet-jsons -m 'map row(%0, $_), split /\W+/, jd(%1).text' \
      -i0 sh:"$(nfu --quote user-jsons \
                    -m 'row %0, int log(jd(%1).followers_count || 1)')" \
      -f21gcf102o \
      > sorted-logfollowers-word-histogram


nfu is all about tab-delimited text data. It does a number of things to make this data easier to work with; for example:

$ git clone git://github.com/spencertipping/nfu
$ cd nfu
$ ./nfu README.md               # behaves like 'less'
$ gzip README.md
$ ./nfu README.md.gz            # transparent decompression (+ xz, bz2, lzo)

Now let’s do some basic word counting. We can get a word list by using nfu’s -m operator, which takes a snippet of Perl code and executes it once for each line. Then we sort (-g, or --group), count-distinct (-c), and reverse-numeric-sort (-O, or --rorder) to get a histogram descending by frequency:

$ nfu README.md -m 'split /\W+/, %0' -gcO
28  nfu
20  seq
19  100

%0 is shorthand for $_[0], which is how you access the first element of Perl’s function-arguments (@_) variable. Any Perl code you give to nfu will be run inside a subroutine, and the arguments are usually tab-separated field values.

Commands you issue to nfu are chained together using shell pipes. This means that the following are equivalent:

$ nfu README.md -m 'split /\W+/, %0' -gcO
$ nfu README.md | nfu -m 'split /\W+/, %0' \
                | nfu -g \
                | nfu -c \
                | nfu -O

nfu uses a number of shorthands whose semantics may become confusing. To see what’s going on, you can use its documentation options:

$ nfu --expand-code 'split /\W+/, %0'
split /\W+/, $_[0]
$ nfu --explain README.md -m 'split /\W+/, %0' -gcO
file    README.md
--map   'split /\W+/, %0'

You can also run nfu with no arguments to see a usage summary.

Basic idioms

Extracting data

  • -m 'split /\W+/, %0': convert text file to one word per line
  • -m 'map {split /\W+/} @_': same thing for text files with tabs
  • -F '\W+': convert file to one word per column, preserving lines
  • -m '@_': reshape to a single column, flattening into rows
  • seq 10 | tr '\n' '\t': reshape to a single row, flattening into columns

The -F operator resplits lines by the regexp you provide. So to parse /etc/passwd, for example, you’d say nfu -F : /etc/passwd ….

Generating data

  • -P 5 'cat /proc/loadavg': run ‘cat /proc/loadavg’ every five seconds, collecting stdout
  • --repeat 10 README.md: read README.md 10 times in a row (this is more useful than it looks; see “Pipelines, Combination, and Quotation” below)

Basic transformations

  • -n: prepend line numbers as first column
  • -m 'row @_, %0 * 2': keep all existing columns, appending %0 * 2 as a new one
  • -m '%1 =~ s/foo/bar/g; row @_': transform second column by replacing ‘foo’ with ‘bar’
  • -m 'row %0, %1 =~ s/foo/bar/gr, @_[2..$#_]': same thing, but without in-place modification of %1

-M is a variant of -m that runs a pool of parallel subprocesses (by default 16). This doesn’t preserve row ordering, but can be useful if you’re doing something latency-bound like fetching web documents:

$ nfu url-list -M 'row %0, qx(curl %0)'

In this example, Perl’s qx() operator could easily produce a string containing newlines; in fact most shell commands are written this way. Because of this, nfu’s row() function strips the newlines from each of its input strings. This guarantees that row() will produce exactly one line of output.


  • -k '%2 eq “nfu”': keep any row whose third column is the text “nfu”
  • -k '%0 < 10': keep any row whose first column parses to a number < 10
  • -k '@_ < 5': keep any row with fewer than five columns
  • -K '@_ < 5': reject any row with fewer than five columns (-K vs -k)
  • -k 'length %0 < 10'
  • -k '%0 eq -+-%0': keep every row whose first column is numeric

Row slicing

  • -T5: take the first 5 lines
  • -T+5: take the last 5 lines (drop all others)
  • -D5: drop the first 5 lines
  • --sample 0.01: take 1% of rows randomly
  • -E100: take every 100th row deterministically

Column slicing

  • -f012: keep the first three columns (fields) in their original order
  • -f10: swap the first two columns, drop the others
  • -f00.: duplicate the first column, pushing others to the right
  • -f10.: swap the first two columns, keep the others in their original order
  • -m 'row(reverse @_)': reverse the fields within each row (row() is a function that keeps an array on one row; otherwise you’d flatten the columns across multiple rows)
  • -m 'row(grep /^-/, @_)': keep fields beginning with -

Histograms (group, count)

  • -gcO: descending histogram of most frequent values
  • -gcOl: descending histogram of most frequent values, log-scaled
  • -gcOs: cumulative histogram, largest values first
  • -gcf1.: list of unique values (group, count, fields 1..n)

Sorting and counting operators support field selection:

  • -g1: sort by second column
  • -c0: count unique values of field 0
  • -c01: count unique combinations of fields 0 and 1 jointly

Common numeric operations

  • -q0.05: round (quantize) each number to the nearest 0.05
  • -q10?: quantize each number to the nearest 10
  • -s: running sum
  • -S: delta (inverse of -s)
  • -l: log-transform each number, base e
  • -L: inverse log-transform (exponentiate) each number
  • -a: running average
  • -V: running variance
  • --sd: running sample standard deviation

Each of these operations can be applied to a specified set of columns. For example:

  • seq 10 | nfu -f00s1: first column is 1..10, second is running sum of first
  • seq 10 | nfu -f00a1: first column is 1..10, second is running mean of first

Some of these commands take an optional argument; for example, you can get a windowed average if you specify a second argument to -a:

  • seq 10 | nfu -f00a1,5: second column is a 5-value sliding average
  • seq 10 | nfu -f00q1,5: second column quantized to 5
  • seq 10 | nfu -f00l1,5: second column log base-5
  • seq 10 | nfu -f00L1,5: second column 5x

Multiple-digit fields are interpreted as multiple single-digit fields:

  • seq 10 | nfu -f00a01,5: calculate 5-average of fields 0 and 1 independently

The only ambiguous case happens when you specify only one argument: should it be interpreted as a column selector, or as a numeric parameter? nfu resolves this by using it as a parameter if the function requires an argument (e.g. -q), otherwise treating it as a column selector.


Note: all plotting requires that gnuplot be in your $PATH.

  • seq 100 | nfu -p: 2D plot; input values are Y coordinates
  • seq 100 | nfu -m 'row @_, %0 * %0' -p: 2D plot; first column is X, second is Y
  • seq 100 | nfu -p %l: plot with lines
  • seq 100 | nfu -m 'row %0, sin(%0), cos(%0)' --splot: 3D plot
$ seq 1000 | nfu -m '%0 * 0.1' \
                 -m 'row %0, sin(%0), cos(%0)' \
                 --splot %l

You can use nfu --expand-gnuplot '%l', for example, to see how nfu is transforming your gnuplot options. (There’s also a list of these shorthands in nfu’s usage documentation.)

Progress reporting

If you’re doing something with a large amount of data, it’s sometimes hard to know whether it’s worth hitting ^C and optimizing stuff. To help with this, nfu has a --verbose (-v) option that activates throughput metrics for each operation in the pipeline. For example:

$ seq 100000000 | nfu -o                # this might take a while
$ seq 100000000 | nfu -v -o             # keep track of lines and kb

Advanced usage (assumes some Perl knowledge)


nfu provides two functions, jd (or json_decode) and je/json_encode, that are available within any code you write:

$ ip_addrs=$(seq 10 | tr '\n' '\r' | nfu -m 'join ",", map "%", @_')
$ query_url="www.datasciencetoolkit.org/ip2coordinates/$ip_addrs"
$ curl "$query_url" \
  | nfu -m 'my $json = jd(%0);
            map row($_, ${$json}{$_}.locality), keys %$json'

This code uses another shorthand, .locality, which expands to a Perl hash dereference ->{“locality”}. There isn’t a similar shorthand for arrays, which means you need to explicitly dereference those:

$ echo '[1,2,3]' | nfu -m 'jd(%0)[0]'           # won't work!
$ echo '[1,2,3]' | nfu -m '${jd(%0)}[0]'


You can setup a multiplot by creating multiple columns of data. gnuplot then lets you refer to these with its using N construct, which nfu lets you write as %uN:

$ seq 1000 | nfu -m '%0 * 0.01' | gzip > numbers.gz
$ nfu numbers.gz -m 'row sin(%0), cos(%0)' \
                 --mplot '%u1%l%t"sin(x)"; %u2%l%t"cos(x)"'
$ nfu numbers.gz -m 'sin %0' \
                 -f00a1 \
                 --mplot '%u1%l%t"sin(x)"; %u2%l%t"average(sin(x))"'
$ nfu numbers.gz -m 'sin %0' \
                 -f00a1 \
                 -m 'row @_, %1-%0' \
                 --mplot '%u1%l%t"sin(x)";

The semicolon notation is something nfu requires. It works this way because internally nfu scripts gnuplot like this:

plot "tempfile-name" using 1 with lines title "sin(x)"
plot "tempfile-name" using 2 with lines title "average(sin(x))"
plot "tempfile-name" using 3 with lines title "difference"

Local map-reduce

nfu provides an aggregation operator for sorted data. This groups adjacent rows by their first column and hands you a series of array references, one for each column’s values within that group. For example, here’s word-frequency again, this time using -A:

$ nfu README.md -m 'split /\W+/, %0' \
                -m 'row %0, 1' \
                -gA 'row $_, sum @{%1}'

A couple of things are happening here. First, the current group key is stored in $_; this allows you to avoid the more cumbersome (but equivalent) ${%0}[0]. Second, %1 is now an array reference containing the second field of all grouped rows. sum is provided by nfu and does what you’d expect.

In addition to map/reduce functions, nfu also gives you --partition, which you can use to send groups of records to different files. For example:

$ nfu README.md -m 'split /\W+/, %0' \
                --partition 'substr(%0, 0, 1)' \
                            'cat > words-starting-with-{}'

--partition will keep up to 256 subprocesses running; if you have more groups than that, it will close and reopen pipes as necessary, which will cause your subprocesses to be restarted. (For this reason, cat > … isn’t a great subprocess; cat >> … is better.)

Loading Perl code

nfu provides a few utility functions:

  • sum @array
  • mean @array
  • uniq @array
  • frequencies @array
  • read_file “filename”: returns a string
  • read_lines “filename”: returns an array of chomped strings

But sometimes you’ll need more definitions to write application-specific code. For this nfu gives you two options, --use and --run:

$ nfu --use myfile.pl ...
$ nfu --run 'sub foo {...}' ...

Any definitions will be available inside -m, -A, and other code-evaluating operators.

A common case where you’d use --run is to precompute some kind of data structure before using it within a row function. For example, to count up all words that never appear at the beginning of a line:

$ nfu README.md -F '\s+' -f0 > first-words
$ nfu --run '$::seen{$_} = 1 for read_lines "first-words"' \
      -m 'split /\W+/, %0' \
      -K '$::seen{%0}'

Notice that we’re package-scoping %::seen. This is required because while row functions reside in the same package as --run and --use code, they’re in a different lexical scope. This means that any my or our variables are invisible and will trigger compile-time errors if you try to refer to them from other compiled code.


Gzipped data is uncompressed automatically by an abstraction that nfu calls a pseudofile. In addition to uncompressing things, several other pseudofile forms are recognized:

$ nfu http://factual.com                # uses stdout from curl
$ nfu sh:ls                             # uses stdout from a command
$ nfu user@host:other-file              # pipe file over ssh -C

nfu supports pseudofiles everywhere it expects a filename, including in read_file and read_lines.

Pipelines, combination, and quotation

nfu gives you several commands that let you gather data from other sources. For example:

$ nfu README.md -m 'split /\W+/, %0' --prepend README.md
$ nfu README.md -m 'split /\W+/, %0' --append README.md
$ nfu README.md --with sh:'tac README.md'
$ nfu --repeat 10 README.md
$ nfu README.md --pipe tac
$ nfu README.md --tee 'cat > README2.md'
$ nfu README.md --duplicate 'cat > README2.md' 'tac > README-reverse.md'

Here’s what these things do:

  • --prepend: prepends a pseudofile’s contents to the current data
  • --append: appends a pseudofile
  • --with: joins a pseudofile column-wise, ending when either side runs out of rows
  • --repeat: repeats a pseudofile the specified number of times, forever if n = 0; ignores any prior data
  • --pipe: same thing as a shell pipe, but doesn’t lose nfu state
  • --tee: duplicates data to a shell process, collecting its stdout into your data stream (you can avoid this by using > /dev/null)
  • --duplicate: sends your data to two shell processes, combining their stdouts

Sometimes you’ll want to use nfu itself as a shell command, but this can become difficult due to nested quotation. To get around this, nfu provides the --quote operator, which generates a properly quoted command line:

$ nfu --repeat 10 sh:"$(nfu --quote README.md -m 'split /\W+/, %0')"

Keyed joins

This works on sorted data, and behaves like SQL’s JOIN construct. Under the hood, nfu takes care of the sorting and the voodoo associated with getting sort and join to work together, so you can write something simple like this:

$ nfu /usr/share/dict/words -m 'row %0, length %0' > bytes-per-word
$ nfu README.md -m 'split /\W+/, %0' \
                -I0 bytes-per-word \
                -m 'row %0, %1 // 0' \
                -gA 'row $_, sum @{%1}'

Here’s what’s going on:

  • -I0 bytes-per-word: outer left join using field 0 from the data, adjoining all columns after the key field from the pseudofile ‘bytes-per-word’
  • -m 'row %0, %1 // 0': when we didn’t get any join data, default to 0 (// is Perl’s defined-or-else operator)
  • -gA 'row $_, sum @{%1}': reduce by word, summing total bytes

We could sidestep all nonexistent words by using -i0 for an inner join instead. This drops all rows with no corresponding entry in the lookup table.

Go forth and conquer

nfu is an actively-maintained project we use in production, so bug reports and feature requests are both welcome. If you read this far and find this kind of thing interesting, you should consider working at Factual!

Factual Featured Partner: HelloTel

Solitary travel can easily be a lonely experience. HelloTel is an app that alleviates this issue by converting any hotel that you’re visiting into your personal social network. Learn more in the interview below with Marc Preston, HelloTel founder and CEO.

Company Name: Sochule Inc, HelloTel
Located: Chico, CA
Factual Partner Since: 2014
Website: hellotelapp.com
Facebook: facebook.com/HelloTelApp
Twitter: @HelloTelApp
Instagram instagram.com/hellotelapp
Apps: iTunes, Google Play
Your Name and Title: Marc Preston, Founder and CEO

Q: Introduce readers to HelloTel.
A: HelloTel transforms any hotel into a niche social network— to make new business connections, find new friends, or both. Today, users log into the app using their Facebook account, which automatically populates their profiles with elements like their name and profile picture (these can be changed later). From there, they can “check into” their hotel to find and interact with other users either at the same establishment or nearby.

Down the line, we will be connecting with Hotels on the back end to enable them to better interact with their guests. This means integration of real hotel services, like ordering food or cabs, from within the app. In return, hotels will be able to use data collected from HelloTel to learn more about their customers and ultimately provide them with a better experience.

Q: Why is Factual data important for HelloTel?
A: HelloTel requires venue data to determine which hotels are near users based on their GPS coordinates. Originally we built our own lists, but they didn’t come close to the hotel data that Factual offers. It’s crucial to us to have the best data, so we never miss a hotel where a user is staying.

Q: What made you decide to create HelloTel?
A: I developed the idea for HelloTel while at CES. I was staying in a huge hotel in Las Vegas and realized that there was absolutely no way that I could meet everyone else in the hotel on a social level. I knew an app like HelloTel could help me not only get to know the people around me in the hotel socially, but also help me make great business connections while at the conference.

Q: Mobile technology is dramatically changing the way we meet new people. Apps like HelloTel and SocialRadar provide new avenues to browse and reach out to potential acquaintances. Where do you see the relationship between mobile and face-to-face socializing going in the next 5-10 years?
A: What our app accomplishes is opening up a hotel of maybe 1,000 people that you would never normally meet and making it possible to find the right social and business connections. We see it as a precursor to a valuable, face to face interaction. The goal for the future isn’t this sort of “head down in your phone” interaction; it’s facilitating in-person relationships. Like HelloTel, I think that’s the direction all of this technology is ultimately going.

Q: What advice do you have for developers creating a new app? Have you learned any big lessons while working on HelloTel?
A: One thing that is really helpful is to think about the framework of your app at the beginning. Most developers start with an iOS app and then separately build an Android version later. This path ends up being a lot of work that could be avoided if you start off building the app in a framework that’s friendly for both Apple and Android. For example, anything you can do in Objective-C, Java, or Swift can be done in C#. Developing in C# has numerous benefits like fewer keystrokes, fewer callbacks for the app’s responsiveness, and lambdas, which make for simplified building for Android. From here, developers can utilize tools such as Xamarin.com to implement native performance and share the C# code across multiple native platforms like iOS, Android, and Windows. If your development roadmap requires the app to be built on multiple platforms, in the end, you will save time and money (trust me on this one) by building entirely in C#.

- Julie Levine, Marketing Associate

More about Factual’s Hotel Data
Factual’s Hotels Data includes over 140,000 hotels, motels, resorts, and bed-and-breakfasts. In addition to the core attributes in all of Factual’s Global Places data, hotel data also includes attributes such as: price, food options, services, size, average rating, and others. Learn more about Factual’s hotels data here.

Factual Partners with Nexage to Accelerate the Availability of Audience Targeting Data in Mobile Advertising

We are very excited to announce our new partnership with Nexage, the premium mobile programmatic marketplace. Demand Partners of Nexage and Factual will leverage our Geopulse Audience solution in order to provide enriched geo-behavioral targeting, enabling advertisers to better reach their desired audience.

Via Nexage Connect, Advertisers can now target mobile campaigns based on how users interact with the physical world. Over 275 segments will be made available at launch with more being added over time. Example behavioral information such as business traveler, in-market auto buyer, and quick service restaurant diner, as well as geographic information like zip code, and Brand Affinity targeting such as McDonald’s, Target, Home Depot, Toyota, Foot Locker and hundreds more Retail, Dining, Financial, Grocery and Automotive brands. Advertisers can choose any combination of these segments to build the precise audience that best fits their campaign.

To develop the audience segments, Geopulse Audience applies our extensive location data (including our Global Places data, which covers over 65 million local businesses and points of interest across 50 countries and additional contextual data about geographic areas) and deep data engineering along with machine learning expertise to the vast amount of location data running through Nexage Connect. By leveraging all of this, Geopulse Audience can better understand mobile user behavior and use this understanding to develop audience segments.

“Nexage has designed our platform to be the market’s most robust and advanced technology in mobile advertising because we understand that the strength of technology directly impacts our customers’ ability to do business and make money,” said Mark Connon, CRO & EVP of Corporate Development of Nexage. “Nexage Connect is another example of extending our platform and providing a powerful capability that enables our customers—both media buyers and publishers—to be more successful and manage their business how they want.”

Publishers running ad inventory through Nexage will benefit both from the increase in the value of their ad inventory driven by the audience segments as well as from the increase in relevance of the ads seen by their users. Nexage and Factual are also working together to bring Geopulse Audience analytics direct to Publishers. Demand Side Platforms (DSPs) and Ad Networks connected to Nexage will benefit by being able to offer their advertisers enhanced targeting capabilities. Advertisers will benefit by increasing the effectiveness of their ad spend by being able to better reach their desired audience.

“Factual makes signals from location, one of the most important and unique value drivers in mobile, accessible to marketers,” said Bill Michels, SVP of Products and Partnerships at Factual. “Our audience segments based on location intelligence strengthens media buyers and advertisers’ ability to deliver more personalized content, and we’re excited about bringing this capability to Nexage, the leading mobile programmatic platform.”

-Glen Nigel Straub, Director, Business Development

Factual to Enhance First Data’s Insightics Solution for SMBs

First Data has chosen to partner with Factual to enhance its Insightics solution for small and medium sized businesses. Insightics is an innovative cloud-based software that unlocks the power of big data behind payment transactions to give SMB merchants the ability to monitor key business metrics and better understand their customers. First Data already evaluates a vast amount of data, but needed more in depth data for additional attributes and intelligence. This collaboration goes beyond transactional processing and produces advanced business and consumer insights that help merchants to grow their businesses.

It’s a big deal for small businesses to get actionable insights about their business. How many new versus repeat customers they have been getting the past few weeks, is an important thing to know. SMBs may also want to know which part of the local neighborhood customers come from and how far are customers willing to travel to come to their store. If the SMB is having a good or bad month, is it just that SMB or all similar businesses in the area? Delivering such capabilities requires all the horsepower of state of the art big data analytics presented in an extremely easy to understand manner to the merchant. That’s what First Data Insightics does.

These powerful insights combine the tremendous amount of payments data flowing through First Data’s systems with the learnings coming from Factual’s U.S. Places data. In order for First Data to provide the most relevant and beneficial insight to a merchant, they need to know a lot about the merchant – that’s where Factual starts to play a part. Factual provides data that includes the exact location of each merchant, other similar merchants around, other dissimilar merchants, name of neighborhood where the merchant is located, hours of operation, price range, etc. US Places, which covers over 17 million local businesses and points of interest, enables First Data to have a comprehensive view of all of the businesses in any geographic area. The rich categorization scheme allows for highly refined benchmarking, making sure that, for example, a beauty salon is benchmarking themselves against strictly other beauty salons and not also against manicure/pedicure nail shops.

First Data will also be using our Restaurants, Hotels, and Healthcare Providers Extended Attributes data sets. These contain extensive, category specific attributes that enable for even more refined segmentation and analysis. With our restaurants data, for example, a First Data merchant, say a 4 star Italian Restaurant, can analyze his performance against other 4 star Italian restaurants, other 4 star restaurants, or all other Italian restaurants, to get a much richer picture on how he is doing and how much of his performance is related to his own business versus the overall business environment.

Here’s what we heard from First Data:

“After extensive research to find a data partner, we found that Factual far exceeded other companies on data quality and its capabilities to maintain and keep the data up to date,” stated Sandeep Garg, VP Product, Information and Analytics at First Data. “Additionally, Factual goes beyond legacy data companies with its technology and the innovative services that it builds on top of the data, enabling us to provide the valuable insights needed for our clients to grow their businesses.”

Thousands of developers (small business owners) in the mobile space use Factual data to drive their businesses. Processing more than 59 billion transactions globally for more than six million merchant locations in 2013, First Data has long been a data powerhouse. We’re looking forward to working with First Data to bring the power of big data to small businesses!