Shipit — NextGen Crowd
Express Delivery Platform
Shipit — is a community of senders and travelers united by the mobile app that helps the former ship packages and the latter make extra money while traveling.
Private Sale Bonus up to 55% May 01—June 30
Pre Sale Bonus up to 35% August 01—August 31
Public Sale Bonus up to 15% September 01—October 31
Private Sale —
May 01—June 30. 2018
Bonus — 55%
-
days
-
hours
-
minutes
-
seconds
9 5 0
Participants in Whitelist
Join our Whitelist

It is the first app of its kind that will use smart contracts and blockchain as a native tool to make people lives easier all around the world. By implementing Shipit tokens and using the blockchain we want to build relationships between users based on transparency, safety and ease of tracking for all deliveries on the platform.

While courier services are becoming more expensive, Shipit allows users to ship and track open packages at lower costs and risks. Shipping has never been easier.

Whitepaper
download pdf file, 11.3 mb
What is ShipIt?
Shipit verifies its users and monitors all shipments providing safe delivery. Interactive interface makes the whole process simple and fast. User is free of any concerns about having missed something important.
Senders
  1. Post a listing
  2. Schedule a meetup with a traveler
  3. Use tracking system
  4. Track the delivery
  5. Pay for the delivery
Travelers
  1. Pick a listing
  2. Schedule a meetup with a sender
  3. Communicate with the sender in real time
  4. Deliver the shipment
  5. Get paid
Known issues of courier and delivery companies
  • High shipping costs
  • Long delivery time
  • Shipments get lost or damaged
Why is shipping so expensive?
Significant operating costs. Courier and delivery services are forced to have thousands of employees, machinery, and equipment units.
Company Market share, % Employees Air means of transport (owned and leased), in units. Motor means of transport (owned and leased), in units.
DHL 38% 508 000 188 76 000
Fedex Corp 24% 400 000 657 58 000
UPS 22% 268 000 657 86 000
TNT 5% 56 000 56 30 000
Other 11%
Fact: Shipping a package of documents from Moscow to New York will cost more than $200. Although, the value of the documents might be even less than $20
Why do shipments get delayed?
Transit hubsDelivery services often cannot ship a parcel directly from one point to another.
BureaucracyParcels are often processed by customs and postal systems.
IntermediariesCourier and delivery companies are sometimes forced to rely on third party services.
15%
Fact:"According to the report by Mintel 15% of delivery companies' customers from Great Britain had to put up with delivery delays and waiting."
Why do shipments get lost or damaged?
TheftCustoms, courier and postal services' employees steal shipments.
Absence of personal responsibility Customs, courier and postal services' employees treat shipments irresponsibly and with negligence.
10/100
Fact:"According to the report by Mintel 10 out of 100 delivery companies' customers from Great Britain had to deal with their shipments getting lost or damaged."
The future belongs to sharing
economy and crowdshipping
"The idea of collaborative consumption is one OF those that are going to change our world within the next 10 years."
TIME Magazine
Although, there are prominent players in some sharing economy industries such as Airbnb in traveling, ZipCar in carsharing, Uber in taxi – the crowd shipping market is still at its very early stages of development. The number of start-ups contributing to sharing economy and attracting more investments grows annually.
Year 2007 2010 2013 2016
Start-ups that attracted investments 40 85 271 420
Overall investments, $ bln 0,04 0,13 1,74 23,4
Revenues, $ bln 2 5,5 15 41
Why sharing
economy is popular
55% Urban
population
63% Smartphone
penetration
48% Internet
penetration
12% Middle class
growth
Buy tokens
Technology
  • Smart contracts and Blockchain
  • Crypto wallet
  • Deposits
  • Factoring
  • Mail forwarding
Smart contracts connect people within the system and make them aware of their responsibilities, because all their activities will be recorded and stored on blockchain without any possibility to manipulate the recorded data.
How it works Result
Profiles Blockchain provides transparency of user record. More responsible users.
Automatization Smart contracts allow to automatize processes and make them safer. Guaranteed absence of errors and manipulations.
Safety All private user data is hashed. Intercepting a hash gains nothing since it is impossible to identify it.
Fiat transactions may be subject to certain barriers that negatively affect the scalability of the app. Governmental bodies sometimes enforce long, costly, bureaucratic procedures that an enterprise is obliged to pass in order for its users in that particular jurisdiction to be able to execute transactions. That is where our own cryptocurrency and crypto wallet come into play.
Reason Result
Freedom
of payments
International banking transactions between citizens of diffirent countries may be unavailable due to bureaucracy and sanctions. Cryptocurrencies are not easy to regulate. This allows paying a traveler in any cryptocurrency.
Convenient
conversion
To convert fiat currency user needs to execute several excessive transactions. User can execute a payment in any way they find convenient by converting fiat to crypto in the app.
Quick payments Fiat transactions may take a long time and get delayed. Faster processed cryptocurrencies would allow to execute almost instant transactions.
To ensure a safe delivery, a sender may request a deposit to be created by a traveler and kept by Shipit app. This function is optional and is applicable in case the item shipped has high value and the traveler who responded to the listing is willing to comply with deposit requirements.
Senders Deposits posted by travelers serve as an insurance for shipments in case of theft, loss or damage.
Travelers In case of incompliance with Shipit rules and requirements, loss, theft, or damage, travelers are not refunded the amount deposited. They will not be able to earn money and will be excluded from the system.
Factoring solves the issue of a deposit for shipment's safety payable by a traveler. Shipit makes a deposit for the traveler – only a small factoring fee is required.
Mail forwarding means purchasing an item internationally and further forwarding it from the country of purchase by intermediary's services. Foreign online and offline stores may have certain advantages unlike those in your country, such as lower prices and wider range. Some brands may even be unavailable in certain countries, therefore, mail forwarding might be the only viable option to get access to their goods.
How it works:
  1. A customer posts a listing in Shipit with a detailed description of a desired item.
  2. Shipit finds a traveler who is flying to customer's region of residence.
  3. The customer creates a deposit and sets a fee.
  4. The traveler buys the item and flies to the customer's region of residence.
  5. The traveler hands off the item to the customer.
  6. Shipit transfers the fee and the amount payable for the item to the traveler.
  7. Shipit recieves a commission.
Shipit mail forwarding advantages:
  • 1,5-3 times lower shipping fees.
  • Access to any goods all around the globe.
  • Access to exclusive items unavailable in the customer's region of residence.
  • Higher speed of delivery.
  • High-quality service and guaranteed safety.

Security

The Shipit development team has spent numerous hours working on optimization of all system components and processes of international deliveries. The app's goal is to provide a safe, simple and fast way of shipping items and an opportunity to earn money delivering them. Special attention was given to issues of safety of our users. We must be sure that no activities in Shipit break any shipping rules and regulations and the items shipped satisfy any and all international standard requirements.

Whitepaper

Key Features

Join now
Comparison
Let people ship your packages.
  • Courier services
  • Crowd services
  • Crowdshipping services
  • Crowdsourced logistics
DHL Fedex UPS USPS
Price $60 $261 $163-$220 $166-$224 $90
Delivery
time
5 days
or less
1—3
business days
5—7
business days
7
business days
21
business days
Safety and
convenience
  • Reliable and verified travelers
  • Integrated chat, reviews and recommendations, deposits and digital security system
  • Customs procedures cause delays
  • No international P2P shipping
  • Limited list of items allowed
  • Customs procedures cause delays
  • No international P2P shipping
  • Limited list of items allowed
  • Customs procedures cause delays
  • No international P2P shipping
  • Limited list of items allowed
  • Tracking a shipment may be unavailable once it crosses borders
  • Shipments get lost, damaged or stolen at customs or postal offices
Uber BlaBlaCar Gett Delivery
Crowdshipping Yes Optional Optional Yes
Available means of transport Cars, Motorbikes, Trains, Planes Cars Cars Cars
Average delivery distance more than 500 km less than 500 km less than 500 km less than 500 km
User profiles on blockchain Yes No No No
System of deposits and insurances for high-value items (optional) Yes No No No
PiggyBee AirMule Hitchit
Interactive map
Mobile app
Verification of travelers
Verification of senders
Reviews on blockchain platform
Preliminary monitoring of shipments
Safe payments
Cryptocurrency payments
Smart contracts
Digital safety systems
Mail forwarding
Crowdsource Logistics
Courier Logistics
Less Trust
More Trust
3 Reasons To Use
Shipit Right Away
Friendly Community We support each other and supervise the quality of service. All users pass verification to build trust and ensure transparency.
Usability Crowdsource models and sharing economy have proven to be highly-demanded, popular and effective. Each smartphone is going to have installed Shipit app in the nearest future. Become part of new history.
Efficiency Wherever you are, you will always be able to find someone who could make a delivery for you. Ship items to over 1000+ km and still save money.
Join Our Telegram
Token Distribution
  • 75%Token Sale
  • 15%Team
  • 5%Partners and advisors
  • 5%Bounty campaign
Token Sale Funds Allocation
  • 37%Development, product
    improvement and technical perfecting
  • 55%Marketing and advertising
  • 5%Legal
  • 3%Other
Smart contract
                    
pragma solidity ^0.4.19;
/**
* @title ERC20Basic
* @dev Simpler version of ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/179
*/
contract ERC20Basic {
    function totalSupply() public view returns (uint256);
    function balanceOf(address who) public view returns (uint256);
    function transfer(address to, uint256 value) public returns (bool);
    event Transfer(address indexed from, address indexed to, uint256 value);
}
/**
* @title ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
contract ERC20 is ERC20Basic {
    function allowance(address owner, address spender) public view returns (uint256);
    function transferFrom(address from, address to, uint256 value) public returns (bool);
    function approve(address spender, uint256 value) public returns (bool);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
    /**
    * @dev Multiplies two numbers, throws on overflow.
    */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }
        uint256 c = a * b;
        assert(c / a == b);
        return c;
    }
    /**
    * @dev Integer division of two numbers, truncating the quotient.
    */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        // assert(b > 0); // Solidity automatically throws when dividing by 0
        // uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold
        return a / b;
    }
    /**
    * @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
    */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        assert(b <= a);
        return a - b;
    }
    /**
    * @dev Adds two numbers, throws on overflow.
    */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        assert(c >= a);
        return c;
    }
}
/**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/
contract BasicToken is ERC20Basic {
    using SafeMath for uint256;
    mapping(address => uint256) balances;
    uint256 totalSupply_;
    /**
    * @dev total number of tokens in existence
    */
    function totalSupply() public view returns (uint256) {
        return totalSupply_;
    }
    /**
    * @dev transfer token for a specified address
    * @param _to The address to transfer to.
    * @param _value The amount to be transferred.
    */
    function transfer(address _to, uint256 _value) public returns (bool) {
        require(_to != address(0));
        require(_value <= balances[msg.sender]);
        balances[msg.sender] = balances[msg.sender].sub(_value);
        balances[_to] = balances[_to].add(_value);
        emit Transfer(msg.sender, _to, _value);
        return true;
    }
    /**
    * @dev Gets the balance of the specified address.
    * @param _owner The address to query the the balance of.
    * @return An uint256 representing the amount owned by the passed address.
    */
    function balanceOf(address _owner) public view returns (uint256 balance) {
        return balances[_owner];
    }
}
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/
contract StandardToken is ERC20BasicToken {
    mapping (address => mapping (address => uint256)) internal allowed;
    /**
    * @dev Transfer tokens from one address to another
    * @param _from address The address which you want to send tokens from
    * @param _to address The address which you want to transfer to
    * @param _value uint256 the amount of tokens to be transferred
    */
    function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
        require(_to != address(0));
        require(_value <= balances[_from]);
        require(_value <= allowed[_from]‌[msg.sender]);
        balances[_from] = balances[_from].sub(_value);
        balances[_to] = balances[_to].add(_value);
        allowed[_from]‌[msg.sender] = allowed[_from]‌[msg.sender].sub(_value);
        emit Transfer(_from, _to, _value);
        return true;
    }
    /**
    * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
    *
    * Beware that changing an allowance with this method brings the risk that someone may use both the old
    * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
    * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
    * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
    * @param _spender The address which will spend the funds.
    * @param _value The amount of tokens to be spent.
    */
    function approve(address _spender, uint256 _value) public returns (bool) {
        allowed[msg.sender]‌[_spender] = _value;
        emit Approval(msg.sender, _spender, _value);
        return true;
    }
    /**
    * @dev Function to check the amount of tokens that an owner allowed to a spender.
    * @param _owner address The address which owns the funds.
    * @param _spender address The address which will spend the funds.
    * @return A uint256 specifying the amount of tokens still available for the spender.
    */
    function allowance(address _owner, address _spender) public view returns (uint256) {
        return allowed[_owner]‌[_spender];
    }
    /**
    * @dev Increase the amount of tokens that an owner allowed to a spender.
    *
    * approve should be called when allowed[_spender] == 0. To increment
    * allowed value is better to use this function to avoid 2 calls (and wait until
    * the first transaction is mined)
    * From MonolithDAO Token.sol
    * @param _spender The address which will spend the funds.
    * @param _addedValue The amount of tokens to increase the allowance by.
    */
    function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
        allowed[msg.sender]‌[_spender] = allowed[msg.sender]‌[_spender].add(_addedValue);
        emit Approval(msg.sender, _spender, allowed[msg.sender]‌[_spender]);
        return true;
    }
    /**
    * @dev Decrease the amount of tokens that an owner allowed to a spender.
    *
    * approve should be called when allowed[_spender] == 0. To decrement
    * allowed value is better to use this function to avoid 2 calls (and wait until
    * the first transaction is mined)
    * From MonolithDAO Token.sol
    * @param _spender The address which will spend the funds.
    * @param _subtractedValue The amount of tokens to decrease the allowance by.
    */
    function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
        uint oldValue = allowed[msg.sender]‌[_spender];
        if (_subtractedValue > oldValue) {
            allowed[msg.sender]‌[_spender] = 0;
        } else {
            allowed[msg.sender]‌[_spender] = oldValue.sub(_subtractedValue);
        }
        emit Approval(msg.sender, _spender, allowed[msg.sender]‌[_spender]);
        return true;
    }
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
    address public owner;
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    /**
    * @dev The Ownable constructor sets the original `owner` of the contract to the sender
    * account.
    */
    function Ownable() public {
        owner = msg.sender;
    }
    /**
    * @dev Throws if called by any account other than the owner.
    */
    modifier onlyOwner() {
        require(msg.sender == owner);
        _;
    }
    /**
    * @dev Allows the current owner to transfer control of the contract to a newOwner.
    * @param newOwner The address to transfer ownership to.
    */
    function transferOwnership(address newOwner) public onlyOwner {
        require(newOwner != address(0));
        emit OwnershipTransferred(owner, newOwner);
        owner = newOwner;
    }
}
contract SHPT is OwnableStandardToken  {
    string public constant name = "Shipit Token";
    string public constant symbol = "SHPT";
    uint8 public constant decimals = 8;
    uint256 public constant INITIAL_SUPPLY = (500 * (10**6)) * (10 ** uint256(decimals));
    constructor() public {
        totalSupply_ = INITIAL_SUPPLY;
        balances[this] = INITIAL_SUPPLY;
        emit Transfer(address(0), this, INITIAL_SUPPLY);
    }
    //отправка токенов, с адреса контракта
    function send(address to, uint amount) public onlyOwner {
        require(to != address(0));
        require(amount > 0);
        // SafeMath.sub will throw if there is not enough balance.
        balances[this] = balances[this].sub(amount);
        balances[to] = balances[to].add(amount);
        emit Transfer(this, to, amount);
    }
    //эмиссия токенов и перевод на указанный адрес
    function mint(address to, uint amount) public onlyOwner {
        require(to != address(0));
        require(amount > 0);
        totalSupply_ = totalSupply_.add(amount);
        balances[to] = balances[to].add(amount);
        emit Transfer(address(0), to, amount);
    }
    //сожжение токенов с указанного адреса
    function burn(address from, uint amount) public onlyOwner {
        require(from != address(0));
        require(amount > 0);
        // SafeMath.sub will throw if there is not enough balance.
        totalSupply_ = totalSupply_.sub(amount);
        balances[from] = balances[from].sub(amount);
        emit Transfer(from, address(0), amount);
    }
    function() public payable {}
    //отправка эфира
    function sendEther(address to, uint amount) public onlyOwner {
        require(to != address(0));
        require(amount > 0);
        to.transfer(amount);
    }
}

Shipit — is the future of express deliveries.
Join our Token Sale!

55% Bonus
Join now