If my travel schedule was any indication, the conference season was in full swing in October. Each week was spent either absorbing new information or speaking at conferences (two in the translation industry and three in technology).

Jessica did a great recap on our observations from the translation industry conferences, so I wanted to share my experiences and observations from two marquee API-related events, API World and API Strategy & Practice.

For me, there were four key takeaways from both:

• There are (finally?!) some trends and best practices emerging in API documentation
• There are even more new tools now to help test and debug APIs
• There’s a growing tool base focused on simplifying the education and onboarding process for integrating third party APIs
• Scaling both technology and teams is hard. There’s no one-size-fits-all approach, and processes and applications will vary by stages of growth. If anything, the difficulty in scaling is identifying when to shift gears. Have you ever tried shifting gears without using the clutch?

As I share a smattering of highlights below, I hope you’ll see it as a testament to the breadth of the current API landscape. There’s a lot of interest in how APIs can create value, yet a recognition that “…developer love is an extremely scarce asset.” I think that’s very true; platforms that are strongest in communicating with developers will be the most successful.

Trending API documentation best practices

An obvious key element to communicating with developers who work with APIs is the documentation. Jakob from apiary.io reckons that an “API is the UI to data.” Indeed, what better way to show how easy something is than by not having an instruction manual?
To help us reach that utopia, I noticed a growing number of tools that all hint at a trend towards standardization in API documentation. To simplify the process of keeping documentation in sync with implementation, endpoint description languages are clearly becoming a best practice. It’s great to see the options increasing, with no obvious winner—yet.

Proliferation of API debugging tools

The plethora of testing and debugging tools was one of the most fun conference findings. When it comes to finding bugs in your API, John Sheehan of Twilio, IFTTT and now RunScope fame said it best:  “…the best way to break an API is give it to someone else.” Indeed, I’ll be the first to admit we’ve experienced this firsthand!
Of course, customers don’t usually appreciate surprises, so to test internally as much as possible here’s a shortlist of tools you may find new and useful:

• requestbin.com — see what clients are generating (helps you debug web hooks)
• ngrok.com — give a local machine a public URL for debugging web hooks
• mitmproxy.org — for interacting with HTTP traffic between API and client
• hurl.it — simulates HTTP requests via a browser
• PonyDebugger — browser-based way for debugging iOS traffic (by Square)
• frisby.js — node.js-based endpoint testing
• VCR — create test suites for HTTP interactions, with a focus on speed
• mocky.io — a mock version of apiary.io

Authentication is another area a growing number of tools and libraries are trying to solve, specifically for OAuth. The folks at WebShell provide their solution through OAuth, while the guys at Mashape have a nice explanation of the complicated standard in the OAuth bible and their own solution in guardian.js. Mashape even goes a step further by providing their version of an HTTP request library at unirest.

Robust ecosystems are built on good communication

The most important component for nurturing an API ecosystem is trust, which is established through communication. Developers must know where to go for the latest information and be well-informed enough to make quick judgment calls.

However, as former editor of ProgrammableWeb John Musser points out, when an API goes down (and let’s be real, it’s always when and not if), platforms have numerous ways to notify their developer community, whether via a blog, dedicated developer forums, social media, change logs, email announcements, GitHub, API docs… the list goes on. So many mediums through which to communicate can seem daunting for both the service provider and developer.

API ecosystems must therefore become robust through consistency and transparency. I think one of the best presentations articulating the importance of this level of communication came from Adam DuVander, who coined three Cs that make an API irresistible: clarity, cost and community.

Clarity: exposing industry best practices for authentication (like LinkedIn’s OAuth test console), or making clear which client libraries are official while supporting others (as Twilio does). You could also call this accessibility.

Cost: helping developers know what limits to keep in mind, like rate limits, usage limits, pricing plans, etc. Google’s API console, for example, has solid developer communication and transparency.

Community: having mechanisms that reward developers working with an API encourages greater adoption. The Yellow API has an app gallery, which has seen positive results for YP. Platform-focused events like Twiliocon and Evernote’s EC, or event-coordination services like Hacker League and ChallengePost, are also good examples that show how to give a little developer love.

Wrappin’ it up

It’s exciting to see so much activity and support around something seemingly as mundane as an API. But, in fact, it’s all testament to how important a role the supporting ecosystem is in encouraging third party adoption.

To that effect, we recently launched our events community page and a much simpler Getting Started guide to our API. We look forward to further improving our relationship with the Gengo API developer community with more accessibility, transparency and developer love.

Go global with Gengo’s people-powered translation platform.

Get Started   or Contact us