(888) 475-FLOW
(888) 475-FLOW
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
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.
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.