Products new2019-06-11T19:39:30-03:00

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

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()

}

}
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()
}

}
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(Order ${order.number})

order.prices.foreach { p =
println(s - ${p.name.getOrElse(price)}: ${p.label})
}

println(s - TOTAL: ${order.total.label})

client.closeAsyncHttpClient()
}

}