When it comes to base credit-card processing fees, old adages like “look before you leap” and “caveat emptor” (buyer beware) come to mind. That’s because things aren’t quite as straightforward as you may think when a seemingly super-low base percentage rate is being dangled before your eyes. An irresistibly attractive base rate of, say, 1.8% can suddenly become 3.5% - 4% if certain conditions aren’t met. And bingo! There goes another chunk of your bottom line.

The reason? Tiered rate structures that Merchant Credit Card Processors use apply increasingly higher percentage fees to mid-qualified and non-qualified transactions. And if you don’t look before you leap and buy with a wary eye you’ll find yourself in a situation like the one another old adage warns about: “marry in haste, repent in leisure.”

Or you can protect yourself up front from the tyranny of tiered rates, and keep more profit in your pocket, with the USBSwiper card payment processing system featuring PayPal as your credit merchant.

But to understand that, you need to understand how tiered rates work.

Up to 40% of Your Transactions Automatically Won’t Qualify for the Provider’s Lowest Rate

Did you know that even though you swipe every customer’s card and obtain every customer’s signature and batch every transaction within 24 hours, up to 40% of the fees you pay will still fall under the higher, mid or non-qualified rate? For the simple reason that up to 40% of your customers will be using rewards-type credit cards, and rewards-type credit cards automatically generate a mid-qualified or non-qualified transaction rate.

After all, someone has to pay for the sky miles, merchandise-redemption points, cash-back allowances, and other goodies that those cards provide. And that someone is you.

Qualified vs. Mid-Qualified vs. Non-Qualified Transactions

The following table lists conditions typically attached to three-tier pricing; specific conditions will vary by card provider. Take a look at how easy it can be to incur higher fees for mid- and non-qualified transactions. These are the kinds of “gotchas” you’re probably not going to hear about up front from a card merchant who’s trying to lock you into a contract with what seems like a fantastic base rate. Only later, when it’s too late to back out, will those significantly higher mid-qualified and non-qualified rates rear their ugly heads.

No Pain, Much Gain With USBSwiper

With the USBSwiper credit card reader and payment processing software, there’s no such thing as a mid-qualified or non-qualified transaction. One flat rate based solely on monthly volumes will help keep your costs lower and more predictable. Remember: a merchant account provider will quote you the lowest transaction rate to get your business; however, it’s a good bet that at least half your monthly card transactions will not qualify for that attractive rate, but will generate much higher fees.

The graph illustrates the potential impact on your annual costs, based on $50,000 in monthly credit-card transactions.

Get Started Today

Why MassRefunds.com?

PayPal provides a transaction history where you can easily look up a single transaction and submit a refund.  However, if you ever find yourself with a list of refunds that you need to issue it can be very time consuming searching through your history in PayPal to find each individual transaction and process the refund.  With MassRefunds.com you can easily compile a list of transactions that need refunded and take care of all of them with a single click!

How Does it Work?  What’s it Cost?

After creating a quick account at the web site you can try the service for 15 days free of charge.  If you decide to continue using the service you will be billed $9.99/mo and you can cancel at any time without any penalties.  Once you’re up and running simply sign-in to your account where you can easily search for multiple transactions at a time.  You may then provide amounts for each individual transaction in case you only need to do a partial refund on any of them, and you can also leave notes if you choose.  Then, with one click of a button all of the refunds are issued at once!  Stop wasting time with refunds and sign-up today!

1 - Local IPN Testing

The first thing I do is create a local HTML form that consists of hidden fields which resemble the same thing PayPal’s system would post to my server when an IPN occurs.  Here’s a sample.

<form method="post" action="ipn-listener.php">
<input type="hidden" name="mc_gross" value="500.00">
<input type="hidden" name="custom" value="test custom data">
<input type="hidden" name="address_status" value="confirmed">
<input type="hidden" name="item_number1" value="6">
<input type="hidden" name="item_number2" value="4">
<input type="hidden" name="payer_id" value="FW5W7ZUC3T4KL">
<input type="hidden" name="tax" value="0.00">
<input type="hidden" name="address_street" value="1234 Rock Road">
<input type="hidden" name="payment_date" value="14:55 15 Jan 07 2005 PST">
<input type="hidden" name="payment_status" value="Completed">
<input type="hidden" name="address_zip" value="12345">
<input type="hidden" name="mc_shipping" value="0.00">
<input type="hidden" name="mc_handling" value="0.00">
<input type="hidden" name="first_name" value="Jason">
<input type="hidden" name="last_name" value="Anderson">
<input type="hidden" name="mc_fee" value="0.02">
<input type="hidden" name="address_name" value="Jason Anderson">
<input type="hidden" name="notify_version" value="1.6">
<input type="hidden" name="payer_status" value="verified">
<input type="hidden" name="business" value="paypal@emailaddress.com">
<input type="hidden" name="address_country" value="United States">
<input type="hidden" name="num_cart_items" value="2">
<input type="hidden" name="mc_handling1" value="0.00">
<input type="hidden" name="mc_handling2" value="0.00">
<input type="hidden" name="address_city" value="Los Angeles">
<input type="hidden" name="verify_sign" value="AlUbUcinRR5pIo2KwP4xjo9OxxHMAi6.s6AES.4Z6C65yv1Ob2eNqrHm">
<input type="hidden" name="mc_shipping1" value="0.00">
<input type="hidden" name="mc_shipping2" value="0.00">
<input type="hidden" name="tax1" value="0.00">
<input type="hidden" name="tax2" value="0.00">
<input type="hidden" name="txn_id" value="TESTER">
<input type="hidden" name="payment_type" value="instant">
<input type="hidden" name="last_name=Borduin">
<input type="hidden" name="payer_email" value="test@domain.com">
<input type="hidden" name="item_name1" value="Rubber+clog">
<input type="hidden" name="address_state" value="CA">
<input type="hidden" name="payment_fee" value="0.02">
<input type="hidden" name="item_name2" value="Roman sandal">
<input type="hidden" name="invoice" value="123456">
<input type="hidden" name="quantity" value="1">
<input type="hidden" name="quantity1" value="1">
<input type="hidden" name="receiver_id" value="5HRS8SCK9NSJ2">
<input type="hidden" name="quantity2" value="1">
<input type="hidden" name="txn_type" value="web-accept">
<input type="hidden" name="mc_gross_1" value="0.01">
<input type="hidden" name="mc_currency" value="USD">
<input type="hidden" name="mc_gross_2" value="0.01">
<input type="hidden" name="payment_gross" value="0.02">
<input type="hidden" name="subscr_id" value="PP-1234">
<input name="test" type="submit" value="test">
</form>

When testing this way, the IPN script will run through your Invalid IPN code because the post did not come from PayPal’s server. As such, you’ll need to adjust your IPN script to force a Valid response. If you’re using my IPN template you can adjust line 56 to…

if(strcmp ($res, "VERIFIED") == 0 || 1 == 1)

Then, simply set the action of the form to your IPN listener and then submit it. This way you’ll be able to see the on-screen result of your IPN script and can easily troubleshoot any errors that may exist. You can add or remove any fields you’d like from the test form and you can adjust the names according to what fields you expect to get from the IPN you’re testing for. Once you’re able to successfully run your test IPN within a browser without any errors you can remove the forced Validity and move on to the next step.

2 - PayPal Developer IPN Simulator

PayPal provides an IPN Simulator from within your developer account. You can use the simulator to easily send test IPN’s to your server for a number of different scenarios. At this point you’ll just need to make sure your IPN script is configured to run on the sandbox servers (see the notes at the top of the IPN template) and then these IPN Simulator posts will validate because they are indeed coming from PayPal’s server. Once these simulated IPN’s are working as expected you’re ready to launch.

3 - Deploy

At this point you’re ready to set your IPN script to production mode instead of sandbox mode and then upload it to your live web server. You can enable IPN within your PayPal profile or you can also include the NotifyURL field in your standard payment buttons or API requests to PayPal.

The only ATM machine near my home for my bank is located inside a local Price Chopper grocery store. I stopped by to get some cash out of my account one day and while in a rush made a very stupid mistake and left my debit card in the ATM machine. I got back home just about 30 minutes later and I realized what I had done. I immediately went back up to the Price Chopper and went to the customer service desk. They had my debit card there for me and gave it back. Whew!

The next day I logged into my online banking just to make sure nothing funny had happened. Sure enough, I discovered a $3,000 charge to a kitchen and bath web site for a bunch of cabinets that was NOT mine! I immediately called my bank and submitted a dispute on the transaction. They gave me a temporary refund of the funds, explained that an investigation would ensue and that it could take up to 90 days before it was completely settled. I asked “What about this kitchen and bath company? Is anybody going to notify them that this was a fraudulant charge?” I was insured that yes, they would indeed be informed, but it might not be for weeks.

Well, at this point I was feeling pretty stupid about leaving my debit card in the ATM machine and I was also curious about the seller and who might have done this with my card. I personally called the kitchen & bath company and informed them of the fraudulant transaction. Now, even though I made a dumb mistake and left my card in the machine, this is where the seller messed up. They proceeded to ship the merchandise to an address in New Jersey even though the billing address on the credit card (which was included in the order, apparently) was in the Kansas City area, where I’m from. This was a big mistake. Had I not personally called to inform the seller that the fraudulant transaction had taken place the merchandie would have reached its destination and the fraudsters could have very well have gotten away with the product. By the time the bank’s investigation made it back to the seller it would have been too late. The credit card company would then take the funds back from the seller to cover what they put back into my account. Because of the fact that the seller had shipped to an address other than the billing address on the credit card (an AVS mis-match, or as PayPal would call it, and Unconfirmed address) they would not have been covered by any type of seller protection from that credit card merchant. At this point they would have been out their product and the $3,000. Needless to say, they were very pleased that I called and informed them of the problem in time for them to put a stop-shipment on the merchandise and get it routed back to their warehouse. Again, had I not called and informed the seller of this problem they would have had no idea it was fraudulant until the bank contacted them up to 90 days later. With PayPal’s Dispute Resolution Center this would not have been a problem.

The Dispute Resolution Center is an area of your PayPal account where you can easily manage any disputes/chargebacks that might occur from transactions you have processed. In the example above, if the seller had used PayPal to process the credit card they would have received a new dispute notification when I initially filed the charge-back with my bank. Then, even if I hadn’t called them to inform them of the problem they would have gotten notification from the PayPal dispute area and would have still had time to put a stop-shipment on the goods. Also, with PayPal’s new Expanded Seller Protection program the seller may have been eligble even after shipping to the Unconfirmed address. If not, there would have been red flags in the transaction details page within the PayPal account warning the seller not to ship the merchandise without further investigation.

This is just one example of how using PayPal as your merchant processor can save valuable time and keep dispute losses to a minimum.

PayPal’s IPN feature is a great way to easily integrate standard payment buttons or automate back-end procedures for Payments Pro solutions. While it’s actually very simple, the process can be confusing when you first begin developing and I’ve seen people give up before they even truly get started.

The following script is a basic PHP template that handles everything you need to get started with PayPal Instant Payment Notification. There are a couple of simple options at the top of the script for handling test servers and SSL. The template handles verifying the POST data with PayPal’s servers to ensure it’s valid and then stores every possible IPN value in PHP variables that are ready for use. If a particular field was not included in the IPN received then it’s simply populated with an empty value, but it’s still available within the script.

You can begin at the very bottom and simply do whatever you want with the store data, whether it’s update a database, format an email and send it to customers, send a text message notification to customers or yourself, etc.

I’ve also included a SQL file you can  use to easily create database tables for use with PayPal’s IPN system.  Later I’ll be completing this entire solution as an easily installed all-in-one package.

Happy scripting!

<?php
////////////////////////////////////////////////////////////
// Angell EYE : PayPal IPN Template : 02.01.2009 //////////
//////////////// angelleye.com  //////////////////////
/////////////////////////////////////////////////////////
// PayPal now provides a variable called test_ipn on sandbox IPN's for simple flagging of sandbox IPN vs. production IPN
$sandbox = isset($_POST['test_ipn']) ? true : false;
$ssl = $sandbox ? false : false;
$ppHost = $sandbox ? 'www.sandbox.paypal.com' : 'www.paypal.com';

// read the post from PayPal system and add 'cmd'
$req = 'cmd=_notify-validate';

// Store each $_POST value in a NVP string: 1 string encoded and 1 string decoded
$IPNDecoded = '';
foreach ($_POST as $key => $value)
{
$value = urlencode(stripslashes($value));
$req .= "&amp;$key=$value";
$IPNDecoded .= $key . " = " . urldecode($value) ."<br /><br />";
}

// post back to PayPal system to validate using SSL or not based on flag set above.
if($ssl)
{
$header = '';
$header .= "POST /cgi-bin/webscr HTTP/1.0\r\n";
$header .= "Host: " . $ppHost . ":443\r\n";
$header .= "Content-Type: application/x-www-form-urlencoded\r\n";
$header .= "Content-Length: " . strlen($req) . "\r\n\r\n";
$fp = fsockopen ('ssl://' . $ppHost, 443, $errno, $errstr, 30);
}
else
{
$header = '';
$header .= "POST /cgi-bin/webscr HTTP/1.0\r\n";
$header .= "Host: " . $ppHost . ":80\r\n";
$header .= "Content-Type: application/x-www-form-urlencoded\r\n";
$header .= "Content-Length: " . strlen($req) . "\r\n\r\n";
$fp = fsockopen ($ppHost, 80, $errno, $errstr, 30);
}

if (!$fp)
{
$IsValid = false;
}
else
{
// Response from PayPal was good.  Now check to see if it returned verified or invalid.  Simply set $IsValud to true/false accordingly.
fputs ($fp, $header . $req);
while(!feof($fp))
{
$res = fgets ($fp, 1024);
if(strcmp ($res, "VERIFIED") == 0)
$IsValid = true;
elseif (strcmp ($res, "INVALID") == 0)
$IsValid = false;
}
fclose ($fp);
}

// Buyer Information
$address_city = isset($_POST['address_city']) ? $_POST['address_city'] : '';
$address_country = isset($_POST['address_country']) ? $_POST['address_country'] : '';
$address_country_code = isset($_POST['address_country_code']) ? $_POST['address_country_code'] : '';
$address_name = isset($_POST['address_name']) ? $_POST['address_name'] : '';
$address_state = isset($_POST['address_state']) ? $_POST['address_state'] : '';
$address_status = isset($_POST['address_status']) ? $_POST['address_status'] : '';
$address_street = isset($_POST['address_street']) ? $_POST['address_street'] : '';
$address_zip = isset($_POST['address_zip']) ? $_POST['address_zip'] : '';
$first_name = isset($_POST['first_name']) ? $_POST['first_name'] : '';
$last_name = isset($_POST['last_name']) ? $_POST['last_name'] : '';
$payer_business_name = isset($_POST['payer_business_name']) ? $_POST['payer_business_name'] : '';
$payer_email = isset($_POST['payer_email']) ? $_POST['payer_email'] : '';
$payer_id = isset($_POST['payer_id']) ? $_POST['payer_id'] : '';
$payer_status = isset($_POST['payer_status']) ? $_POST['payer_status'] : '';
$contact_phone = isset($_POST['contact_phone']) ? $_POST['contact_phone'] : '';
$residence_country = isset($_POST['residence_country']) ? $_POST['residence_country'] : '';

// Basic Information
$notify_version = isset($_POST['notify_version']) ? $_POST['notify_version'] : '';
$charset = isset($_POST['charset']) ? $_POST['charset'] : '';
$business = isset($_POST['business']) ? $_POST['business'] : '';
$item_name = isset($_POST['item_name']) ? $_POST['item_name'] : '';
$item_number = isset($_POST['item_number']) ? $_POST['item_number'] : '';
$quantity = isset($_POST['quantity']) ? $_POST['quantity'] : '';
$receiver_email = isset($_POST['receiver_email']) ? $_POST['receiver_email'] : '';
$receiver_id = isset($_POST['receiver_id']) ? $_POST['receiver_id'] : '';

// Cart Items
$num_cart_items = isset($_POST['num_cart_items']) ? $_POST['num_cart_items'] : '';

$i = 1;
$cart_items = array();
while(isset($_POST['item_number' . $i]))
{
$item_number = isset($_POST['item_number' . $i]) ? $_POST['item_number' . $i] : '';
$item_name = isset($_POST['item_name' . $i]) ? $_POST['item_name' . $i] : '';
$quantity = isset($_POST['quantity' . $i]) ? $_POST['quantity' . $i] : '';
$mc_gross = isset($_POST['mc_gross_' . $i]) ? $_POST['mc_gross_' . $i] : '';
$mc_handling = isset($_POST['mc_handling' . $i]) ? $_POST['mc_handling' . $i] : '';
$mc_shipping = isset($_POST['mc_shipping' . $i]) ? $_POST['mc_shipping' . $i] : '';
$custom = isset($_POST['custom' . $i]) ? $_POST['custom' . $i] : '';
$option_name1 = isset($_POST['option_name1_' . $i]) ? $_POST['option_name1_' . $i] : '';
$option_selection1 = isset($_POST['option_selection1_' . $i]) ? $_POST['option_selection1_' . $i] : '';
$option_name2 = isset($_POST['option_name2_' . $i]) ? $_POST['option_name2_' . $i] : '';
$option_selection2 = isset($_POST['option_selection2_' . $i]) ? $_POST['option_selection2_' . $i] : '';

$current_item = array(
'item_number' => $item_number,
'item_name' => $item_name,
'quantity' => $quantity,
'mc_gross' => $mc_gross,
'mc_handling' => $mc_handling,
'mc_shipping' => $mc_shipping,
'custom' => $custom,
'option_name1' => $option_name1,
'option_selection1' => $option_selection1,
'option_name2' => $option_name2,
'option_selection2' => $option_selection2
);

array_push($cart_items, $current_item);
$i++;
}

// Advanced and Custom Information
$custom = isset($_POST['custom']) ? $_POST['custom'] : '';
$invoice = isset($_POST['invoice']) ? $_POST['invoice'] : '';
$memo = isset($_POST['memo']) ? $_POST['memo'] : '';
$option_name1 = isset($_POST['option_name1']) ? $_POST['option_name1'] : '';
$option_selection1 = isset($_POST['option_selection1']) ? $_POST['option_selection1'] : '';
$option_name2 = isset($_POST['option_name2']) ? $_POST['option_name2'] : '';
$option_selection2 = isset($_POST['option_selection2']) ? $_POST['option_selection2'] : '';
$tax = isset($_POST['tax']) ? $_POST['tax'] : '';

// Website Payments Standard, Website Payments Pro, and Refund Information
$auth_id = isset($_POST['auth_id']) ? $_POST['auth_id'] : '';
$auth_exp = isset($_POST['auth_exp']) ? $_POST['auth_exp'] : '';
$auth_amount = isset($_POST['auth_amount']) ? $_POST['auth_amount'] : '';
$auth_status = isset($_POST['auth_status']) ? $_POST['auth_status'] : '';

// Fraud Management Filters
$i = 1;
$fraud_management_filters = array();
while(isset($_POST['fraud_management_filters_' . $i]))
{
$filter_name = isset($_POST['fraud_management_filter_' . $i]) ? $_POST['fraud_management_filter_' . $i] : '';

array_push($fraud_management_filters, $filter_name);
$i++;
}

$mc_gross = isset($_POST['mc_gross']) ? $_POST['mc_gross'] : '';
$mc_handling = isset($_POST['mc_handling']) ? $_POST['mc_handling'] : '';
$mc_shipping = isset($_POST['mc_shipping']) ? $_POST['mc_shipping'] : '';
$mc_fee = isset($_POST['mc_fee']) ? $_POST['mc_fee'] : '';
$num_cart_items = isset($_POST['num_cart_items']) ? $_POST['num_cart_items'] : '';
$parent_txn_id = isset($_POST['parent_txn_id']) ? $_POST['parent_txn_id'] : '';
$payment_date = isset($_POST['payment_date']) ? $_POST['payment_date'] : '';
$payment_status = isset($_POST['payment_status']) ? $_POST['payment_status'] : '';
$payment_type = isset($_POST['payment_type']) ? $_POST['payment_type'] : '';
$pending_reason = isset($_POST['pending_reason']) ? $_POST['pending_reason'] : '';
$protection_eligibility  = isset($_POST['protection_eligibility']) ? $_POST['protection_eligibility'] : '';
$reason_code = isset($_POST['reason_code']) ? $_POST['reason_code'] : '';
$remaining_settle = isset($_POST['remaining_settle']) ? $_POST['remaining_settle'] : '';
$shipping_method = isset($_POST['shipping_method']) ? $_POST['shipping_method'] : '';
$shipping = isset($_POST['shipping']) ? $_POST['shipping'] : '';
$tax = isset($_POST['tax']) ? $_POST['tax'] : '';
$transaction_entity = isset($_POST['transaction_entity']) ? $_POST['transaction_entity'] : '';
$txn_id = isset($_POST['txn_id']) ? $_POST['txn_id'] : '';
$txn_type = isset($_POST['txn_type']) ? $_POST['txn_type'] : '';
// Currency and Currency Exchange Information
$exchange_rate = isset($_POST['exchange_rate']) ? $_POST['exchange_rate'] : '';
$mc_currency = isset($_POST['mc_currency']) ? $_POST['mc_currency'] : '';
$settle_amount = isset($_POST['settle_amount']) ? $_POST['settle_amount'] : '';
$settle_currency = isset($_POST['settle_currency']) ? $_POST['settle_currency'] : '';

// Auction Variables
$auction_buyer_id = isset($_POST['auction_buyer_id']) ? $_POST['auction_buyer_id'] : '';
$auction_closing_date = isset($_POST['auction_closing_date']) ? $_POST['auction_closing_date'] : '';
$auction_multi_item = isset($_POST['auction_multi_item']) ? $_POST['auction_multi_item'] : '';
$for_auction = isset($_POST['for_auction']) ? $_POST['for_auction'] : '';

// Mass Payments
$i = 1;
$mass_payments = array();
while(isset($_POST['masspay_txn_id_' . $i]))
{
$masspay_txn_id = isset($_POST['masspay_txn_id_' . $i]) ? $_POST['masspay_txn_id_' . $i] : '';
$mc_currency = isset($_POST['mc_currency_' . $i]) ? $_POST['mc_currency_' . $i] : '';
$mc_fee = isset($_POST['mc_fee_' . $i]) ? $_POST['mc_fee_' . $i] : '';
$mc_gross = isset($_POST['mc_gross_' . $i]) ? $_POST['mc_gross_' . $i] : '';
$receiver_email = isset($_POST['receiver_email_' . $i]) ? $_POST['receiver_email_' . $i] : '';
$status = isset($_POST['status_' . $i]) ? $_POST['status_' . $i] : '';
$unique_id = isset($_POST['unique_id_' . $i]) ? $_POST['unique_id_' . $i] : '';

$current_payment_data_set = array(
'masspay_txn_id' => $masspay_txn_id,
'mc_currency' => $mc_currency,
'mc_fee' => $mc_fee,
'mc_gross' => $mc_gross,
'receiver_email' => $receiver_email,
'status' => $status,
'unique_id' => $unique_id
);

array_push($mass_payments, $current_payment_data_set);
$i++;
}
// Recurring Payments Information
$initial_payment_status = isset($_POST['initial_payment_status']) ? $_POST['initial_payment_status'] : '';
$initial_payment_txn_id = isset($_POST['initial_payment_txn_id']) ? $_POST['initial_payment_txn_id'] : '';
$recurring_payment_id = isset($_POST['recurring_payment_id']) ? $_POST['recurring_payment_id'] : '';
$product_name = isset($_POST['product_name']) ? $_POST['product_name'] : '';
$product_type = isset($_POST['product_type']) ? $_POST['product_type'] : '';
$period_type = isset($_POST['period_type']) ? $_POST['period_type'] : '';
$payment_cycle = isset($_POST['payment_cycle']) ? $_POST['payment_cycle'] : '';
$outstanding_balance = isset($_POST['outstanding_balance']) ? $_POST['outstanding_balance'] : '';
$amount_per_cycle = isset($_POST['amount_per_cycle']) ? $_POST['amount_per_cycle'] : '';
$initial_payment_amount = isset($_POST['initial_payment_amount']) ? $_POST['initial_payment_amount'] : '';
$profile_status = isset($_POST['profile_status']) ? $_POST['profile_status'] : '';
$amount = isset($_POST['amount']) ? $_POST['amount'] : '';
$time_created = isset($_POST['time_created']) ? $_POST['time_created'] : '';
$next_payment_date = isset($_POST['next_payment_date']) ? $_POST['next_payment_date'] : '';
$rp_invoice_id = isset($_POST['rp_invoice_id']) ? $_POST['rp_invoice_id'] : '';

// Subscription Variables
$subscr_date = isset($_POST['subscr_date']) ? $_POST['subscr_date'] : '';
$subscr_effective = isset($_POST['subscr_effective']) ? $_POST['subscr_effective'] : '';
$period1 = isset($_POST['period1']) ? $_POST['period1'] : '';
$period2 = isset($_POST['period2']) ? $_POST['period2'] : '';
$period3 = isset($_POST['period3']) ? $_POST['period3'] : '';
$amount1 = isset($_POST['amount1']) ? $_POST['amount1'] : '';
$amount2 = isset($_POST['amount2']) ? $_POST['amount2'] : '';
$amount3 = isset($_POST['amount3']) ? $_POST['amount3'] : '';
$mc_amount1 = isset($_POST['mc_amount1']) ? $_POST['mc_amount1'] : '';
$mc_amount2 = isset($_POST['mc_amount2']) ? $_POST['mc_amount2'] : '';
$mc_amount3 = isset($_POST['mc_amount3']) ? $_POST['mc_amount3'] : '';
$mc_currency = isset($_POST['mc_currency']) ? $_POST['mc_currency'] : '';
$recurring = isset($_POST['recurring']) ? $_POST['recurring'] : '';
$reattempt = isset($_POST['reattempt']) ? $_POST['reattempt'] : '';
$retry_at = isset($_POST['retry_at']) ? $_POST['retry_at'] : '';
$recur_times = isset($_POST['recur_times']) ? $_POST['recur_times'] : '';
$username = isset($_POST['username']) ? $_POST['username'] : '';
$password = isset($_POST['password']) ? $_POST['password'] : '';
$subscr_id = isset($_POST['subscr_id']) ? $_POST['subscr_id'] : '';

// Dispute Notification Variables
$case_id = isset($_POST['case_id']) ? $_POST['case_id'] : '';
$case_type = isset($_POST['case_type']) ? $_POST['case_type'] : '';
$case_creation_date = isset($_POST['case_creation_date']) ? $_POST['case_creation_date'] : '';
?>

And here is a SQL file you can use to easily create the database tables.

-- phpMyAdmin SQL Dump
-- version 3.1.1
-- http://www.phpmyadmin.net
--
-- Host: localhost
-- Generation Time: Feb 20, 2009 at 11:17 PM
-- Server version: 5.0.67
-- PHP Version: 5.2.6

SET SQL_MODE="NO_AUTO_VALUE_ON_ZERO";

--
-- Database: `paypal_ipn`
--

-- --------------------------------------------------------

--
-- Table structure for table `paypal_disputes`
--

CREATE TABLE IF NOT EXISTS `paypal_disputes` (
`id` tinyint(10) NOT NULL auto_increment,
`txn_id` varchar(25) collate utf8_bin NOT NULL,
`case_id` varchar(25) collate utf8_bin NOT NULL,
`case_type` varchar(25) collate utf8_bin NOT NULL,
`case_creation_date` varchar(100) collate utf8_bin NOT NULL,
`payment_date` varchar(100) collate utf8_bin NOT NULL,
`receipt_id` varchar(25) collate utf8_bin NOT NULL,
`verify_sign` varchar(255) collate utf8_bin NOT NULL,
`payer_email` varchar(127) collate utf8_bin NOT NULL,
`payer_id` varchar(20) collate utf8_bin NOT NULL,
`invoice` varchar(127) collate utf8_bin NOT NULL,
`reason_code` varchar(25) collate utf8_bin NOT NULL,
`custom` varchar(255) collate utf8_bin NOT NULL,
`notify_version` varchar(25) collate utf8_bin NOT NULL,
`creation_timestamp` timestamp NOT NULL default CURRENT_TIMESTAMP,
PRIMARY KEY  (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin AUTO_INCREMENT=1 ;

--
-- Dumping data for table `paypal_disputes`
--

-- --------------------------------------------------------

--
-- Table structure for table `paypal_ipn_log`
--

CREATE TABLE IF NOT EXISTS `paypal_ipn_log` (
`id` tinyint(4) NOT NULL auto_increment,
`created_timestamp` timestamp NOT NULL default CURRENT_TIMESTAMP,
`ipn_data_serialized` text collate utf8_bin NOT NULL,
PRIMARY KEY  (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin AUTO_INCREMENT=1 ;

--
-- Dumping data for table `paypal_ipn_log`
--

-- --------------------------------------------------------

--
-- Table structure for table `paypal_mass_payments`
--

CREATE TABLE IF NOT EXISTS `paypal_mass_payments` (
`id` tinyint(4) NOT NULL auto_increment,
`masspay_txn_id` varchar(25) collate utf8_bin NOT NULL,
`mc_currency` varchar(50) collate utf8_bin NOT NULL,
`mc_fee` double NOT NULL,
`mc_gross` double NOT NULL,
`receiver_email` varchar(127) collate utf8_bin NOT NULL,
`status` varchar(25) collate utf8_bin NOT NULL,
`unique_id` varchar(20) collate utf8_bin NOT NULL,
`creation_timestamp` timestamp NOT NULL default CURRENT_TIMESTAMP,
PRIMARY KEY  (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin AUTO_INCREMENT=1 ;

--
-- Dumping data for table `paypal_mass_payments`
--

-- --------------------------------------------------------

--
-- Table structure for table `paypal_orders`
--

CREATE TABLE IF NOT EXISTS `paypal_orders` (
`id` tinyint(10) unsigned NOT NULL auto_increment,
`receiver_email` varchar(127) collate utf8_bin NOT NULL,
`payment_status` varchar(25) collate utf8_bin NOT NULL,
`pending_reason` varchar(25) collate utf8_bin NOT NULL,
`payment_date` varchar(100) collate utf8_bin NOT NULL,
`mc_gross` double NOT NULL,
`mc_fee` double NOT NULL,
`tax` double NOT NULL,
`mc_currency` varchar(10) collate utf8_bin NOT NULL,
`txn_id` varchar(25) collate utf8_bin NOT NULL,
`txn_type` varchar(25) collate utf8_bin NOT NULL,
`first_name` varchar(75) collate utf8_bin NOT NULL,
`last_name` varchar(75) collate utf8_bin NOT NULL,
`address_street` varchar(200) collate utf8_bin NOT NULL,
`address_city` varchar(50) collate utf8_bin NOT NULL,
`address_state` varchar(40) collate utf8_bin NOT NULL,
`address_zip` varchar(20) collate utf8_bin NOT NULL,
`address_country` varchar(64) collate utf8_bin NOT NULL,
`address_status` varchar(25) collate utf8_bin NOT NULL,
`payer_email` varchar(127) collate utf8_bin NOT NULL,
`payer_status` varchar(25) collate utf8_bin NOT NULL,
`payment_type` varchar(25) collate utf8_bin NOT NULL,
`notify_version` varchar(50) collate utf8_bin NOT NULL,
`verify_sign` varchar(255) collate utf8_bin NOT NULL,
`address_name` varchar(130) collate utf8_bin NOT NULL,
`protection_eligibility` varchar(50) collate utf8_bin NOT NULL,
`ipn_status` varchar(25) collate utf8_bin NOT NULL,
`subscr_id` varchar(25) collate utf8_bin NOT NULL,
`custom` varchar(255) collate utf8_bin NOT NULL,
`reason_code` varchar(25) collate utf8_bin NOT NULL,
`contact_phone` varchar(25) collate utf8_bin NOT NULL,
`item_name` varchar(127) collate utf8_bin NOT NULL,
`item_number` varchar(127) collate utf8_bin NOT NULL,
`invoice` varchar(127) collate utf8_bin NOT NULL,
`for_auction` tinyint(10) NOT NULL,
`auction_buyer_id` varchar(75) collate utf8_bin NOT NULL,
`auction_closing_date` varchar(100) collate utf8_bin NOT NULL,
`auction_multi_item` double NOT NULL default '1',
`creation_timestamp` timestamp NOT NULL default CURRENT_TIMESTAMP,
`address_country_code` varchar(2) collate utf8_bin NOT NULL,
PRIMARY KEY  (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin AUTO_INCREMENT=1 ;

--
-- Dumping data for table `paypal_orders`
--

-- --------------------------------------------------------

--
-- Table structure for table `paypal_order_items`
--

CREATE TABLE IF NOT EXISTS `paypal_order_items` (
`id` tinyint(10) NOT NULL auto_increment,
`order_id` tinyint(10) NOT NULL,
`subscr_id` varchar(25) collate utf8_bin NOT NULL,
`item_name` varchar(130) collate utf8_bin NOT NULL,
`item_number` varchar(130) collate utf8_bin NOT NULL,
`os0` varchar(200) collate utf8_bin NOT NULL,
`on0` varchar(75) collate utf8_bin NOT NULL,
`os1` varchar(200) collate utf8_bin NOT NULL,
`on1` varchar(75) collate utf8_bin NOT NULL,
`quantity` double NOT NULL default '0',
`custom` varchar(255) collate utf8_bin NOT NULL,
`mc_gross` double NOT NULL default '0',
`mc_handling` double NOT NULL default '0',
`mc_shipping` double NOT NULL default '0',
`creation_timestamp` timestamp NOT NULL default CURRENT_TIMESTAMP,
PRIMARY KEY  (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin AUTO_INCREMENT=1 ;

--
-- Dumping data for table `paypal_order_items`
--

-- --------------------------------------------------------

--
-- Table structure for table `paypal_recurring_payments`
--

CREATE TABLE IF NOT EXISTS `paypal_recurring_payments` (
`id` tinyint(10) NOT NULL auto_increment,
`mc_gross` double NOT NULL default '0',
`protection_eligibility` varchar(50) collate utf8_bin NOT NULL,
`payment_date` varchar(100) collate utf8_bin NOT NULL,
`payment_status` varchar(25) collate utf8_bin NOT NULL,
`mc_fee` double NOT NULL default '0',
`notify_version` varchar(25) collate utf8_bin NOT NULL,
`payer_status` varchar(25) collate utf8_bin NOT NULL,
`currency_code` varchar(10) collate utf8_bin NOT NULL,
`verify_sign` varchar(255) collate utf8_bin NOT NULL,
`amount` double NOT NULL default '0',
`txn_id` varchar(25) collate utf8_bin NOT NULL,
`payment_type` varchar(25) collate utf8_bin NOT NULL,
`receiver_email` varchar(130) collate utf8_bin NOT NULL,
`receiver_id` varchar(15) collate utf8_bin NOT NULL,
`txn_type` varchar(25) collate utf8_bin NOT NULL,
`mc_currency` varchar(25) collate utf8_bin NOT NULL,
`residence_country` varchar(2) collate utf8_bin NOT NULL,
`receipt_id` varchar(50) collate utf8_bin NOT NULL,
`transaction_subject` varchar(150) collate utf8_bin NOT NULL,
`shipping` double NOT NULL default '0',
`product_type` varchar(50) collate utf8_bin NOT NULL,
`time_created` varchar(100) collate utf8_bin NOT NULL,
`rp_invoice_id` varchar(127) collate utf8_bin NOT NULL,
`ipn_status` varchar(25) collate utf8_bin NOT NULL,
`creation_timestamp` timestamp NOT NULL default CURRENT_TIMESTAMP,
PRIMARY KEY  (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin AUTO_INCREMENT=1 ;

--
-- Dumping data for table `paypal_recurring_payments`
--

-- --------------------------------------------------------

--
-- Table structure for table `paypal_recurring_payment_profiles`
--

CREATE TABLE IF NOT EXISTS `paypal_recurring_payment_profiles` (
`id` tinyint(10) NOT NULL auto_increment,
`payment_cycle` varchar(50) collate utf8_bin NOT NULL,
`txn_type` varchar(30) collate utf8_bin NOT NULL,
`last_name` varchar(75) collate utf8_bin NOT NULL,
`first_name` varchar(75) collate utf8_bin NOT NULL,
`next_payment_date` varchar(100) collate utf8_bin NOT NULL,
`residence_country` varchar(2) collate utf8_bin NOT NULL,
`initial_payment_amount` double NOT NULL default '0',
`rp_invoice_id` varchar(127) collate utf8_bin NOT NULL,
`currency_code` varchar(10) collate utf8_bin NOT NULL,
`time_created` varchar(100) collate utf8_bin NOT NULL,
`verify_sign` varchar(255) collate utf8_bin NOT NULL,
`period_type` varchar(25) collate utf8_bin NOT NULL,
`payer_status` varchar(25) collate utf8_bin NOT NULL,
`payer_email` varchar(130) collate utf8_bin NOT NULL,
`receiver_email` varchar(130) collate utf8_bin NOT NULL,
`payer_id` varchar(20) collate utf8_bin NOT NULL,
`product_type` varchar(50) collate utf8_bin NOT NULL,
`payer_business_name` varchar(130) collate utf8_bin NOT NULL,
`shipping` double NOT NULL default '0',
`amount_per_cycle` double NOT NULL default '0',
`profile_status` varchar(25) collate utf8_bin NOT NULL,
`notify_version` varchar(25) collate utf8_bin NOT NULL,
`amount` double NOT NULL default '0',
`outstanding_balance` double NOT NULL default '0',
`recurring_payment_id` varchar(50) collate utf8_bin NOT NULL,
`product_name` varchar(130) collate utf8_bin NOT NULL,
`ipn_status` varchar(25) collate utf8_bin NOT NULL,
`creation_timestamp` timestamp NOT NULL default CURRENT_TIMESTAMP,
PRIMARY KEY  (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin AUTO_INCREMENT=1 ;

--
-- Dumping data for table `paypal_recurring_payment_profiles`
--

-- --------------------------------------------------------

--
-- Table structure for table `paypal_subscriptions`
--

CREATE TABLE IF NOT EXISTS `paypal_subscriptions` (
`id` tinyint(10) NOT NULL auto_increment,
`custom` varchar(255) collate utf8_bin NOT NULL,
`subscr_id` varchar(25) collate utf8_bin NOT NULL,
`sub_event` varchar(50) collate utf8_bin NOT NULL,
`subscr_date` varchar(100) collate utf8_bin NOT NULL,
`subscr_effective` varchar(100) collate utf8_bin NOT NULL,
`period1` varchar(50) collate utf8_bin NOT NULL,
`period2` varchar(50) collate utf8_bin NOT NULL,
`period3` varchar(50) collate utf8_bin NOT NULL,
`amount1` double NOT NULL default '0',
`amount2` double NOT NULL default '0',
`amount3` double NOT NULL default '0',
`mc_amount1` double NOT NULL default '0',
`mc_amount2` double NOT NULL default '0',
`mc_amount3` double NOT NULL default '0',
`recurring` varchar(10) collate utf8_bin NOT NULL,
`reattempt` varchar(10) collate utf8_bin NOT NULL,
`retry_at` varchar(100) collate utf8_bin NOT NULL,
`recur_times` varchar(25) collate utf8_bin NOT NULL,
`username` varchar(70) collate utf8_bin NOT NULL,
`password` varchar(30) collate utf8_bin NOT NULL,
`txn_id` varchar(25) collate utf8_bin NOT NULL,
`payer_email` varchar(130) collate utf8_bin NOT NULL,
`residence_country` varchar(2) collate utf8_bin NOT NULL,
`mc_currency` varchar(10) collate utf8_bin NOT NULL,
`verify_sign` varchar(255) collate utf8_bin NOT NULL,
`payer_status` varchar(25) collate utf8_bin NOT NULL,
`first_name` varchar(75) collate utf8_bin NOT NULL,
`last_name` varchar(75) collate utf8_bin NOT NULL,
`receiver_email` varchar(130) collate utf8_bin NOT NULL,
`payer_id` varchar(15) collate utf8_bin NOT NULL,
`notify_version` varchar(25) collate utf8_bin NOT NULL,
`item_name` varchar(130) collate utf8_bin NOT NULL,
`item_number` varchar(130) collate utf8_bin NOT NULL,
`ipn_status` varchar(25) collate utf8_bin NOT NULL,
`creation_timestamp` timestamp NOT NULL default CURRENT_TIMESTAMP,
PRIMARY KEY  (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin AUTO_INCREMENT=1 ;

--
-- Dumping data for table `paypal_subscriptions`
--

-- --------------------------------------------------------

--
-- Table structure for table `paypal_subscription_payments`
--

CREATE TABLE IF NOT EXISTS `paypal_subscription_payments` (
`id` tinyint(10) NOT NULL auto_increment,
`first_name` varchar(75) collate utf8_bin NOT NULL,
`last_name` varchar(75) collate utf8_bin NOT NULL,
`payer_email` varchar(130) collate utf8_bin NOT NULL,
`memo` text collate utf8_bin NOT NULL,
`item_name` varchar(130) collate utf8_bin NOT NULL,
`item_number` varchar(130) collate utf8_bin NOT NULL,
`os0` varchar(200) collate utf8_bin NOT NULL,
`on0` varchar(65) collate utf8_bin NOT NULL,
`os1` varchar(200) collate utf8_bin NOT NULL,
`on1` varchar(65) collate utf8_bin NOT NULL,
`quantity` double NOT NULL default '0',
`payment_date` varchar(100) collate utf8_bin NOT NULL,
`payment_type` varchar(25) collate utf8_bin NOT NULL,
`txn_id` varchar(25) collate utf8_bin NOT NULL,
`mc_gross` double NOT NULL default '0',
`mc_fee` double NOT NULL default '0',
`payment_status` varchar(25) collate utf8_bin NOT NULL,
`pending_reason` varchar(25) collate utf8_bin NOT NULL,
`txn_type` varchar(30) collate utf8_bin NOT NULL,
`tax` double NOT NULL default '0',
`mc_currency` varchar(25) collate utf8_bin NOT NULL,
`reason_code` varchar(25) collate utf8_bin NOT NULL,
`custom` varchar(255) collate utf8_bin NOT NULL,
`address_country` varchar(50) collate utf8_bin NOT NULL,
`subscr_id` varchar(25) collate utf8_bin NOT NULL,
`payer_status` varchar(25) collate utf8_bin NOT NULL,
`ipn_status` varchar(25) collate utf8_bin NOT NULL,
`creation_timestamp` timestamp NOT NULL default CURRENT_TIMESTAMP,
PRIMARY KEY  (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin AUTO_INCREMENT=1 ;

--
-- Dumping data for table `paypal_subscription_payments`
--

So, we sold our item on eBay and now “evil” PayPal has placed a temporary hold on these funds, however, they’re telling us to go ahead and ship it.  The way this new system works is that our funds will not be released until one of the following things happens:

• Your buyer leaves positive feedback
• 3 days pass after delivery confirmation (via tracking number)
• 21 days have passed

Obviously, we don’t want to wait 21 days for our money.  So how can we ensure that one of the first two things happens in a timely manner so that we can have access to our money as quickly as possible?  Here are a few things to consider.

Handling Feedback

eBay’s Selling Manager application provides an easy way to automate the process of requesting feedback from your buyers.  You can create rules to send a feedback reminder x number of days after shipping it.  Beyond that, you can easily find all of your sold items that need feedback and with just a few clicks you can send out feedback request emails to every one of them with a personal, customized message to each.

If the Selling Manager doesn’t offer enough help you can use the eBay web services API to develop custom tools to completely automate the process of requesting feedback from buyers who have not left any, as well as leaving feedback for your buyers on a set schedule, after they’ve left one for you, or however you’d like to handle it.  You could even create a system that automatically tracked all of your current shipments and sent out reminders on the same day your customer received their item.  Within the reminder, ask them to inspect their item and ensure they’re happy and then please leave a feedback on eBay.

Of course, the key to obtaining a positive feedback quickly is to be honest about what you’re selling and maintain good communication with your buyer throughout the entire process.  If your buyer is truly happy with your service and the product they received they are much more likely to take a few moments and leave you a feedback.

Tracking Numbers – Proof of Delivery

PayPal will also release the funds once three days have passed after proof-of-delivery (tracking number shows delivered).  If you use PayPal’s shipping buttons to print shipping labels for your products then this step is taken care of automatically.  The tracking number is entered into the transaction details and PayPal’s system can easily track it and release the funds accordingly.  This probably covers the majority of you.

Here’s the part PayPal screwed up!  They do plan to fix it, though.

If you are NOT using PayPal’s shipping buttons to print shipping labels it can be a nightmare to maintain the tracking numbers in PayPal so that their system can successfully release funds on time.  Currently, the only way you can get your tracking information into PayPal if it was generated elsewhere is to manually add it.  There is no access to tracking information via PayPal’s web services API!

This problem could indeed be a big one.  I have a couple of clients that use FedEx for shipping so they don’t even have the choice of using PayPal’s shipping features to generate shipping labels.  As such, the only option they have is to employ somebody to enter tracking numbers manually into PayPal’s system.  As such, they typically skip this and focus on obtaining positive feedback from the buyers.

Why is PayPal Doing This?

I think the easiest way to explain why this system has been put into place is to provide an example scenario in which not having this system hurts everybody.  I’ve seen it all too often.  Consider the following:

Buyer purchases a desktop computer on eBay for $1000 from Seller.  Seller states in the auction that the computer has 4 RAM slots.  He also states that he has a 7 day return policy should anything go wrong with the sale.

Buyer pays for the item via PayPal and Seller has the money instantly.  Seller is an honest guy that just needed to get rid of this computer.  He ships the computer and assumes everything will be just fine.  Seller proceeds to spend the $1000 on this month’s bills and his PayPal account is now at $0.

Buyer receives the computer and sees that it only has 2 RAM slots in it.  He had already purchased 4 sticks of RAM and was ready to load up his new machine and is rather upset.  Buyer contacts Seller and explains the situation and also opens a new PayPal dispute claiming the item was not as described.

Seller, again, is an honest guy.  In the PayPal dispute he apologizes for his mistake and agrees that Buyer should get a full refund upon returning his item.  Buyer returns the item and provides proof-of-delivery on the returned merchandise.  PayPal sides with Buyer on the dispute and attempts to refund Buyer.

The problem is that Seller already spent the money.  Seller’s PayPal account now goes into the -$1000 balance.  PayPal has to explain to Buyer that because the Seller has insufficient funds they cannot refund the money even though they sided with Buyer on the dispute.  Buyer, of course, is not happy with this news.

Seller is also not happy because his PayPal account is now -$1000 they’re coming after him for that money.  Seller is struggling to pay it back, though, because he already spent it on his bills.

At this point Buyer is unhappy with PayPal, Seller is unhappy with PayPal, and PayPal is unhappy that they now have 2 people spreading the word on blogs that PayPal is a horrible thing.

That is just one of the many examples I’ve seen that could have been avoided if the Seller would have simply waited until the buyer had received his item and was completely happy BEFORE spending the money.  Buyer would have gotten his refund and Seller could have re-listed the item and sold it again with the correct specifications.

Here’s another scenario to consider:

Scammer has a list of phished eBay and PayPal accounts.  Scammer proceeds to list items on these accounts that are high dollar and quick sellers.  Things like iPhones, laptops, and the likes.  Scammer sells approximately 20 of these items without any intention of ever delivering a single thing to anybody.  Unsuspecting buyers purchase these items and send payment right away.  Scammer then moves the money from these payments between a bunch of different phished accounts to make it hard to track and eventually gets out with cash or might even use the funds to purchase items and have them shipped to “drop-spots” where they will be able to obtain the merchandise.

In such a case, once PayPal discovers this has happened they are forced to freeze ALL ACCOUNTS INVOLVED while they investigate and try to track down all of the money that has now flooded their system with disputes.  Now you’ve got a whole mess of upset customers.

Again, this scam could have been avoided had the funds not been made available until after the buyers actually had their items, which in this case would have been never.  Then, when disputes were filed the funds would still be available to refund to the buyer.

Once more, these are just a couple examples of the many crazy scenarios I’ve seen with buyers and sellers on eBay using PayPal.  By implementing systems like this “Escrow” holding, huge problems can be avoided and if you follow the guidelines of the system it will not be a nuisance.

PCI Compliance Updates
In previous versions, credit card data was encrypted, however, it was still stored internally within USBSwiper. With version 3.3 this is no longer the case. Card data is only stored until it’s successfully processed, at which point the data is wiped clean from USBSwiper and only “display” fields are shown (ie. xxxx-xxxx-xxxx-4532).

Invoice Items Updates
The drop-down list in the items area of invoices now sorts alphabetically instead of numerically on the internal ID. Also, the custom item ID field can be edited directly on the Invoices screen to add items rather than through the drop-down list or the search area. This way you can quickly add items if you know your own ID or if you have a bar-code system in place.

Authorization Features Now Included
USBSwiper 3.3 includes the ability to authorize a credit card prior to capturing the final order amount. This feature was requested mostly from restaurant owners who would typically need to apply a tip after authorization the customer’s credit card. You may configure USBSwiper to automatically authorize all new invoices or you may set each individual invoice to authorize only when necessary. The authorization is just for $1.00 and immediately releases the authorization back to the bank. It’s simply used to ensure the card is valid.

Sales Tax, Discount Codes, Handling Fee Updates
These features have been completely revamped to allow multiple options for each. You may now set up a complete table of all sales tax rates you might need. For example, if you charge different rates for different counties/cities you can easily include them. Also, inventory items may be marked as Taxable to ensure only the items you need to tax are included in the sales tax calculations. Discount Codes and Handling Fees can be maintained much like sales tax. You can add as many different codes as you like and each can be either flat-rate or percentage based. You may set defaults for each within your Setup screen and you may adjust invoice individually as well.

Currency Updates
Version 3.3 now allows you to adjust the currency processed on the invoice. You may set a default currency within your Setup screen and you may also adjust the currency on each individual invoice as needed.

More General Updates

• Internal notes from USBSwiper are now included in requests to PayPal so they can be seen in the PayPal transaction details.
• Partial refunds and the ability to leave refund notes has been included. Multiple partial refunds are also available up to the original full amount.
• Added option to print invoices without displaying the options dialog so you don’t have to say OK when you print an invoice. This option can be set within your Setup screen via a check box.
• Fixed invoice items so that if you edit the name(s) on the invoice screen it reflects on receipts and in PayPal transaction details. Previously, it would still use the name that was stored in Products.
• Added last 4 digits of credit card number and the PayPal transaction ID to all receipts.
• Added shipping address information on Invoices. If shipping information is included it’s passed to PayPal accordingly.
• Re-activating a software license no longer creates additional Setup records, therefore, you can re-activate without causing confguration problems.
• Fixed a bug where a validation error would occur when switching to Key mode after having already swiped a credit card.
• Added options to the payment type field to help maintain all types of transactions: Cash, Check, Money Order, Other.

Invoicing Updates
Previously, the only way you could add items to your invoices was to click on the ID column of the list within the invoice and select products from the drop down list provided. This worked well if you’re only dealing with a couple of items but was horrible for handling any real type of inventory at all.

You can still add items using the ID drop down menu, however, there is now a feature to search for an item by Item ID, Name, or Price. You simply click an Add Item button on the returned item to add it to your current invoice. This allows you to add items much more quickly and without the hassle of the drop down.

Error Reporting
Previously when an error was returned trying to charge a credit card you had to click into the log in order to find the error information. Now, anytime an error is returned it will be displayed immediately in a pop-up dialog so you know right away what went wrong without any confusion or extra clicks involved.

Receipt Printing Updates
There are now layouts to handle the following receipt printer sizes: 2.25″, 3″, 4″ and full 8.5″ x 11″.  Also, the receipt layouts now dynamically adjust according to the number of items on them so you’re not wasting any of your receipt paper roll!

The items on the invoice and receipts have been adjusted to sort first by price (high to low) and then by name (alphabetically).

Automated Features Updates
We have added options in your Setup panel which allow you to activate the automation of various tasks within USBSwiper. The following features are available…

• Automatically include sales tax / handling fees on all new invoices.
• Automatically process the credit card upon swiping so you don’t have to click the process button!
• Automatically print receipts upon a successful transaction.

John Donahoe, CEO of eBay, and and Glenn Lim, Manager of PayPal Developer Services, present Andrew Angell with an eBay Live! 2008 Star Developer Award.

“eBay and its community depends upon third-party developers to drive innovation and to create the tools that drive buyer and seller engagement,” said Max Mancini, senior director of Platform and Disruptive Innovation at eBay, who announced the winners today at the seventh annual eBay Developers Conference at Chicago’s McCormick Place West convention center. “It’s with great honor that we recognize these award winners for their achievements and innovation.”

Award Winners Included

• DSR Rockstar - ShipRush by Z-Firm (USA)
• Most Innovative Application - Jaast for Wii by Scendix Software (Germany)
• Early Adopter - iRibbit by Aduci (USA)
• Service to the Developer Community - Joe Fox (elzorro) of BD Network (UK)
• Best Design - Kyozou Widget by Kyozou (Canada)
• PayPal Most Innovative Application - Eventbrite (USA)
• PayPal Service to the Developer Community - Andrew Angell (angelleye) of USBSwiper (USA)

Award Runners-Up Include

• DSR Rockstar - ezSupport for eBay by HostedSupport (USA)
• Most Innovative Application - Mobile Alerts for Sellers by ahTXT (USA)
• Early Adopter - GarageBuy by iwascoding (Germany)
• Service to the Developer Community - Anthony Sukow of Terapeak (Canada)
• Best Design - Video advertisements for eBay listings by Vzaar (UK)

The Star Developer Awards are presented annually to recognize the talent and dedication of members of the eBay Developers Program who have shown the most innovative use of the eBay and PayPal platforms and made extraordinary contributions to the community.

“The Star Developer Awards embody the best of what the eBay platform is all about by taking advantage of an extensive and unique set of ecommerce-focused Web services, driving community engagement with buyers and sellers wherever they are, and creating sustainable businesses,” said Kumar Kandaswamy, senior manager, eBay Developers Program.

The PayPal Developer Community, established in 2001, is an online community of 400,000 registered Web developers, Web designers and software developers who provide e-commerce technology solutions using the PayPal platform. The program is among the largest of its kind in the world, offering developers free access to technical tools, online payments resources and related third-party applications. More information about the PayPal Developer Community can be viewed at PayPalDeveloper.com.

Not long after he landed his first programming job, Drew Angell realized he was in over his head. He needed to ramp up his education – and fast. Training videos helped him with classic ASP and PHP while web discussion forums taught him how to work with XML web services. In his search for information about PayPal, Angell stumbled across the PayPal Developer Community forums.

“I jumped in and started asking questions – and from there I was off and running,” Angell recalls. “If I got a PayPal API error that I couldn’t find in the documentation, someone on the Developer Community always stepped up with an explanation. And if I had a specific technical question, I would often get an answer from a PayPal employee within 24 hours.”

Sparking New Ideas

Today, Angell specializes in PayPal and eBay integration. He continues to hang out in the Developer Community – but now he’s the one providing answers. “People often ask questions that are covered in the PayPal documentation, so I just point them in the right direction,” says Angell. “Almost every question you can think of is covered in the Integration Center on Developer Central – it’s just a matter of knowing where to look.”

Why would a busy developer like Angell keep sharing free advice in the Developer Community? “I learn best by helping other people,” he says. “And when people ask me a tough question, it often triggers ideas for my next project.”

Boosting Business

By providing knowledgeable answers on a public forum, Angell has gained recognition as an expert in PayPal integration. As a result, he’s attracted new business. “I’ve had potential clients contact me and say, ‘I saw you answering everyone’s questions in the Developer Community, so I figured you were the guy to call for my next project,’” says Angell. “Building up a good reputation in the Developer Community is like a résumé for the electronic age.”

Forgoing traditional advertising, Angell recently used Developer Community to announce a new application he developed. It allows customers to charge credit cards via a USB swiper, rather than typing information into PayPal Virtual Terminal. “I posted a link to my video demo [at www.usbswiper.com] and got quite a few hits,” says Angell. “Developer Community is ideal for getting your name out. If you can solve people’s problems, word spreads quickly.”

Becoming an Ace Developer

Angell recently earned another perk from Developer Community when PayPal named him an Ace Developer – an honor reserved for those who make at least 150 highly rated posts. “It was cool,” says Angell. “They sent me a T-shirt, and I’m proud to wear it. I keep going back to Developer Community, not only to share my knowledge, but also to get answers that I know I can trust.”