(888) 475-FLOW

FLOW THE NEXT-GENERATION
FOR CROSS-BORDER E-COMMERCE

Flow Modules

Flexible • Complete • Modular

Flow is revolutionizing how merchants go global
Flexible - with all variables and components configurable
Complete - with every aspect of cross-border e-commerce offered
Modular - with all components available as stand-alone modules

Localization

Hyper-localized shopping experience across your site with local displays, formats, payments, catalogs and more

Pricing

Full price, margin and currency control across your site funnel and with infinite flexibility

Landed Costs

Real-time duty, tax and restrictions feeds for purchases anywhere, with any site display option

Payments

Broad payment options and local methods for maximum conversion and acceptance by region

Logistics

Flexible, simple, low cost ship options with full pricing control and ship policy management

Customer Service

Complete customer service management, integrated or stand-alone, with total data ownership

Analytics

Real-time data with rich analytics into all aspects of your global business and site funnel

FLOW TECHNOLOGY

Flexibility • Control • Transparency

Flow is designed from the start with complete, simple REST APIs. We believe in flexibility, control and transparency, so all Flow products use the exact same API that are provided to clients. Flow is modern, cloud-native and fit-for-purpose.

SO … USING FLOW IS ALWAYS SIMPLE

Landed Cost Curl
# Products in Flow are localized (duty, tax, and currency calculated) by 
# experience; usually by country. The curl command below will find the 
# best experience and localized items for Canada, in this example.


curl --silent -u HlGgfflLamiTQJ: \
'https://api.flow.io/playground/experiences/items?country=CAN'
Landed Cost Ruby
# Products in Flow are localized (duty, tax, and currency calculated) by 
# experience; usually by country. The ruby code below will find the 
# best experience and localized items for Canada, in this example.

require 'flowcommerce'

ORG = 'playground'
client = FlowCommerce.instance(:token => 'HlGgfflLamiTQJ')

client.experiences.get_items(ORG, :country => 'CAN', :number => ['sku-1', 'sku-2']).each do |i|
 puts i.number
 i.local.prices.each do |price|
 case price.key
 when "localized_item_price"
 puts " - Price: #{price.label}"
 when "localized_item_vat"
 puts " - #{price.name}: #{price.label}"
 when "localized_item_duty"
 puts " - Duty: #{price.label}"
 end
 end
end
Landed Cost Scala
# Products in Flow are localized (duty, tax, and currency calculated) by 
# experience; usually by country. The scala code below will find the 
# best experience and localized items for Canada, in this example.

import io.flow.v0.{Authorization, Client}
import io.flow.v0.models._

object Main extends App {

 import scala.concurrent.ExecutionContext.Implicits.global

 val client = new Client(auth = Some(Authorization.Basic("HlGgfflLamiTQJ")))
 val org = "playground"

 client.experiences.getItems(
 org,
 country = Some("CAN"),
 number = Some(Seq("sku-1", "sku-2"))
 ).map { items =>
 
 items.foreach { i =>
 println(i.number)
 i.local.map(_.prices).get foreach {
 case p: LocalizedItemPrice =>
 println(s" - Price: ${p.label}")
 
 case p: LocalizedItemVat =>
 println(s" - ${p.name}: ${p.label}")
 
 case p: LocalizedItemDuty =>
 println(s" - Duty: ${p.label}")
 
 case p: LocalizedTotal =>
 println(s" - Total: ${p.label}")
 
 case LocalizedPriceUndefinedType(_) =>
 // Placeholder for future types
 }
 }
 
 client.closeAsyncHttpClient()
 
 }

}
Orders Curl
# Create an order with two units of sku-2
curl --silent \
 -u HlGgfflLamiTQJ: \
 -X PUT \
 -d items[number]=sku-2 \
 -d items[quantity]=2 \
 -d destination[streets]="123 Yonge Street" \
 -d destination[city]="Toronto" \
 -d destination[province]="Ontario" \
 -d destination[postal]="M5C 1W4" \
 -d destination[country]="CAN" \
 'https://api.flow.io/playground/orders/R726941?country=CAN'
Orders Ruby
# Create an order with two units of sku-2

require 'flowcommerce'

ORG = 'playground'
client = FlowCommerce.instance(:token => 'HlGgfflLamiTQJ')

order = client.orders.put_by_number(ORG, 'R726941',
 ::Io::Flow::V0::Models::OrderPutForm.new(
 :items => [
 { :number => "sku-2", :quantity => 2 }
 ],
 :destination => {
 :streets => ["123 Yonge Street"],
 :city => "Toronto",
 :province => "Ontario",
 :postal => "M5C 1W4",
 :country => "CAN"
 }
 ),
 :country => "CAN"
 )

puts "Order %s" % order.number
order.prices.each do |p|
 puts " - #{p.name}: #{p.label}"
end
puts " - TOTAL: #{order.total.label}"
Orders Scala
# Create an order with two units of sku-2

import io.flow.v0.{Authorization, Client}
import io.flow.v0.models._

object Main extends App {

 import scala.concurrent.ExecutionContext.Implicits.global

 val client = new Client(auth = Some(Authorization.Basic("HlGgfflLamiTQJ")))
 val org = "playground"

 client.orders.putByNumber(
 org,
 "R726941",
 orderPutForm = OrderPutForm(
 items = Seq(
 LineItemForm(number = "sku-2", quantity = 2)
 ),
 destination = Some(
 OrderAddress(
 streets = Some(Seq("123 Yonge Street")),
 city = Some("123 Yonge Street"),
 province = Some("Ontario"),
 postal = Some("M5C 1W4"),
 country = Some("CAN")
 )
 )
 ),
 country = Some("CAN")
 ).map { order =>
 
 println(s"Order ${order.number}")
 
 order.prices.foreach { p =>
 println(s" - ${p.name.getOrElse("price")}: ${p.label}")
 }
 
 println(s" - TOTAL: ${order.total.label}")
 
 client.closeAsyncHttpClient()
 }

}
Payments Curl
# Add a card
curl --silent \
 -u HlGgfflLamiTQJ: \
 -d name="Joe Smith" \
 -d number="4111 1111 1111 1111" \
 -d cvv=123 \
 -d expiration_month=12 \
 -d expiration_year=2020 \
 'https://api.flow.io/playground/cards'

# Authorize payment through Flow
curl --silent \
 -u HlGgfflLamiTQJ: \
 -d discriminator="merchant_of_record_authorization_form" \
 -d amount=10.50 \
 -d currency=CAD \
 -d order_number=R726941 \
 -d token=F96JX9zqOP1aCYbna1dMHz2r2hxxhQ9ZSw8T79LjJXtORkwbNAlYL2MTEli4VJEs \
 'https://api.flow.io/playground/authorizations'
Payments Ruby
# Add a card

require 'flowcommerce'

ORG = 'playground'
client = FlowCommerce.instance(:token => 'HlGgfflLamiTQJ')

card = client.cards.post(ORG,
 ::Io::Flow::V0::Models::CardForm.new(
 :number => "4012888888881881",
 :name => "Joe Smith",
 :expiration_month => 1,
 :expiration_year => 2020,
 :cvv => "737"
 )
 )

puts "Card created - secure token is: %s" % card.token
 
auth = client.authorizations.post(ORG,
 ::Io::Flow::V0::Models::MerchantOfRecordAuthorizationForm.new(
 :order_number => 'R726941',
 :token => card.token
 )
 )

puts "Authorization created for %s %s [id: %s]" % [auth.amount, auth.currency, auth.id]

capture = client.captures.post(ORG,
 ::Io::Flow::V0::Models::CaptureForm.new(
 :authorization_id => auth.id
 ))
puts "Capture created for %s %s [id: %s]" % [capture.amount, capture.currency, capture.id]
Payments Scala
# Add a card
import io.flow.v0.{Authorization, Client}
import io.flow.v0.models._

object Main extends App {

 import scala.concurrent.ExecutionContext.Implicits.global

 val client = new Client(auth = Some(Authorization.Basic("HlGgfflLamiTQJ")))
 val org = "playground"

 import scala.concurrent.Future
 
 for {
 card <- client.cards.post(
 org,
 CardForm(
 number = Some("4012888888881881"),
 name = "Joe Smith",
 expirationMonth = 1,
 expirationYear = 2020,
 cvv = "737"
 )
 ).recoverWith {
 case ex => Future.successful {
 client.closeAsyncHttpClient()
 println(s"ERROR: ${ex}")
 throw ex
 }
 }
 
 auth <- client.authorizations.post(
 org,
 MerchantOfRecordAuthorizationForm(
 orderNumber = "R726941",
 token = card.token
 )
 ).recoverWith {
 case ex => Future.successful {
 client.closeAsyncHttpClient()
 println(s"ERROR: ${ex}")
 throw ex
 }
 }
 
 capture <- client.captures.post(
 org,
 CaptureForm(
 authorizationId = auth.id
 )
 ).recoverWith {
 case ex => Future.successful {
 client.closeAsyncHttpClient()
 println(s"ERROR: ${ex}")
 throw ex
 }
 }
 
 } yield {
 println(s"Card created - secure token is ${card.token}")
 println(s"Authorization created for ${auth.amount} ${auth.currency} [id ${auth.id}]")
 println(s"Capture created for ${capture.amount} ${capture.currency} [id ${capture.id}]")
 
 client.closeAsyncHttpClient()
 }

}

In addition to the complete HTTP REST API, Flow offers native
SDKs for the full suite of APIs in Scala, Ruby, Node, Go Lang, and Java.