
Flow Modules
Flow is revolutionizing how merchants go global
MODULAR
With all components available as stand-alone modules
FLEXIBLE
With all variables and components configurable
COMPLETE
With every aspect of cross-border e-commerce offered

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
A/B Testing
Optimize onsite conversion by locale through A/B testing of all aspects of the customer journey


Flow Global E-Commerce 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

1 2 3 4 5 6 7 | 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 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'
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | 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 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
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 | 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() } } |
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() } }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | 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 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'
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 | 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 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]
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 | 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() } } |
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() } }
1 2 3 4 5 6 7 8 9 10 11 12 13 | 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 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'
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 | 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 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}
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 | 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(Order ${order.number}) order.prices.foreach { p = println(s - ${p.name.getOrElse(price)}: ${p.label}) } println(s - TOTAL: ${order.total.label}) client.closeAsyncHttpClient() } } |
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(Order ${order.number}) order.prices.foreach { p = println(s - ${p.name.getOrElse(price)}: ${p.label}) } println(s - TOTAL: ${order.total.label}) client.closeAsyncHttpClient() } }