I’m excited to announce The Attack Machine, an exploratory site available via Evri’s experimental Garden, which leverages the power of the Evri API to automatically generate content oriented around an action, or verb.

Content on The Attack Machine is automatically generated leveraging Evri’s deep linguistic analysis of news, blog and other web content. The Attack Machine is an example application highlighting the power of leveraging a grammatical clause level understanding of verbs. The entire Attack Machine site could be straightforwardly mapped to other verbs, such as love, hate, punch, cherish, destroy, etc.

Content on The Attack Machine homepage is generated by an algorithm which runs every few minutes and looks for the top attackers and victims in particular categories such as animals, locations, weapons, and politicians.

Evri’s system can be thought of like an army of 7th grade grammar students armed with a really large dictionary, or knowledgebase. These 7th grade grammar student algorithms are able to scour the news, blog and other web content to break every sentence down into key grammatical clauses such as the grammatical subject, verb, and object. The attackers in The Attack Machine are, in essence, the grammatical subjects; the verb is always attack and related verbs like: kill, assault, maim, etc.; and the victims on The Attack Machine are the grammatical objects. So, for example, if a blog post contains a simple sentence or title like: “Israel attacks Hamas.”, this post will appear in the attacker page for Israel, and the victim page for Hamas.

In a blog post titled Evri’s Garden Sprouts Some Search I discuss in detail the underlying search mechanism our scientists and engineers use to power higher level API and application functionality. One of the key higher level API functionalities The Attack Machine leverages is an API resource called Get relations about an entity. This API resource is used, for example, to populate the center column in the individual attack pages such as this one on alligator attacks:

and more specifically, the following REST API call is used:

http://api.evri.com/v1/organism/alligator-0×397510/relations/verb/attack/?media=article&sort=date&includeMatchedLocations=true&appId=evri.com/blog

This API call allows us to automatically identify the key people, places, organizations and things involved in attacks, in addition to getting the articles which correspond to the latest attacks. Now if the user clicks on a specific person, place, or thing, the following API call is used:

http://api.evri.com/v1/organism/alligator-0×397510/relations/verb/attack/location/florida-0×3154d?media=article&sort=date&includeMatchedLocations=true&appId=evri.com/blog

So in this way, we can populate the data for all attacks by alligators in Florida.

Finally, The Attack Machine leverages the Evri API to generate unique natural language content which benefits the reader, as well as significantly helps page SEO. For example, the 1st and third paragraphs in the 1st column in the screen shot above are automatic formulations from API output. In addition, the Evri knowledgebase is leveraged to minimize human editorial contribution. For example, the second paragraph above is written by an editor and linked to either a specific entity, a narrow category for an entity, such as animal, or politician, and a higher level category such as person, organism, or location. Simple logic is then applied at page generation time to select the natural language content from an entity handle if it exists, if not, from a narrow category handle, and if none exists (since we have thousands), then from a higher level category (there are only a handful of these) handle.

That’s all for now. If you have any questions on how to use the Evri API for similar applications, or any other feedback, please let us know on our API forum.

Now that we’ve gotten version 2.0 of EvriVerse in the App Store, it’s time to talk about some of its internals. In this post we’re going to talk about how EvriVerse works with our public API using our open-source Cocoa library. While the library code isn’t specific to the iPhone, the Xcode project that it is part of has a definite iPhone bent to it. Eventually we’ll enhance it to build a Mac OS framework. For now it has been somewhat purpose-built as a static library for iPhone applications.

Using the EvriApi

Using the API starts with creating an instance of the EvriApi class. When you create one you need to provide an application identifier.

EvriApi *api = [[EvriApi alloc] initWithAppID:@"My-Awesome-Evri-Powered-App"];

Right now we aren’t using API keys, but we would appreciate it if you could put some short descriptive text here so we can differentiate between requests when we analyze our API logs.

You only need one instance of this class (it’s thread-safe) so you should keep a reference to it in some globally-available place such as your application delegate class.

The EvriApi is designed for maximum UI responsiveness. Instead of blocking callers until results are returned from our web API, requests are made with a target object and a specific method selector. When the request completes, the callback method will be invoked on the specified target asynchronously. This keeps your main thread of control from blocking which can lead to a lousy user-experience. All of the API-related methods on the EvriApi class implement a signature like:

// assume we have the method -handleCallback:(EvriApiResponse *)response
NSString *requestID = [api makeRequestForSomething:@"A Thing"
                                   performSelector:@selector(handleCallback:)
                                          onTarget:self];

The callback method will be handed an EvriApiResponse instance which can be queried for success and for the message payload:

- (void)handleCallback:(EvriApiResponse *)response {
  if ([response success]) {
    NSArray *entities = (NSArray *)[response responseObject];
    // do cool stuff with entities
  }
  else {
    // handle error case
  }
}

When making a request, it immediately returns a unique request identifier as a string. You can use this to cancel any outstanding requests if the user switches views before the request completes. OK, enough Cocoa details, let’s dig into the API…

Using the API

Newsmakers

So let’s dig in by starting with our new startup screen. Instead of starting with the graph view, we now give you a view of the top newsmakers as we show them on our homepage. This is done by calling the -fetchPopwhyList:withSelector:onTarget: method. The callback method will be delivered an array of PopwhyItems, which are just simple model objects. We use each entry to fill out the table cells in this view, except for the images which are retrieved asynchronously.

The Graph View

Once an entity is selected from the previous screen, we make a call to -fetchTopTargetsForEntity:performSelector:onTarget:. This call will asynchronously deliver an array of Entity objects to the callback method. In EvriVerse we take the top five surrounding entities and render the graph view like so:

Whenever a user touches one of the target entities, we simply re-issue the same query with a different entity URI and rebuild the graph on the callback. Because the results are delivered asynchronously it was easy to split our animations up into changes that execute concurrently with the request (shrinking down nodes we’re going to throw away) and animations that occur after we have received the query results (growing the new nodes).

Note that the Entity objects returned by this call are not fully “fleshed-out”. If you want additional details you need to query the API for them (explained below).

Entity Headlines

On the main entity in the graph view, the user can select one of four sub-views. The first one is the headlines view. Here we request top news articles for an entity like so:

NSString *reqID = [api fetchArticlesForEntity:@"/person/les-paul-0x182c4"
                              performSelector:@selector(handleNews:)
                                     onTarget:self];

The callback method will receive an array of Article objects which contain the headline, a snippet of relevant text and the original URI.

When a user selects one of these articles, we simply push a web view into view with the original article URL as the content source.

Entity Images

One of the new features we’ve added in the 2.0 release of EvriVerse is the ability to browse recent images for the selected entity. To retrieve images for a given entity URI, make a call like this:

NSString *reqID = [api fetchImagesForEntity:@"/person/jimmy-page-0x35793"
                            performSelector:@selector(handleEntityImages:)
                                   onTarget:self];

The callback method will receive an array of ImageData model objects. Note that these objects only contain the URLs for the images, not the image data itself.

Images are associated with their original source, so when a user touches an image we push a web view with the original web page as the source.

Entity Profile

Sometimes you just want to know who or what a particular entity is. This view provides some high-level details to answer that question such as an image, and a description.

To get this kind of information you can call the API like so:

NSString *reqID = [api fetchEntityDetails:@"/person/les-paul-x182c4"
                          performSelector:@selector(handleEntityDetails:)
                                 onTarget:self];

The callback method will return a fleshed-out Entity object.

Entity Connections

The last view in our tour of the EvriVerse application is the entity connections view. This is one of the things that really sets Evri apart from other news applications. The connections listed in this view are always up to date based on what’s going on in the news.

In this example we can see a number of other musicians related to the late, great Les Paul. These connections are culled from the vast array of sources we index on the web. Over time these connections change based on what people are writing about on the web.

To get this information, call the API like this:

NSString *reqID = [api fetchTopTargetsForEntity:@"/person/les-paul-0x182c4"
                                performSelector:@selector(handleRelatedEntities:)
                                       onTarget:self];

The callback method will receive an array of Target objects which contain a URI describing the relationship and the other Entity. We use this information to render the table view above.

When a user selects one of these connected entities we want to display a list of articles constrained to those two items. For example, selecting “Jimmy Page” will return us a list of articles that contains articles with sentences connecting Les Paul with Jimmy Page. To get this information call the API like so:

NSString *reqID = [api fetchArticlesForEntity:@"/person/les-paul-0x182c4"
                                  otherEntity:@"/person/jimmy-page-0x35793"
                              performSelector:@selector(handleArticles:)
                                     onTarget:self];

The callback method will receive an array of Article model objects.

EvriVerse is just one of what will be many ways that we wrap our public API into a compelling user-experience. With the release of EvriApi under an open-source license we are excited to see what other developers do with it. So go get the library, build something cool and wow us!

Every minute of every day people are expressing their sentiments and writing them down in news articles, blog posts, and other web content. Many people are too famous to write down their sentiments, but journalists, bloggers and other content creators are more than willing to document their feelings. Often times a famous radio commentator will bash a politician, or a politician will thrash a Hollywood actress. And on occassion, a true act of heroism will be recognized, and all sorts of famous folk will follow up with praise. Whether depressing or uplifting, disturbing or unnerving, tapping in to the sentiments of key actors on the world stage can be highly informative and engaging.

I’m excited to announce the release of our new sentiment web API which lets you build applications around the sentiments of specific entities (i.e. people, places, or things) as well as categories, or facets. Every minute of every day, Evri’s systems are busy scouring the web, reading news content, blog posts and more so you don’t have to. Now, Evri’s system is also understanding the sentiments, or positive and negative expressions by and about entities.  Many types of applications can be built using the sentiment API in areas including, but not limited to: market intelligence, market research, sports and entertainment, brand management, product reviews and more. Specifically, Evri’s new sentiment API lets you:

• Find the percentage of positive and negative expressions of sentiment made by an entity, or about an entity. For example, find out what percentage of things being written about the iPhone are positive and which percent are negative.
• Discover who is criticizing and who is praising a particular person, place or thing. For example, see who is criticizing and praising Microsoft right now.
• Read what praisers and critics are saying about an entity. For example, see what the GOP are saying about the Democrats.
• Discover who or what your favorite entity is bashing and why. For example, see who Lance Armstrong is complaining about.
• Discover who or what your favorite entity is praising and why. For example, see who the World Health Organization is commending and why.

Now, as an exploratory exercise, or tutorial, on how to use the API, I will walk through the calls needed to make a widget called the Vibology Meter. So, imagine the widget below is externally configured to be about the entity Barack Obama corresponding to the Evri URI: /person/barack-obama-0×16f69. Upon first load, you see something that looks like this:

From the above screenshot, we can see that the percentage of positive sentiment and negative sentiment expressed by Barack Obama are displayed. We can also see the specific top entities being praised by Barack Obama in the left column, and the specific entities being criticized in the right column. For example, from the above screenshot, we see that Barack Obama is criticizing the GOP, Rush Limbaugh, the ACLU, Al Zawahiri, and Israel. In order to render the screenshot above, this sentiment summary information is returned by the following REST API resource call:

/v1/sentiment/summary?sentimentSource=/person/barack-obama-0×16f69&includeSummaryDetails=true&sort=date

Now, consider the use case outlined in the screenshot below, where the user clicks on [Anything] under the positive vibes sentiment. In order to get the results outlined to the right of the positive and negative sentiment columns, we execute a resource request like:

/v1/sentiment/about?sentimentSource=/person/barack-obama-0×16f69&sentimentType=positive&sort=date

From this request URI, we see that the sentimentSource references Barack Obama, meaning we are interested in vibes or sentiment expressed by Obama, as opposed to about him. Next we see the sentimentType is set to positive, meaning we are interested in positive sentiment expressions. Finally, we see sort=date meaning we are interested in the latest results.

Also from the screenshot below, we see the results of this resource request, namely, the specific snippet from the article, as well as a time stamp, the article title, and a link off to the source article. From the snippet, we see the sentence stating that “the president commended…” — the Evri system recognizes “the president” to be the source of the vibes, or sentiment, and commendation to be the prime justification for his positive sentiment expression.

And finally, we consider the case illustrated below, where the “Receiving vibes” tab is selected, and the particular source of negative sentiment is chosen by the user to be Rush Limbaugh. In this case, by executing this resource request:

/v1/sentiment/about?entityURI=/person/barack-obama-0×16f69&sentimentType=negative&sentimentSource=/person/rush-limbaugh-0×1ebf5&sort=date

From this request URI, we see that the entityURI references Barack Obama, meaning the returned sentiment is about Barack Obama. We can also see that the sentimentType is set to negative, meaning returned sentiment expressions will be negative in nature. We also see that the sentimentSource references Rush Limbaugh. The URI referencing Limbaugh was obtained from the sentiment summary results of the request shown above in reference to the first screenshot.

That pretty much sums up our walk through with the sentiment API. For complete documentation on this new API resource, see the Get sentiment information section of our REST API Specification. And finally, if you have any comments on how we can make this API better, questions on how to get things to work, or examples of bugs, please let us know on our developer forum.

I’m excited to announce the launch of our new JavaScript API.  We’ve been using the JavaScript API internally for quite some time, for example, our widgets are built on this flexible and easy to use web API. It feels great to finally open it up to the Evri development community.

The Evri Javascript API utilizes JSONP to make web service requests to Evri’s RESTful API. The JSONP requests are augmented with a set of callbacks similar to those used in many cross-browser Javascript libraries for handling AJAX requests. This allows the Evri Javascript API to return first class objects back to the calling Javascript code without your needing to parse or traverse the JSON returned by Evri’s RESTful API.

Amongst other places, you can check the JavaScript API out in action on a fun new mashup called The Summarizer available at: www.thesummarizer.com. The Summarizer lets you see entities (people, places, or things) present in Twitter tweets about a topic, or by a given Tweeter. For example, you can find entities contained within the latest tweets by @cnn, or all entities in tweets about the Iran Elections. In addition, The Summarizer lets you pivot on one of these related entities, to find other tweets, images, videos, articles, etc. In short, its a great way to explore highly related information to something going on right now, in real time.

So how does it use the Evri JavaScript API? According to Carlos, the rockin developer behind The Summarizer:

We instantiate a Session object which we use for all API calls. We get a TweetsList object by calling Tweet.findFromUsername and findForQuery as needed. The TweetsList has a list of the entities (i.e. people, places and things present in tweets) but it doesn’t have all requisite entity information such as entity descriptions. We retrieve an EntityList by using getEntityDetails. The EntityList has entity names and descriptions. The EntityList is then used to populate the left column. We bind each list item to its respective Entity object. When you click on an entity we make the following calls depending on what right side tab is selected:

• entity.media.getImages is called to populate the Images tab
• entity.media.getVideos is called to populate the Videos tab
• entity.media.getArticles is called to populate the Articles tab
• entity.getRelations to populate the ‘More About’ tab
• entity.getTweetsAbout to populate the Tweets tab

And voila, that’s it. You can read all about the API in the JavaScript API documentation. And as always, ask any question, and please give us feedback on our developer forum.

The Evri iPhone

Here at Evri we love the iPhone. We know that its been a complete game-changer in the mobile-space. And, it seems like this whole iPhone App thing is catching on. So naturally, with so many iPhone fans in the company we thought to ourselves, “hey, we oughtta write an iPhone app!”

Starting as a “20% Time Project”, we’ve put together our first iPhone application that showcases our unique content browsing and discovery engine — and it’s all built with the same APIs that we expose to external developers. We call it “EvriVerse” and it’s available now in the iTunes App Store. We think it’s pretty nifty.

So what does it do? Well, one of the questions that we’re good at answering here at Evri is “what’s going on right now, out in the world?” With our ever-growing structured data store and deep semantic understanding of dynamic web content, we have an awful lot of connected, contextual, relevant information to play with. We do the work of finding important information about topics you care about, and let you browse them in a new way. Let’s take a look…

The initial EvriVerse screen

When you first start the app, you have two places you can go. You can either search for something specific by touching the magnifying glass, or see what’s making news by touching the rainbow. Let’s start with the hot list.

Selecting an entry from the list will take you to our main view where you can see that topic and its top-five connections. The connections are to People, Products, Organizations or other things out in the world that the topic you are interested in is connected to.

Here I’ve selected Wanda Sykes. Touching one of the related topics allows you navigate the what we call the “Entity Web”. Think of this as the ultimate “Six-Degrees of Kevin Bacon” tool.

Touching the main topic will give you a list of current articles, as well as current actions, top connections and profile information for that topic.

“Actions” and “Connections” give you a new way to browse web content about the topic you are interested in. With Actions you will see just that, a list of verbs your topic is engaged in – visiting, speaking, buying, etc.. Connections will show you what things your topic is connected to. Navigating any of these will take you to the list of articles that help you understand the connection. You can then follow this all the way through to the article — and you didn’t need to do any typing to get there!.

This is just the first release of this application and we have a host of features planned in the future. We hope you find it useful, informative and entertaining. Please do let us know what you think, and what features you think we should add. If you have questions or comments, please visit our iPhone Support Page and leave us a note.

Once again, you can download the app here . If you like it, please rate and review it. If you have a problem, please let us know.

Cheers!

The evribot and Relationship Triples

The evribot is an automated Twitter account that tweets extremely brief summaries of news stories. We created the evribot to demonstrate how our API extracts meaningful relationships from unstructured documents on the web. The tweets take the form of (subject, link, target) triples that represent the relationship between a subject entity and a target entity. Triples often represent a single sentence, where the link is a verb and the target is the object. Here’s an example taken from the evribot:

[Eric Holder » closing » Guantanamo Bay]
"Obama's new detainee policy: Break from Bush, or the same?"
→ http://ur.ly/9Ll

In this tweet, the triple is (Eric Holder, closing, Guantanamo Bay) and comes from a sentence in the second to last paragraph of the article. Triples can also be used to represent more general relationships between two entities. For example, (Eric Holder, government agency, United States Department of Justice).

While entity tagging allows one to identify the popular people, places, and things that are in the news, our ability to extract these triples allows us to take a stab at why those entities are in the news. One purpose of the evribot experiment is to see if exposing triples to you, our users, is useful. So tell us what you think.

A Few Technical Details

The evribot is driven by a Ruby script that uses the soon to be released evri-api rubygem that wraps the Evri API for convenient use within Ruby. Here’s an outline of the Evri API calls used to extract the triples that make up the evribot’s tweets (all paths are relative to http://api.evri.com):

First, evribot retrieves a list of popular people using /v1/zeitgeist/entities/person/popular. An entity from this list is used to form the subject of the triple. Given a subject entity, the following calls are made to find the link, target, and related article that make up the tweet:

1. The first relation from /v1/person/eric-holder-0×149fdb/relations is used as the link of the triple.
2. The selected relation of the previous query will contain an href attribute that can be used to find the targets of the relation. Again pick the first item.
   /v1/person/eric-holder-0×149fdb/relations/facet/government-agency
3. Finally, use the targetHref provided in the selected target entity to obtain an article /v1/person/eric-holder-0×149fdb/relations/facet/government-agency/organization/united-states-department-of-justice-0×2ad44?media=articles

If you have questions about the Evri API, you can search for answers and ask questions on our developer mailing list. And if you have feedback for evribot, feel free to send it an “@ reply” or direct message with your thoughts.

We had a great week for the Evri API. At Demo 09 we showed off many of our wares including the recently released Evri Toolbar, our widgets including the Washington Post widget, as well as the entity profile pages; all of these applications are built completely on our public API. I also chatted with many developers about their applications and how the Evri API might help add some powerful features — I was thrilled at the enthusiasm for building on our platform.

In addition to the excitement around Demo 09, I’m happy to announce a few new features in the API. The new work includes:

• support for domain constraints
• support for date constraints
• JSONP support
• alias support for entities
• improved documentation

Support for domain constraints

One of the new features we’ve launched is the ability to constrain your results to particular domains. Below is a screenshot of our Washington Post widget taken from this article titled: New Life for ‘Clean Coal’ Project. In this widget, the default behavior is to include related article results from the washingtonpost.com domain.

This is made possible by the includeDomains and excludeDomains parameters. You can now include a set of domains, or exclude a set of domains for any Get media about an entity resource requests.

Support for date constraints

If you want to constrain related article results to a particular date, you can now do so using the includeDates input parameter like this. For example, we use this API resource to provide trend plots like this one

to show related news, blog posts, and web content on a particular date. This is helpful if you want to find out why a person, place or thing suddenly became important. For example, the screen shot above from the Sri Lanka national cricket team page tragically illustrates the terrorist incident against the team propelled the massive news coverage.

JSONP support

Many of our developers were asking for JSONP callback support. So, voila, its here. See the REST API specification for details on how to use it.

Alias support

Another great little feature is we now include aliases for entities returned in the Get entity network about some text resource. For example, in this sentence:

Seattle, a city in the United States, also known as the USA, or US, is nice in the December months when Pearl Jam and Alice in Chains are rocking out.

if you click HERE to see the returned network, you might notice that US, and USA are returned as aliases for the United States. Our system now automatically recognizes the terms US and USA as aliases, or synonyms, of the United States. This feature is helpful for many applications. For example, some of our developers wanted to track and display to users the common alias forms of an entity so their users can understand what name forms are typically used on the web. In another application, developers wanted to be able to highlight the many forms of an entity on a page. For example, an entity like Barack Obama might be referred to as Obama, Barack, and Barack Obama and the application needs to highlight them all.

Improved documentation

Finally, we’ve had some great feedback from you, our developers, on ways to improve our documenation to make it easier to get started. Special thanks to Doug for really spending a lot of time giving us detailed examples. Among other things, we’ve cleaned up the input parameters section, added additional examples, and added an Example scenarios section to help better communicate how to use the results of one resource call, as input to another.

And on a final note, if you haven’t signed up for our Developer Forum, please do so. It’s the best place to ask questions, and get answers on all things related to the Evri API.

Last week we had our first ever Evri Holiday Hackathon. A bunch of us locked ourselves into a hotel for a couple days and hacked away on our laptops building new apps using Evri’s API. It was a blast; we ate great food, hacked great code, and lots of wonderful applications came out. At the end of the contest, all present voted on their favorite app.

This year, 3rd place went to Seth and Phil for a great game called Connected to Whom. Second place went to Arun who created an engaging music browsing mashup. And the winners were Carsten and Satish who built an Evri Twitter widget that plugs into our entity detail pages; whenever you go to an Evri page about an entity (person, place or thing), the Evri Twitter widget uses Twitter to find the most recent buzz (tweets in Twitter-speak) about that entity. In addition, the Evri Twitter widget automatically identifies other entities present in tweets and prepares links to other Evri entity pages. The result is an entertaining way to surf through the entity web while riding the latest buzz wave.

You can try it out. You’ll need to install GreaseMonkey onto your Firefox browser (sorry, no other browser support yet) in case you don’t already have it. Then click HERE to install the widget. Finally, take it out for a spin at www.evri.com and go to your favorite entity page; the tweets are shown just below the videos. Here is a screenshot:

We hope to open our Hackathon contest up publicly sometime next year, and we’d love to see you all there. In the mean time, check out our API, build some great stuff, and tell us all about it on the Evri API Group page. And on a final note, here’s a slideshow from the Hackathon:

We are excited to announce that an early preview of our API is available for you to take out for a spin.

The Evri API gives you programmatic access to Evri’s rich mapping of the entity web, or the web of people, places and things connected to one another via language itself. The Evri API exposes portions of Evri’s deep NLP based technology as well as Evri’s extensive knowledgebase of information about entities. For more on Evri’s technology, please see the tech talk pages on the Evri blog. Most functionality seen on www.evri.com as well as that exposed via Evri widgets is based on the Evri API.

The Evri API is a REST based service whose results are returned in either XML or JSON and can be easily processed in most programming languages including, but not limited to: JavaScript, Python, Ruby, Perl, ActionScript, Java, C#, C, C++ and more. Among other things, the Evri API enables you to find:

• Entities located in an article or body of text
• Popular entities on the entity web broken down by various categories like politician, actor or film.
• Structured information about an entity including things like birth date, death date, universities attended, children, etc.
• How entities are related including the news, blog, or web language that links them on the entity web
• How entities or combinations of entities are related to documents, images and video found on the web
• Media recommendations for entities, or combinations of entities, based on a specific news, blog, or web article mention.

Here are some example questions which the Evri API can help answer:

• Who is popular on the Internet right now? Or more specifically, which actors, politicians, products, or films are popular right now?
• Who is Barack Obama being welcomed by? Who is Obama being criticized by?
• How can I find related articles, images, or videos to the article I am reading?
• What is the relationship between Google and Yahoo right now?
• What actions is AC/DC performing?
• Who is Microsoft acquiring?

The Evri API is currently in an early preview stage. Only a small portion of our extensive knowledgebase and NLP based text analysis and search infrastructure is currently exposed. We are committed to exposing more and more of our powerful entity web platform over time; this preview release is the first step.

To get started, please see the complete Evri API documentation available at: www.evri.com/developer/index.html. Have fun, and please use the Evri API Group to ask questions and find answers about the Evri API. We will respond to your questions as promptly as we can.