Braintree::Transaction.sale(
  :amount => "100.00",
  :credit_card => {
    :number => "5105105105105100",
    :expiration_date => "12/2020"
  }
)

Braintree_Transaction::sale(array(
  'amount' => '100.00',
  'creditCard' => array(
    'number' => '5105105105105100',
    'expirationDate' => '12/2020'
  )
));

braintree.Transaction.sale({
    "amount": "100.00",
    "credit_card": {
        "number": "5105105105105100",
        "expiration_date": "12/2020"
    }
})

gateway.transaction().sale(new TransactionRequest()
  .amount(new BigDecimal("100.00"))
  .creditCard()
    .number("5105105105105100")
    .expirationDate("12/2020")
    .done()
);

Net::Braintree::Transaction->sale({
  amount => "100.00",
  credit_card => {
    number => "5105105105105100",
    expiration_date => "12/2020"
  }
});

gateway.Transaction.Sale(new TransactionRequest
{
    Amount = 100.00M,
    CreditCard = new TransactionCreditCardRequest
    {
      Number = "5105105105105100",
      ExpirationDate = "12/2020"
    }
});

var saleRequest = {
  amount: '100.00',
  creditCard: {
    number: '510510510510510',
    expirationDate: '12/2020'
  }
};

gateway.transaction.sale(saleRequest, function (err, result) {
  // Handle result
});

Braintree::Customer.create(
  :first_name => params[:first_name],
  :last_name => params[:last_name],
  :credit_card => {
    :billing_address => {
      :postal_code => params[:postal_code]
    },
    :number => params[:number],
    :expiration_month => params[:month],
    :expiration_year => params[:year],
    :cvv => params[:cvv]
  }
)

Braintree_Customer::create(array(
  'firstName' => $request->get('first_name'),
  'lastName' => $request->get('last_name'),
  'creditCard' => array(
    'billingAddress' => array(
      'postalCode' => $request->get('postal_code')
    ),
    'number' => $request->get('number'),
    'expirationMonth' => $request->get('month'),
    'expirationYear' => $request->get('year'),
    'cvv' => $request->get('cvv')
  )
))

braintree.Customer.create({
    "first_name": request.form["first_name"],
    "last_name": request.form["last_name"],
    "credit_card": {
        "billing_address": {
            "postal_code": request.form["postal_code"]
        },
        "number": request.form["number"],
        "expiration_month": request.form["month"],
        "expiration_year": request.form["year"],
        "cvv": request.form["cvv"]
    }
})

CustomerRequest customerRequest = new CustomerRequest()
  .firstName(request.queryParams("first_name"))
  .lastName(request.queryParams("last_name"))
  .creditCard()
    .billingAddress()
      .postalCode(request.queryParams("postal_code"))
      .done()
    .number(request.queryParams("number"))
    .expirationMonth(request.queryParams("month"))
    .expirationYear(request.queryParams("year"))
    .cvv(request.queryParams("cvv"))
    .done();

Net::Braintree::Customer->create({
  first_name => param("first_name"),
  last_name => param("last_name"),
  credit_card => {
    billing_address => {
      postal_code => param("postal_code")
    },
    number => param("number"),
    expiration_month => param("month"),
    expiration_year => param("year"),
    cvv => param("cvv")
  }
});

CustomerRequest request = new CustomerRequest
{
    FirstName = collection["first_name"],
    LastName = collection["last_name"],
    CreditCard = new CreditCardRequest
    {
        BillingAddress = new CreditCardAddressRequest
        {
            PostalCode = collection["postal_code"]
        },
        Number = collection["number"],
        ExpirationMonth = collection["month"],
        ExpirationYear = collection["year"],
        CVV = collection["cvv"]
    }
};

var customerRequest = {
  firstName: req.body.first_name,
  lastName: req.body.last_name,
  creditCard: {
    billingAddress: {
      postalCode: req.body.postal_code
    },
    number: req.body.number,
    expirationMonth: req.body.month,
    expirationYear: req.body.year,
    cvv: req.body.cvv
  }
};

gateway.customer.create(customerRequest, function (err, result) {
  // Handle result
});

Braintree::Subscription.create(
  :payment_method_token => payment_method_token,
  :plan_id => "test_plan_1"
)

Braintree_Subscription::create(array(
  'paymentMethodToken' => $payment_method_token,
  'planId' => 'test_plan_1'
));

braintree.Subscription.create({
    "payment_method_token": payment_method_token,
    "plan_id": "test_plan_1"
})

SubscriptionRequest req = new SubscriptionRequest()
  .paymentMethodToken(paymentMethodToken)
  .planId("test_plan_1");

Net::Braintree::Subscription->create({
  payment_method_token => $payment_method_token,
  plan_id => "test_plan_1"
});

SubscriptionRequest request = new SubscriptionRequest
{
    PaymentMethodToken = paymentMethodToken,
    PlanId = "test_plan_1"
};

var subscriptionRequest = {
  paymentMethodToken: customer.creditCards[0].token,
  planId: "test_plan_1"
};

gateway.subscription.create(subscriptionRequest, function (err, result) {
  // Handle result
});