# Live API url
https://api.placepay.com/

# Test API url
https://test-api.placepay.com/

# Live API
import place
place.api_key = 'private_key_6fsMi3GDxXg1XXSluNx1sLEd'

# Test API
import place
place.api_key = 'test_private_key_dwjVajaCQKO4RJuV'

# Live API
require 'place'
Place.api_key = 'private_key_6fsMi3GDxXg1XXSluNx1sLEd'

# Test API
require 'place'
Place.api_key = 'test_private_key_dwjVajaCQKO4RJuV'

<?php
# Live API
require_once('vendor/autoload.php');
Place\Place::$api_key = 'private_key_6fsMi3GDxXg1XXSluNx1sLEd'
?>

<?php
# Test API
require_once('vendor/autoload.php');
Place\Place::$api_url = 'test_private_key_dwjVajaCQKO4RJuV';
?>

// Live API url
var place = require('place-api');
place.api_key = 'private_key_6fsMi3GDxXg1XXSluNx1sLEd'

// Test API url
var place = require('place-api');
place.api_key = 'test_private_key_dwjVajaCQKO4RJuV'

// Live API url
PlaceClient.api_key = "private_key_6fsMi3GDxXg1XXSluNx1sLEd";

// Test API url
PlaceClient.api_key = "test_private_key_dwjVajaCQKO4RJuV";

# To install using pip:
pip install place-api

# To install using Bundler:
gem 'place-api', '~> 0.5.5'

# To install using gem:
gem install place-api

# To install using Composer:
composer require place/place-api

// To install using npm:
npm install place-api

https://github.com/placepay/place-csharp.git

# Using curl, you can pass the API key with each request
# Make sure to append your API key with `:` when using `curl`.
curl "https://api.placepay.com/transactions" \
    -u private_key_6fsMi3GDxXg1XXSluNx1sLEd:

import place
place.api_key = 'private_key_6fsMi3GDxXg1XXSluNx1sLEd'

require "place"
Place.api_key = "private_key_6fsMi3GDxXg1XXSluNx1sLEd"

<?php
require_once('vendor/autoload.php');
Place\Place::$api_key = "private_key_6fsMi3GDxXg1XXSluNx1sLEd";
?>

var place = require('place-api')
place.api_key = 'private_key_6fsMi3GDxXg1XXSluNx1sLEd'

PlaceClient.api_key = "private_key_6fsMi3GDxXg1XXSluNx1sLEd";

# Single mode
curl "https://api.placepay.com/transactions/gkXzxwqyMw7LWAIFJecc4I90" \
    -u private_key_6fsMi3GDxXg1XXSluNx1sLEd:

import place
place.api_key = 'private_key_6fsMi3GDxXg1XXSluNx1sLEd'

# Single mode
transaction = place.Transaction.get('gkXzxwqyMw7LWAIFJecc4I90')

require "place"
Place.api_key = "private_key_6fsMi3GDxXg1XXSluNx1sLEd"

# Single mode
transaction = Place::Transaction.get('gkXzxwqyMw7LWAIFJecc4I90')

<?php
Place\Place::$api_key = "private_key_6fsMi3GDxXg1XXSluNx1sLEd";

# Single mode
$transaction = Place\Transaction::get('gkXzxwqyMw7LWAIFJecc4I90');
?>

var place = require('place-api')
place.api_key = 'private_key_6fsMi3GDxXg1XXSluNx1sLEd'

// Single mode
place.Transaction.get('gkXzxwqyMw7LWAIFJecc4I90')
    .then(function(transaction){})

PlaceClient.api_key = "private_key_6fsMi3GDxXg1XXSluNx1sLEd";

// Single mode
PlaceTransaction transaction = PlaceTransaction.get("gkXzxwqyMw7LWAIFJecc4I90");

# Query mode
curl "https://api.placepay.com/transactions/?type=refund" \
    -u private_key_6fsMi3GDxXg1XXSluNx1sLEd:

# Query mode
transaction = place.Transaction.select( type='refund' )

# Query mode
transaction = Place::Transaction.select( type: "refund" )

<?php
# Query mode
$transaction = Place\Transaction::select(array('type'=>'refund'));
?>

// Query mode
place.Transaction.select({ type: 'refund' })
    .then(function(transaction){})

// Query mode
PlaceTransaction transaction = PlaceTransaction.select(new { type="refund" });

# Single mode
curl "https://api.placepay.com/accounts/" \
    -u private_key_6fsMi3GDxXg1XXSluNx1sLEd: \
    -d email="joe.chip@example.com" \
    -d full_name="Joe Chip" \
    -d user_type="payer"

# Single mode
account = place.Account.create(
    email='joe.chip@example.com',
    full_name='Joe Chip',
    user_type='payer'
)

# Single mode
account = Place::Account.create(
    email: 'joe.chip@example.com',
    full_name: 'Joe Chip',
    user_type: 'payer'
)

<?php
# Query mode
$account = Place\Account::create(array(
    'email'=>'joe.chip@example.com',
    'full_name'=>'Joe Chip',
    'user_type'=>'payer'
));
?>

// Single mode
place.Account.create({
    email: 'joe.chip@example.com',
    full_name: 'Joe Chip',
    user_type: 'payer'
}).then(function(account) {});

// Single mode
PlaceAccount account = PlaceAccount.create(new {
    email="joe.chip@example.com",
    full_name="Joe Chip",
    user_type="payer"
})

# Bulk mode
curl "https://api.placepay.com/accounts/" \
    -u private_key_6fsMi3GDxXg1XXSluNx1sLEd: \
    -d [0]email="joe.chip@example.com" \
    -d [0]full_name="Joe Chip" \
    -d [0]user_type="payer" \
    -d [1]email="glen.runciter@example.com" \
    -d [1]full_name="Glen Runciter" \
    -d [1]user_type="payer"

# Bulk mode
accounts = place.Account.create([
    place.Account(
        email='joe.chip@example.com',
        full_name='Joe Chip',
        user_type='payer'
    ),
    place.Account(
        email='glen.runciter@example.com',
        full_name='Glen Runciter',
        user_type='payer'
    )
])

# Bulk mode
accounts = Place::Account.create([
    Place::Account.new(
        email: 'joe.chip@example.com',
        full_name: 'Joe Chip',
        user_type: 'payer'
    ),
    Place::Account.new(
        email: 'glen.runciter@example.com',
        full_name: 'Glen Runciter',
        user_type: 'payer'
    )
])

<?php
# Bulk mode
$account = Place\Account::create(array(
    new Place\Account(array(
        'email'=>'joe.chip@example.com',
        'full_name'=>'Joe Chip',
        'user_type'=>'payer'
    )),
    new Place\Account(array(
        'email'=>'glen.runciter@example.com',
        'full_name'=>'Glen Runciter',
        'user_type'=>'payer'
    ))
));
?>

// Bulk mode
place.Account.create([
    place.Account({
        email: 'joe.chip@example.com',
        full_name: 'Joe Chip',
        user_type: 'payer'
    }),
    place.Account({
        email: 'glen.runciter@example.com',
        full_name: 'Glen Runciter',
        user_type: 'payer'
    })
]).then(function(account) {});

// Bulk mode
List<PlaceAccount> accounts = PlaceAccount.create(new[]{
    new PlaceAccount(){
        email="joe.chip@example.com",
        full_name="Joe Chip",
        user_type="payer"
    },
    new PlaceAccount(){
        email="glen.runciter@example.com",
        full_name="Glen Runciter",
        user_type="payer"
    }
});

# Single mode
curl "https://api.placepay.com/accounts/rqlPhhU3aJ8DWBF5zPJI8HrU" \
    -u private_key_6fsMi3GDxXg1XXSluNx1sLEd: \
    -X PUT \
    -d email="joe.chip@example.com"

# Single mode
account.update( email="joe.chip@example.com" )

# Single mode
account.update( email: 'joe.chip@example.com' )

<?php
# Single mode
$account->update(array( 'email'=>'joe.chip@example.com' ));
?>

// Single mode
account.update({ email: "joe.chip@example.com" })

// Single mode
account.update(new { email="joe.chip@example.com" });

# Query mode
curl "https://api.placepay.com/accounts/?email=joe.chip@example.com&query_mode=1" \
    -u private_key_6fsMi3GDxXg1XXSluNx1sLEd: \
    -X PUT \
    -d email="joe.chip@example.com"

# Query mode
accounts = place.Account.select(
    email='joe.chip@example.com',
    update_all={
        'email': 'joe.chip@example.com'
    }
)

# Query mode
accounts = Place::Account.select(
    email: 'joe.chip@example.com',
    update_all: {
        'email' => 'joe.chip@example.com'
    }
)

<?php
# Query mode
$accounts = Place\Account::select(array(
    'email'=>'joe.chip@example.com',
    'update_all'=>array(
        'email'=>'joe.chip@example.com'
    )
));
?>

// Query mode
place.Account.select({
    email: 'joe.chip@example.com',
    update_all: {
        'email': 'joe.chip@example.com'
    }
})

// Query mode
List<PlaceAccount> accounts = PlaceAccount.select(new {
    email="joe.chip@example.com"
}, update_all: new {
    email="joe.chip@example.com"
});

# Bulk mode
curl "https://api.placepay.com/accounts/" \
    -u private_key_6fsMi3GDxXg1XXSluNx1sLEd: \
    -X PUT \
    -d [0][id]="rqlPhhU3aJ8DWBF5zPJI8HrU" \
    -d [0][email]="joe.chip@example.com" \
    -d [1][id]="kswxX5hFW57SN7icmdcaszd4" \
    -d [1][email]="glen.runciter@example.com"

# Bulk mode
accounts = place.Account.update_all([
    [ account1, { 'email': 'joe.chip@example.com' } ],
    [ account2, { 'email': 'glen.runciter@example.com' } ]
])

# Bulk mode
accounts = Place::Account.update_all([
    [ account1, { 'email': 'joe.chip@example.com' } ],
    [ account2, { 'email': 'glen.runciter@example.com' } ]
])

<?php
# Bulk mode
$accounts = Place\Account::update_all(array(
    array( account1, array( 'email'=>'joe.chip@example.com' )),
    array( account2, array( 'email'=>'glen.runciter@example.com' ))
));
?>

// Bulk mode
place.Account.update_all([
    [ account1, { 'email': 'joe.chip@example.com' } ],
    [ account2, { 'email': 'glen.runciter@example.com' } ]
])

// Bulk mode
List<PlaceAccount> accounts = PlaceAccount.update_all(new object[]{
    new object[]{ account1, new { email="joe.chip@example.com" } },
    new object[]{ account2, new { email="glen.runciter@example.com" } }
})

# Single mode
curl "https://api.placepay.com/invoices/kswxX5hFW57SN7icmdcaszd4" \
    -u private_key_6fsMi3GDxXg1XXSluNx1sLEd: \
    -X DELETE

# Single mode
invoice.delete()

# Single mode
invoice.delete()

<?php
# Single mode
$invoice->delete();
?>

// Single mode
invoice.delete()

// Single mode
invoice.delete()

# Query mode
curl "https://api.placepay.com/invoices/?reference_id=example@example.com&query_mode=1" \
    -u private_key_6fsMi3GDxXg1XXSluNx1sLEd: \
    -X DELETE

# Query mode
invoices = place.Invoice.select(
    reference_id='example',
    delete_all=True
)

# Query mode
invoices = Place::Invoice.select(
    reference_id: 'example',
    delete_all: true
)

<?php
# Query mode
$invoices = Place\Invoice::select(array(
    'reference_id'=>'example',
    'delete_all'=>true
));
?>

// Query mode
place.Invoice.select({
    reference_id: 'example',
    delete_all: true
})

// Query mode
List<PlaceInvoices> invoices = PlaceInvoice.select(new {
    reference_id="example"
}, delete_all: true);

# Bulk mode
curl "https://api.placepay.com/invoices/" \
    -u private_key_6fsMi3GDxXg1XXSluNx1sLEd: \
    -X DELETE \
    -d [0][id]="rqlPhhU3aJ8DWBF5zPJI8HrU" \
    -d [1][id]="kswxX5hFW57SN7icmdcaszd4"

# Bulk mode
invoices = place.Invoice.delete_all([
    invoice1,
    invoice2
])

# Bulk mode
invoices = Place::Invoice.delete_all([
    invoice1,
    invoice2
])

<?php
# Bulk mode
$invoices = Place\Invoice::delete_all(array(
    account1,
    account2
));
?>

// Bulk mode
place.Invoice.delete_all([
    invoice1,
    invoice2
])

// Bulk mode
PlaceInvoice.delete_all(new[]{
    invoice1,
    invoice2
});

# Single mode
curl "https://api.placepay.com/invoices/lEOCGQRFHXtZg51uBGHpyd7h" \
    -u private_key_6fsMi3GDxXg1XXSluNx1sLEd:

invoice = place.Invoice.get('lEOCGQRFHXtZg51uBGHpyd7h')
print invoice.json()

invoice = Place::Invoice.get('lEOCGQRFHXtZg51uBGHpyd7h')
puts invoice.json()

<?php
$invoice = Place\Invoice::get('lEOCGQRFHXtZg51uBGHpyd7h');
puts $invoice->json();
?>

place.Invoice.get('lEOCGQRFHXtZg51uBGHpyd7h')
    .then(function( invoice ){ console.log(invoice.json()) })

PlaceInvoice invoice = PlaceInvoice.get("lEOCGQRFHXtZg51uBGHpyd7h");
Console.WriteLine( invoice.json() )

{
  "id": "16mgrY95eKG6oZ1hDx3kmBOkB",
  "object": "invoice",
  "accepted_payment_state": "full",
  "amount": 1000,
  "description": "September Rent",
  "due_date": "2015-09-01",
  "type": "rent",
  "items": [{
    "id": "rqlPhhU3aJ8DWBF5zPJI8HrU",
    "object": "invoice_item",
    "amount": 100,
    "amount_allocated": 100,
    "date_incurred": "2017-12-10 20:41:40",
    "description": "Wolf Chow",
    "invoice_id": "16mgrY95eKG6oZ1hDx3kmBOkB",
    "prorated": true,
    "recurring": false,
    "type": "pet_food",
    "allocations": [{
      "id": 285,
      "object": "invoice_item_allocation",
      "amount": 100,
      "item_id": "rqlPhhU3aJ8DWBF5zPJI8HrU",
      "payer_id": "1GNFiZvNHINWhoVEWAMqjw0uo",
      "type": "auto"
    }]
  }],
  "payers": [{
    "id": "1GNFiZvNHINWhoVEWAMqjw0uo",
    "object": "invoice_payer",
    "access": true,
    "account_id": "LVWc2lnL0R6MmGgzVmIzzKmo",
    "active": true,
    "amount_allocated": 1000,
    "amount_paid": 1000,
    "email": "joe.chip@example.com",
    "first_name": "Joe",
    "invoice_id": "16mgrY95eKG6oZ1hDx3kmBOkB",
    "last_name": "Chip",
    "last_payment_date": "2015-08-28",
    "paid": true,
    "payments": [{
      "id": "258V5IKHHoYxr0qyeesqkgPgY",
      "object": "transaction",
      "account_id": "LVWc2lnL0R6MmGgzVmIzzKmo",
      "amount": 100.83,
      "deposit_account_id": "W3flrWSs1kzSCYytR3XIwjb3",
      "description": "string",
      "failed_timestamp": "2017-12-10 20:41:40",
      "fee": 1.95,
      "initiated_timestamp": "2017-12-10 20:41:40",
      "payment_method": {},
      "payment_method_id": "19QsDurdSxJ0gVNzOcQSlew3D",
      "settled": true,
      "status": "complete",
      "status_details": "string",
      "type": "charge"
    }],
    "payments_transfer_date": "2015-09-04",
    "payments_transfered": true
  }],
  "fee_settings": {}
}

# Example of using the `greater-than` operator
curl "https://api.placepay.com/transactions/?initiated_timestamp=>2017-11-01" \
    -u private_key_6fsMi3GDxXg1XXSluNx1sLEd:

# Example of combining the `greater-than`, `less-than`, and `and` operator
curl "https://api.placepay.com/transactions/?initiated_timestamp=>2017-11-01&initiated_timestamp=<2017-11-15" \
    -u private_key_6fsMi3GDxXg1XXSluNx1sLEd:

# Example of using the `greater-than` operator
curl "https://api.placepay.com/transactions/?status=declined|canceled" \
    -u private_key_6fsMi3GDxXg1XXSluNx1sLEd:

# Example of using the `greater-than` operator
transactions = place.Transaction.select(
    place.Transaction.initiated_timestamp >= datetime.date(2018,8,1)
)

# Example of combining the `greater-than`, `less-than`, and `and` operator
transactions = place.Transaction.select(
    place.Transaction.initiated_timestamp > datetime.date(2018,8,1),
    place.Transaction.initiated_timestamp < datetime.date(2018,8,15)
)

# Example of using the `or` operator
transactions = place.Transaction.select(
    (place.Transaction.status == 'declined') | (place.Transaction.status == 'canceled')
)

# Example of using the `match` operator
transactions = place.Transaction.select(
    place.Transaction.description.contains('Rent')
)

# Putting it all together
transactions = place.Transaction.select(
    place.Transaction.initiated_timestamp > datetime.date(2018,8,1),
    place.Transaction.initiated_timestamp < datetime.date(2018,8,15),
    (place.Transaction.status == 'declined') | (place.Transaction.status == 'canceled'),
    place.Transaction.description.contains('Rent'),
    place.Transaction.amount != 100
)

# Example of using the `greater-than` operator
transactions = Place::Transaction.select(
    initiated_timestamp: '>2017-11-01'
)

# Example of combining the `greater-than`, `less-than`, and `and` operator
transactions = Place::Transaction.select(
    initiated_timestamp: [ '>2017-11-01', '<2017-11-15' ]
)

# Example of using the `or` operator
transactions = Place::Transaction.select(
    status: 'declined|canceled'
)

<?php
# Example of using the `greater-than` operator
$transactions = Place\Transaction::select(array(
    'initiated_timestamp' => '>2017-11-01'
));
?>

<?php
# Example of combining the `greater-than`, `less-than`, and `and` operator
$transactions = Place\Transaction::select(array(
    'initiated_timestamp' => array( '>2017-11-01', '<2017-11-15' )
));
?>

<?php
# Example of using the `or` operator
$transactions = Place\Transaction::select(array(
    'status' => 'declined|canceled'
))
?>

// Example of using the `greater-than` operator
place.Transaction.select({
    initiated_timestamp: '>2017-11-01'
}).then(function( transactions ){})

// Example of combining the `greater-than`, `less-than`, and `and` operator
place.Transaction.select({
    initiated_timestamp: [ '>2017-11-01', '<2017-11-15' ]
}).then(function( transactions ){})

// Example of using the `or` operator
place.Transaction.select({
    status: 'declined|canceled'
}).then(function( transactions ){})

// Example of using the `greater-than` operator
List<PlaceTransaction> transactions = PlaceTransaction.select(new {
    initiated_timestamp=">2017-11-01"
})

// Example of combining the `greater-than`, `less-than`, and `and` operator
List<PlaceTransaction> transactions = PlaceTransaction.select(new {
    initiated_timestamp=new[]{ ">2017-11-01", "<2017-11-15" }
})

// Example of using the `or` operator
List<PlaceTransaction> transactions = PlaceTransaction.select(new {
    status="declined|canceled"
})

# Example of using the special range fields
curl "https://api.placepay.com/transactions/?limit=5&offset=100" \
    -u private_key_6fsMi3GDxXg1XXSluNx1sLEd:

# Example of using the special range fields
transactions = place.Transaction.select(
    limit=10,
    offset=5
)

# Example of using the special range fields
transactions = Place::Transaction.select(
    limit: 10,
    offset: 5
)

<?php
# Example of using the special range fields
$transactions = Place\Transaction::select(array(
    'limit' => 10,
    'offset' => 5
));
?>

// Example of using the special range fields
place.Transaction.select({
    limit: 10,
    offset: 5
}).then(function(transactions){})

// Example of using the special range fields
List<PlaceTransaction> transactions = PlaceTransaction.select(new {
    limit=10,
    offset=5
})

# Example of setting field preference globally
place.Transaction.default_params = { 'fields': '*,payer_conv_fee' }

# Example of setting field preference globally
Place::Transaction.default_params = { fields: '*,payer_conv_fee' }

<?php
# Example of setting field preference globally
Place\Transaction::default_params = array( 'fields' => '*,payer_conv_fee' );
?>

// Example of setting field preference globally
place.Transaction.default_params = { 'fields': '*,payer_conv_fee' }

// Example of setting field preference globally
PlaceTransaction.default_params = new { fields='*,payer_conv_fee' }

curl "https://api.placepay.com/transactions/3axWdCgzecx9HR7PSOqP2" \
    -u private_key_6fsMi3GDxXg1XXSluNx1sLEd: \
    -X PUT
    -d "custom_fields[custom]=data"

trans = place.Transaction.get( '3axWdCgzecx9HR7PSOqP2',
    fields='*,custom_fields' )

trans.update(custom_fields={'custom': 'data'},
    fields: '*,custom_fields')

trans = Place::Transaction.get( '3axWdCgzecx9HR7PSOqP2',
    fields: '*,custom_fields' )

trans.update(custom_fields: {'custom': 'data'},
    fields: '*,custom_fields')

<?php
$trans = Place\Transaction.get('3axWdCgzecx9HR7PSOqP2',
    array( "fields"=>"*,custom_fields" ))

$trans.update(array("custom_fields"=>{"custom": "data"},
    "fields"=>"*,custom_fields"))
?>

place.Transaction.get('3axWdCgzecx9HR7PSOqP2',
    {fields: '*,custom_fields'})
    .then(function(trans) {
        trans.update({
            custom_fields: {'custom': 'data'},
            fields: '*,custom_fields'
        })
    })

PlaceTransaction trans = PlaceTransaction.get( "3axWdCgzecx9HR7PSOqP2",
    new { fields="*,custom_fields" } )

trans.update(new { custom_fields=new { custom="data" } },
    new { fields="*,custom_fields" })

{
  "id": "HWIjDMdcZHl2Dj1i6lNXW4r5",
  "object": "transaction",
  "account_id": "r3jyJXI3bpLs9m9YZV6OiFib",
  "amount": 177.4,
  "deposit_account_id": "129BOlWKt2Ta52bU99hKZkH3C",
  "description": "string",
  "failed_timestamp": null,
  "fee": 1.95,
  "initiated_timestamp": "2018-05-10 12:32:18",
  "payment_method_id": "10f10tnMIIzFZkj7RDQvcCmVg",
  "status": "complete",
  "status_details": "string",
  "type": "charge",
  "custom_fields": {
    "custom": "data"
  }
}

{
    "object": "error",
    "error_type": "InvalidArguments",
    "error_description": "secret_key",
    "details": {
        "secret_key": "Must be at least 7 characters and contain at least one number and one letter."
    }
}

{
    "object": "error",
    "error_type": "InvalidArguments",
    "error_description": "[0][accepted_terms], [0][email], [0][secret_key], [1][email], [1][accepted_terms], [1][secret_key]",
    "details": {
        "object": "list",
        "values": [
            {
                "secret_key": "Must be at least 7 characters and contain at least one number and one letter.",
                "accepted_terms": "Must be a valid bool",
                "email": "Must be a valid email"
            },
            {
                "secret_key": "Must be at least 7 characters and contain at least one number and one letter.",
                "email": "Must be a valid email",
                "accepted_terms": "Must be a valid bool"
            }
        ]
    }
}

curl "https://api.placepay.com/transactions/" \
    -u private_key_6fsMi3GDxXg1XXSluNx1sLEd: \
    -d "initiated_timestamp=>2018-05-01" \
    -d "fields=sum(amount),status" \
    -d "group_by=status"

trans = place.Transaction.select(
    place.Transaction.initiated_timestamp >= datetime.date(2018,5,1),
    fields='sum(amount),status', group_by='status' )

trans = Place::Transaction.select( initiated_timestamp: '>2018-05-01',
    fields: 'sum(amount),status', group_by: 'status' )

<?php
$trans = Place\Transaction.select(array( "initiated_timestamp"=>">2018-05-01",
    "fields"=>"*,custom_fields" ))
?>

place.Transaction.select({ initiated_timestamp: '>2018-05-01',
    fields: 'sum(amount),status', group_by: 'status'})
    .then(function(trans) {
    })

PlaceTransaction trans = PlaceTransaction.select(new { initiated_timestamp=">2018-05-01",
    fields="sum(amount),status", group_by="status" })

[
  {
    "status": "complete",
    "sum(amount)": 40000
  },
  {
    "status": "declined",
    "sum(amount)": 5000
  }
]

<form action="/path/to/your/post/method" method="POST">
  <script
    src="https://placepay.com/plugins/pay.js"
    data-key="public_key_AWcpDnNBB7oLfNqfQ6g66262"
    data-amount="1000.00"
    data-description="First Month's Rent">
  </script>
</form>

rs_transaction_id = '19QsDurdSxJ0gVNzOcQSlew3D'
curl "https://api.placepay.com/transactions/$rs_transaction_id" \
    -u private_key_6fsMi3GDxXg1XXSluNx1sLEd: \
    -X PUT \
    -d status=complete

import place

place.api_key = 'private_key_6fsMi3GDxXg1XXSluNx1sLEd'

rs_transaction_id = '19QsDurdSxJ0gVNzOcQSlew3D'

place.Transaction.select(
    id=rs_transaction_id,
    update_all={ 'status': 'complete' }
)

require 'place'
Place.api_key = 'private_key_6fsMi3GDxXg1XXSluNx1sLEd'

post '/submit_payment/' do
    rs_transaction_id = params[:rs_transaction_id]

    transaction = Place::Transaction.get(
        rs_transaction_id,
        update: { 'status' => 'complete' }
    )
end

<?php
Place\Place::$api_key = 'private_key_6fsMi3GDxXg1XXSluNx1sLEd';

$rs_transaction_id = $_GET['rs_transaction_id'];

$transaction = Place\Transaction::get(
    rs_transaction_id,
    array( 'status' => 'complete' ) #get object and update status in single request
);
?>

var place = require('place-api')

place.api_key = 'private_key_6fsMi3GDxXg1XXSluNx1sLEd'

rs_transaction_id = '19QsDurdSxJ0gVNzOcQSlew3D'

place.Transaction.select({
    id: rs_transaction_id,
    update_all: { 'status': 'complete' }
})

PlaceClient.api_key = "private_key_6fsMi3GDxXg1XXSluNx1sLEd";

string rs_transaction_id = "19QsDurdSxJ0gVNzOcQSlew3D";

PlaceTransaction.select(new {
    id=rs_transaction_id
}, update_all: new { status="complete" });

<form action="/path/to/your/post/method" method="POST">
  <script
    src="https://placepay.com/plugins/pay.js"
    data-key="public_key_AWcpDnNBB7oLfNqfQ6g66262"
    data-access-token="${access_token}"
    data-amount="1000.00"
    data-description="Example Payment">
  </script>
</form>

<script src="https://placepay.com/plugins/pay.js"></script>

<script>
Place.pay.open({
    key: "public_key_AWcpDnNBB7oLfNqfQ6g66262",
    access_token: "${access_token}",
    amount: 1000.0,
    description: "Example Payment",
    on: {
        autopay_changed: function (data) {
            // handle callback
        }
    }
})
</script>

<script src="https://placepay.com/plugins/pay.js"></script>

<script>
Place.pay.open({
    key: "public_key_AWcpDnNBB7oLfNqfQ6g66262",
    access_token: "${access_token}",
    amount: 1000.0,
    description: "Example Payment",
    embed: true,
    embed_container: $('#payment-form').get(0),
    on: {
        autopay_changed: function (data) {
            // handle callback
        }
    }
})
</script>

# Create a payer account
curl "https://api.placepay.com/accounts/" \
    -u private_key_6fsMi3GDxXg1XXSluNx1sLEd: \
    -d email="joe.chip@example.com" \
    -d full_name="Joe Chip" \
    -d user_type="payer"

# Create a payer account
account = place.Account.create(
    email='joe.chip@example.com',
    full_name='Joe Chip',
    user_type='payer'
)
# At this point store the account.id for use later

# Create a payer account
account = Place::Account.create(
    email: 'joe.chip@example.com',
    full_name: 'Joe Chip',
    user_type: 'payer'
)
# At this point store the account.id for use later

<?php
# Create a payer account
$account = Place\Account::create(array(
    'email' => 'joe.chip@example.com',
    'full_name' => 'Joe Chip',
    'user_type' => 'payer'
));
# At this point store the $account->id for use later
?>

// Create a payer account
place.Account.create({
    email: 'joe.chip@example.com',
    full_name: 'Joe Chip',
    user_type: 'payer'
}).then(function(account){
    // At this point store the account.id for use later
})

// Create a payer account
PlaceAccount account = PlaceAccount.create(new {
    email="joe.chip@example.com",
    full_name="Joe Chip",
    user_type="payer"
});
// At this point store the account.id for use later

# Create an access token
account_id = '20pt57fgkN2V5G8GYsch7vrHR'
curl "https://api.placepay.com/accounts/$account_id/access_tokens" \
    -u private_key_6fsMi3GDxXg1XXSluNx1sLEd: \
    -d type=session_access

# Create an access token
access_token = place.AccessToken.create(
    account_id=account.id,
    type='session_access'
)
# Use the value of access_token.acess_token
# as the data-access-token param with the plugin

# Create an access token
access_token = Place::AccessToken.create(
    account_id: account.id,
    type: 'session_access'
)
# Use the value of access_token.acess_token
# as the data-access-token param with the plugin

<?php
# Create an access token
$access_token = Place\AccessToken::create(array(
    'account_id' => $account->id,
    'type' => 'session_access'
));
# Use the value of $access_token->acess_token
# as the data-access-token param with the plugin
?>

// Create an access token
place.AccessToken.create({
    account_id: account.id,
    type: 'session_access'
}).then(function(access_token) {
    // Use the value of access_token.acess_token
    // as the data-access-token param with the plugin
})

// Create an access token
PlaceAccessToken access_token = PlaceAccessToken.create(new {
    account_id=account.id,
    type="session_access"
});
// Use the value of access_token.acess_token
// as the data-access-token param with the plugin

<!-- Then when you render the plugin, pass the access token. Note: the access_token only works once -->
<form action="/path/to/your/post/method" method="POST">
  <script
    src="https://placepay.com/plugins/pay.js"
    data-key="public_key_AWcpDnNBB7oLfNqfQ6g66262"
    data-amount="1000.00"
    data-description="First Month's Rent"
    data-access-token="${access_token}">
  </script>
</form>

# Create a payer account
curl "https://api.placepay.com/accounts/?fields=*,username,access_tokens" \
    -u private_key_6fsMi3GDxXg1XXSluNx1sLEd: \
    -d email="joe.chip@example.com" \
    -d full_name="Joe Chip" \
    -d user_type="payer" \
    -d access_tokens[0][type]='session_access'

# Create a payer account
account = place.Account.create(
    username='your_unique_id',
    email='joe.chip@example.com',
    full_name='Joe Chip',
    user_type='payer',
    access_tokens=[
        place.AccessToken( type='session_access' )
    ],
    fields='*,username,access_tokens'
)
# At this point, just use the account.access_tokens[0].access_token for the *Pay* plugin

# Create a payer account
account = Place::Account.create(
    username: 'your_unique_id',
    email: 'joe.chip@example.com',
    full_name: 'Joe Chip',
    user_type: 'payer',
    access_tokens: [
        place.AccessToken.new( type: 'session_access' )
    ],
    fields: '*,username,access_tokens'
)
# At this point, just use the account.access_tokens[0].access_token for the *Pay* plugin

<?php
# Create a payer account
$account = Place\Account::create(array(
    'username' => 'your_unique_id',
    'email' => 'joe.chip@example.com',
    'full_name' => 'Joe Chip',
    'user_type' => 'payer',
    'access_tokens' => array(
        new Place\AccessToken( 'type' => 'session_access' )
    )
));
#  At this point, just use the $account->access_tokens[0]->access_token for the *Pay* plugin
?>

// Create a payer account
place.Account.create({
    username: 'your_unique_id',
    email: 'joe.chip@example.com',
    full_name: 'Joe Chip',
    user_type: 'payer',
    access_tokens: [
        place.AccessToken({ type: 'session_access' })
    ],
    fields: '*,username,access_tokens'
}).then(function(account){
    // At this point, just use the account.access_tokens[0].access_token for the *Pay* plugin
})

// Create a payer account
PlaceAccount account = PlaceAccount.create(new {
    username="your_unique_id",
    email="joe.chip@example.com",
    full_name="Joe Chip",
    user_type="payer",
    access_tokens=new[]{
        new PlaceAccessToken(){ type="session_access" }
    }
}, new { fields="*,username,access_tokens" });
// At this point, just use the account.access_tokens[0].access_token for the *Pay* plugin

<!-- Then when you render the plugin, pass the access token. Note: the access_token only works once -->
<script
  src="https://placepay.com/plugins/pay.js"
  data-key="public_key_AWcpDnNBB7oLfNqfQ6g66262"
  data-access-token="${access_token}"
  data-autopay-only="true">
</script>

curl "https://api.placepay.com/autopay_enrollments" \
    -u private_key_6fsMi3GDxXg1XXSluNx1sLEd:

autopay_enrollments = place.AutopayEnrollments.select()

autopay_enrollments = Place::AutopayEnrollments.select()

<?php
$autopay_enrollments = Place\AutopayEnrollments::select();
?>

place.AutopayEnrollments.select()
    .then(function(autopay_enrollments){})

PlaceAutopayEnrollments autopay_enrollments = PlaceAutopayEnrollments.select()

payments = []
for enrollment in autopay_enrollments:
    payments.append( place.Transaction(
        type='charge',
        amount=1000, # replace this with the outstanding balance
        description='March Rent',
        payment_method_id=enrollment.payment_method_id,
        deposit_account_id=enrollment.deposit_account_id
    ) )

payments = []
for enrollment in autopay_enrollments
    payments.push( Place::Transaction.new(
        type: 'charge',
        amount: 1000, # replace this with the outstanding balance
        description: 'March Rent',
        payment_method_id: enrollment.payment_method_id,
        deposit_account_id: enrollment.deposit_account_id
    ) )
end

<?php
$payments = array();
foreach( $autopay_enrollments as $enrollment ) {
    $payments.push( new Place\Transaction(array(
        'type' => 'charge',
        'amount' => 1000, # replace this with the outstanding balance
        'description' => 'March Rent',
        'payment_method_id' => $enrollment->payment_method_id,
        'deposit_account_id' => $enrollment->deposit_account_id
    )) )
}
?>

payments = []
for ( var i = 0; i < autopay_enrollments.length; i++ ) {
    var enrollment = autopay_enrollments[i]
    payments.push( place.Transaction({
        type: 'charge',
        amount: 1000, // replace this with the outstanding balance
        description: 'March Rent',
        payment_method_id: enrollment.payment_method_id,
        deposit_account_id: enrollment.deposit_account_id
    }) )
}

List<PlaceTransaction> payments = new List<PlaceTransaction>();
for ( int i=0; i < autopay_enrollments.Count; i++ ) {
    PlaceAutopayEnrollments enrollment = autopay_enrollments[i];
    payments.Add( new PlaceTransaction(){
        type="charge",
        amount=1000, // replace this with the outstanding balance
        description="March Rent",
        payment_method_id=enrollment.payment_method_id,
        deposit_account_id=enrollment.deposit_account_id
    } );
}

curl "https://api.placepay.com/transactions/" \
    -u private_key_6fsMi3GDxXg1XXSluNx1sLEd: \
    -d "[0][type]=charge" \
    -d "[0][amount]=1000" \
    -d "[0][description]=March Rent" \
    -d "[0][payment_method_id]=$payment_method_id" \
    -d "[0][deposit_account_id]=$deposit_account_id"

# process automatic payments
payments = place.Transaction.create( payments )

for payment in payments:
    if payment.status == 'complete':
        # handle complete payment
    else:
        # handle declined payment

# process automatic payments
payments = Place::Transaction.create( payments )

for payment in payments
    if payment.status == 'complete'
        # handle complete payment
    else
        # handle declined payment
    end
end

<?php
# process automatic payments
$payments = Place\Transaction:create( $payments )

foreach( $payments as $payment ) {
    if ( $payment->status == 'complete' ) {
        # handle complete payment
    } else {
        # handle declined payment
    }
}
?>

// process automatic payments
place.Transaction.create( payments )
    .then(function(payments) {
        for ( var i = 0; i < payments.length; i++ ) {
            var payment = payments[i]
            if ( payment.status == 'complete' )
                // handle complete payment
            else
                // handle declined payment
        }
    })

// process automatic payments
PlaceTransaction payments = PlaceTransaction.create( payments )

for ( int i=0; i < payments.Count; i++ ) {
    PlaceTransaction payment = payments[i];
    if ( payment.status == "complete" )
        // handle complete payment
    else
        // handle declined payment
}

<script>
Place.pay.on( '.mybutton', 'loaded', function() {
    console.log('event captured')
})
</script>

<script>
Place.pay.on( '.mybutton', 'autopay_changed', function( evt ) {
    if ( evt.autopay )
      console.log('autopay enabled')
    else
      console.log('autopay disabled')
})
</script>

<script>
Place.pay.on( '.mybutton', 'autopay_changed', function( evt ) {
    Place.pay.lock()

    $.post('/autopay_flag', { enabled: !!evt.autopay }, function() {
        Place.pay.unlock()
    })
})
</script>

<script
  src="https://placepay.com/plugins/pay.js"
  data-key="public_key_AWcpDnNBB7oLfNqfQ6g66262"
  data-access-token="${access_token}"
  data-amount="1000"
  data-description="Rent"
  data-custom-fields="${uri_encode({'custom':'example'})}">
</script>

  <script
    src="https://placepay.com/plugins/deposit.js"
    data-key="public_key_AWcpDnNBB7oLfNqfQ6g66262"
    data-access-token="access_token_AWcpDnNBB7oLfNqfQ6g66262">
  </script>

<script>
Place.deposit.open({
    key: "public_key_AWcpDnNBB7oLfNqfQ6g66262",
    access_token: "${access_token}",
    deposit_account_id:"9hUFlPbqPlAUbeTp",
    on: {
        deposit_changed: function (data) {
            // handle callback
        }
    }
})
</script>

# Create a recipient account
curl "https://api.placepay.com/deposit_accounts/" \
    -u private_key_6fsMi3GDxXg1XXSluNx1sLEd: \
    -d company="Example Landlord LLC" \
    -d phone="111-222-3333" \
    -d address[street_address]="123 Example St" \
    -d address[unit_number]="#4" \
    -d address[city_state_zip]="New York, NY 10004"

# Create a recipient account
deposit_account = place.DepositAccount.create(
    company='Example Landlord LLC',
    phone='111-222-3333',
    address=place.Address(
        street_address='123 Example St',
        unit_number='#4',
        city_state_zip='New York, NY 10004'
    )
)
# At this point store the deposit_account.id for use later

# Create a recipient account
deposit_account = Place::DepositAccount.create(
    company: 'Example Landlord LLC',
    phone: '111-222-3333',
    address: Place::Address.new(
        street_address: '123 Example St',
        unit_number: '#4',
        city_state_zip: 'New York, NY 10004'
    )
)
# At this point store the deposit_account.id for use later

<?php
# Create a recipient account
$deposit_account = new Place\DepositAccount::create(array(
    'company' => 'Example Landlord LLC',
    'phone' => '111-222-3333',
    'address' => new Place\Address(
        'street_address' => '123 Example St',
        'unit_number' => '#4',
        'city_state_zip' => 'New York, NY 10004'
    )
))
# At this point store the $deposit_account.id for use later
?>

// Create a recipient account
place.DepositAccount.create({
    company: 'Example Landlord LLC',
    phone: '111-222-3333',
    address: place.Address({
        street_address: '123 Example St',
        unit_number: '#4',
        city_state_zip: 'New York, NY 10004'
    })
}).then(function(deposit_account){
    // At this point store the deposit_account.id for use later
})

// Create a recipient account
PlaceDepositAccount deposit_account = PlaceDepositAccount.create(new {
    company="Example Landlord LLC",
    phone="111-222-3333",
    address=new PlaceAddress(){
        street_address="123 Example St",
        unit_number="#4",
        city_state_zip="New York, NY 10004"
    }
})
// At this point store the deposit_account.id for use later

# Create an access token
curl "https://api.placepay.com/access_tokens" \
    -u private_key_6fsMi3GDxXg1XXSluNx1sLEd: \
    -d type=session_access

# Create an access token
access_token = place.AccessToken.create(
    type='session_access'
)
# Use the value of access_token.acess_token
# as the data-access-token param with the plugin

# Create an access token
access_token = Place::AccessToken.create(
    type: 'session_access'
)
# Use the value of access_token.acess_token
# as the data-access-token param with the plugin

<?
    # Create an access token
    $access_token = Place\AccessToken::create(array(
        'type' => 'session_access'
    ))
    # Use the value of access_token.acess_token
    # as the data-access-token param with the plugin
?>

// Create an access token
place.AccessToken.create(
    type='session_access'
).then(function(access_token){
    // Use the value of acess_token.acess_token
    // as the data-access-token param with the plugin
})

// Create an access token
PlaceAccessToken access_token = PlaceAccessToken.create(new {
    type="session_access"
});
// Use the value of access_token.acess_token
// as the data-access-token param with the plugin

<script
    src="https://placepay.com/plugins/deposit.js"
    data-key="public_key_JqZzahBa9Z0exkzbQoEBl8"
    data-access-token="${access_token}">
</script>

<script>
Place.deposit.on( '.mybutton', 'loaded', function() {
    console.log('event captured')
})
</script>

# Get the processing activation status
deposit_account_id = 'hzus4iw9ujkR9TPcpYEs'
curl "https://api.placepay.com/deposit_accounts/$deposit_account_id" \
    -u private_key_6fsMi3GDxXg1XXSluNx1sLEd: |
    python -mjson.tool | grep processing_activation_status

# Get the processing activation status
deposit_account = place.DepositAccount.get('hzus4iw9ujkR9TPcpYEs')

print deposit_account.deposit_method.processing_activation_status
# returns either 'pending', 'in_review', 'active', 'inactive', 'action_needed'

# Get the processing activation status
deposit_account = Place::DepositAccount.get('hzus4iw9ujkR9TPcpYEs')

puts deposit_account.deposit_method.processing_activation_status
# returns either 'pending', 'in_review', 'active', 'inactive', 'action_needed'

<?
    # Get the processing activation status
    $deposit_account = Place\DepositAccount::get('hzus4iw9ujkR9TPcpYEs');

    echo(deposit_account->deposit_method->processing_activation_status);
    # returns either 'pending', 'in_review', 'active', 'inactive', 'action_needed'
?>

// Get the processing activation status
place.DepositAccount.get('hzus4iw9ujkR9TPcpYEs')
    .then(function(deposit_account){
        console.log(deposit_account.deposit_method.processing_activation_status)
        // returns either 'pending', 'in_review', 'active', 'inactive', 'action_needed'
    })

// Get the processing activation status
PlaceDepositAccount deposit_account = PlaceDepositAccount.get('hzus4iw9ujkR9TPcpYEs');

Console.Log(deposit_account.deposit_method.processing_activation_status);
// Use the value of access_token.acess_token
// returns either 'pending', 'in_review', 'active', 'inactive', 'action_needed'

curl "https://api.placepay.com/transactions" \
    -u private_key_6fsMi3GDxXg1XXSluNx1sLEd: \
    -d "fields=*,credit_ledger" \
    -d "type=deposit" \
    -d "account_id=$deposit_account_id"

trans = place.Transaction.select( type='deposit',
    account_id=deposit_account.id, fields='*,credit_ledger' )

trans = Place::Transaction.select( type: 'deposit',
    account_id: deposit_account.id, fields: '*,credit_ledger' )

trans = Place\Transaction::select(array(
    'type'=>'deposit',
    'account_id'=>$deposit_account->id,
    'fields'=>'*,credit_ledger'
))

place.Transaction.select({
    'type': 'deposit',
    'account_id': deposit_account.id,
    'fields': '*,credit_ledger'
)).then(function(trans) {
})

PlaceTransaction trans = PlaceTransaction.select(new{
    account_id=deposit_account.id,
    type="deposit",
    fields="*,credit_ledger"
});

curl "https://api.placepay.com/transactions" \
    -u private_key_6fsMi3GDxXg1XXSluNx1sLEd: \
    -d "fields=*,debit_ledger"

trans = place.Transaction.select( type='charge',
    account_id=account.id, fields='*,debit_ledger' )

trans = Place::Transaction.select( type: 'charge',
    account_id: account.id, fields: '*,debit_ledger' )

trans = Place\Transaction::select(array(
    'type'=>'charge',
    'account_id'=>$account->id,
    'field'=>'*,debit_ledger'
))

place.Transaction.select({
    'type': 'charge',
    'account_id': account.id,
    'fields': '*,debit_ledger'
)).then(function(trans) {
})

PlaceTransaction trans = PlaceTransaction.select(new{
    type="charge",
    account_id=deposit_account.id,
    fields="*,debit_ledger"
});

{
  "id": "HWIjDMdcZHl2Dj1i6lNXW4r5",
  "object": "transaction",
  "account_id": "r3jyJXI3bpLs9m9YZV6OiFib",
  "amount": 177.4,
  "deposit_account_id": "129BOlWKt2Ta52bU99hKZkH3C",
  "description": "string",
  "failed_timestamp": null,
  "fee": 1.95,
  "initiated_timestamp": "2018-05-10 12:32:18",
  "payment_method_id": "10f10tnMIIzFZkj7RDQvcCmVg",
  "status": "complete",
  "status_details": "string",
  "type": "charge",
  "debit_ledger": [{
    "id": "115pm5D1vH0vjo2ftu5msX0Ns",
    "object": "transaction_ledger",
    "account_id": "1QsHK85NtiZZ0hDSTeZhzEAp6",
    "amount": 177.4,
    "destination_id": "1ct0dNO6EsKwzWCblbLoCSwrr",
    "source_id": "HWIjDMdcZHl2Dj1i6lNXW4r5",
    "status": "complete",
    "timestamp": "2018-05-10 12:32:18",
    "total_amount": 2101.36,
    "type": "deposit"
  },{
    "id": "115pm5D1vH0vjo2ftu5msX0Ns",
    "object": "transaction_ledger",
    "account_id": "1QsHK85NtiZZ0hDSTeZhzEAp6",
    "amount": 177.4,
    "destination_id": "1ct0dNO6EsKwzWCblbLoCSwrr",
    "source_id": "HWIjDMdcZHl2Dj1i6lNXW4r5",
    "status": "complete",
    "timestamp": "2018-05-11 12:32:18",
    "total_amount": 177.4,
    "type": "refund"
  }],
  "credit_ledger": [{
    "id": "115pm5D1vH0vjo2ftu5msX0Ns",
    "object": "transaction_ledger",
    "account_id": "1QsHK85NtiZZ0hDSTeZhzEAp6",
    "amount": 177.4,
    "destination_id": "HWIjDMdcZHl2Dj1i6lNXW4r5",
    "source_id": "1xfI91OI3EVPP57iKi5Iwobg0",
    "status": "complete",
    "timestamp": "2018-05-11 12:32:18",
    "total_amount": 300.3,
    "type": "reversal"
  }]
}