Skip to main content

Introducing Pipeable

· 5 min read
Deyan Vitanov
Juan Lozano
Petar Dobrev

For the past few months we have been working on the PipeableSDK and today we are excited to show it to you all!

What is Pipeable?

Pipeable is an open-source iOS and (soon) Android SDK that allows developers to programmatically control webviews in mobile apps. Webviews are essentially in-app browsers that display web content directly within the app. If you are familiar with Puppeteer or Playwright, Pipeable serves a similar purpose but for these embedded browsers, offering granular control over web interactions.

What can you use Pipeable for?

You can use Pipeable anytime you want to automate interactions with third-party websites within your mobile app. To illustrate, let's dive into a concrete example: an automation that searches HackerNews for a specific query (in this case "web automation") and retrieves the titles of relevant stories.

// Navigate to a web page
try? await page.goto("https://news.ycombinator.com", waitUntil: .networkidle)

// Wait for the search form to load so we can interact with it
let searchForm = try await page.waitForXPath(
"//form[contains(@action, 'hn.algolia.com')]", visible: true
)

// Find the search bar text input and type the query "web automation" into it
let textAreaEl = try await searchForm?.querySelector("input[type='text']")
try await textAreaEl!.type("web automation", delay: 50)

// Submit the search
try await page.submitActiveForm()

// Wait for the results page
try await page.waitForURL { url in url.contains("hn.algolia") }

// Wait for the search results to be visible
try await page.waitForSelector(".Story_title", visible: true)

// Get all the story title elements from the page
let stories = try await page.querySelectorAll(".Story_title a > span")

var storyTitles: [String] = []
for story in stories {
// Get the text content for each story title
if let title = try await story.textContent() {
storyTitles.append(title)
}
}
print(storyTitles)

A couple of things to note:

  • The automation is operating directly on the website’s document object model (DOM) and allows you, the developer, to do anything that a user can do, even if there is no API or the API is restricted.
  • If you are familiar with Playwright or Puppeteer then the above code should look familiar to you and this is intentional, we designed Pipeable to be broadly compatible with these frameworks (see Pipeable Scripting below).
  • You can checkout the full code in a sample app here.

Agentic AI

While Pipeable can be used for many things, we are particularly excited about unlocking agentic AI on mobile through the power of webview automation. Specifically the ability to connect to 3rd party websites and perform actions there on behalf of the user, from within a mobile app. This capability paves the way for richer, more dynamic app experiences, turning mobile applications into powerful tools that not only access web information but interact with web ecosystems on behalf of users. We're eager to see the creative solutions developers will build with Pipeable, enhancing mobile app functionality and empowering users.

To get a feel for what this could look like you can check out a simple AirBnB booking agent that we built with Pipeable and GPT4 in our samples repo.

Why webviews and Pipeable?

We think that Pipeable and webviews are a great fit for automations for a number of reasons:

  • Because webviews are integrated with mobile OS-es, users can log into websites using their preferred mobile authentication workflow (leveraging FaceID, TouchID, etc.) without the need to explicitly share or type credentials. Handling CAPTCHAs, 2FA, etc. is similarly fluid.
  • Automations leverage the website’s document object model (DOM) and allow AI agents to do anything that a user can do, even when there is no API or the API is restricted.
  • Automations can be executed entirely on the client for better privacy and security. Also, developers can offer an option to continue the session in the cloud using Pipeable Scripting for better convenience and more flexibility.

Pipeable Scripting

The final cornerstone of the PipeableSDK is PipeableScript, a runtime environment that allows developers to write their automations in TypeScript/JavaScript, while still enabling execution directly on mobile devices. This has two key benefits:

  • You can dynamically load your scripts into your app at runtime, this means that if the underlying website changes and your automation breaks you can simply fix the script and deploy it to your app without going through the full app update process.
  • The scripts you write are broadly compatible1 with Playwright and Puppeteer, this means that you can run your PipeableScript in Playwright or Puppeteer if you want to execute your script on a server. This can be especially helpful for certain types of tasks which are long running or compute intensive.

Conclusion

Thanks for making it this far! If you are interested in learning more, you can check out out Github repo or try out one of our sample apps. If you want to receive updates about Pipeable, you can sign up for updates here. We are very excited about collaborating with folks building Agentic AI on mobile, if this is you, please grab some time on our Calendly, send us an email or DM us on Twitter.

Footnotes

  1. We are still working through all the details here, if you have a use case where this compatibility would be helpful please grab some time on our Calendly, send us an email or DM us on Twitter.