Language  Help


Public Api

MyDashWallet provides a public Api to call some of the functionality available for users on this website


Does provide an easy way to generate a mixing address like on Dash send to this address will be mixed and then forwarded to the toAddress. After this is done all traces are deleted. Use MixingStatus to check on how the mixing is doing. Small amounts (smaller than 10 Dash if enough pre-mixed Dash is available) are usually send out right away, otherwise mixing can take up to 12h, which is outside of our control and depends on the Dash network conditions. is one of the most successful parts of this website, check it out on how much mixing activity is here in the upper right corner on that page.


Returns a string on the current mixing status, especially on incoming amounts, outgoing amounts and once it is done.

Allows to create a special Api account that can be integrated into any other app. It is up to you if you want to share the redeem link to your users or keep the funds savely locked in your app. The redeem link is needed for both api function CashOutEmailAccount and the Redeem link a user can click to control his funds himself. Please note that each email account can ONLY be created once, every other call you attempt with the same email will result in a "Account already exists" error message. The api does not check for a valid email (the email still must contain @. If a valid email is used the user will be contacted when funds arrive or when he needs to redeem them.

The disableAutoRedeem parameter will immediately redeem any funds you send to the generated user dash address. By default this is false, which means funds send to this user will automatically return after 9 days to you. Like for tipping the idea is that you freely give out Dash and you get back your funds from users not interested.

Returns the following json data:
  • Address: Generated user address you can send funds to
  • Redeem: Redeem data, this contains the private key and should not be shared or made visible except if you really want to show it to the user. See ?Redeem= link below to build a valid url from this data.
  • Email: Email this account belongs to, must be used for GetEmailAccountBalance and CashOutEmailAccount api calls below as well.
  • RedeemBy: Either "Never" or the timestamp when the user must redeem his funds (either by clicking the redeem link or if you call CashOutEmailAccount)

Returns the amount of dash currently in this account email dash address, if you have the dash address stored from CreateEmailAccount you can check this yourself in the Dash blockchain. Will return 0 if the account doesn't exist or the account is empty.

Allows your app to send all user funds to a target dash address. Must use the same email and redeem values from CreateEmailAccount. Will return the tx in the dash blockchain.

Either received by the user once he receives a tip or when using CreateEmailAccount. PLEASE NOTE that the redeem link is private and ANYONE with this link can access the funds in this account, it should never be shared or shown to anyone. Only accounts that have been created via the social platforms (Twitter, Discord, Reddit, Telegram, Email or Api) have a redeem link. Any other accounts CANNOT be redeemed and are totally under the user control, if they lose their keystore, hd wallet seed, backups or hardware wallet, no one can help.

This is an advanced function used to generate a raw transaction by a full node to be signed on the client side (in javascript). All parameters are required, if you need more examples and details you can check the index.js file running on this website. See the detailed step by step guide and lots of helpful links below to get started.
  • utxos: List of utxos as input (all of them must belong to you so you can sign them). The list is separated by | and contains the tx first and the index second.
  • channel: User channel (Reddit, Twitter, Telegram, Discord, Email, Api, etc.). If this is "Address" no user account is used and the sendTo address is used.
  • amount: Amount to send, can be the complete balance, the fee will be calculated and deduced automatically. If the utxos contain enough funds, the minimum fee is added on top of this amount. If the utxos contain not enough funds, this method will error out.
  • sendTo: If channel is "Address" this is the address used to send the funds to. Otherwise this is the account name (email, twitter account, discord name, api account, etc.) to send the funds to.
  • remainingAmount: Expected remaining amount to be send to remainingAddress.
  • remainingAddress: If there are funds left from the utxos the remainder (see remainingAmount) is send here. When everything is send this could be empty, but for safety this should always be used. Usually this is the same address as sendTo.
  • instantSend: Use instant send for this tx, affects fees.
  • privateSend: Use private send for this tx, will redirect the outputs to a generated mixing address, which will then forward to the sendTo address. Also affects fees.
  • extraText: Extra text to send along this tx, will be displayed to the target user if possible (email, twitter, discord, etc.). For chat messages this is the chat message included into the blockchain.
Returns the raw tx to be signed (e.g. with a keystore, hd wallet or hardware wallet), you can then use SendSignedTx to send it out.

To get comfortable using dashcore-lib MyDashWallet is based on you can read its documentation and also check out the many great examples at bitcore-lib examples.

The best way to look for working examples is to look at the MyDashWallet site itself (either the current index.js or the older one from When you click " Generate Transaction" on the website you pretty much call GenerateRawTx and once you confirm all the data and click SendSignedTx you send that locally signed transaction in your browser to the web server, which forwards it into the dash network. There are also several test pages that might help understand certain functionality, this one for Ledger Hardware Wallets also goes through all the steps and provides a ton of help and explanations of each step: (view html source, especially the ledgerGenerateTransaction javascript function).

GenerateRawTx is basically a helper function for things that are hard to do in the browser, the information provided by Dash explorers (like or or our own) are not sufficient to properly build a raw transaction. It is still possible with some extra information to do all this in javascript, but it is hard, thus this method exists to make this step easier, it is especially useful for hardware wallets were we directly get the utxos after enumerating the available inputs.

Let's go through it step by step:
  • If Xt8Fb2Ha5A7aXBq1hL2tKaf5yhBqr3NnQZ is our dash address, we can check its balance on any explorer: (note that can't display that many records and shows invalid received/sent numbers, insight explorers like ours work the best, this is actually the reason we run our own explorers to provide missing functionality and be able to fix issues like these).
  • We can check if our address has any unspent inputs (utxos): (again, doesn't work here, so let's use our own again: ). This gives us an array of spendable utxos, the important information for each entry is the txid and vout (transaction id and output number). We also should keep track of the amount available, this is how much we can use minus the transaction fees.
  • Now we append the utxos into a string (can be any number, let's just use one) separated with "|" for each entry (1 entry is one txid and one vout): var utxosTextWithOutputIndices = "7a0d2e43b33d00199952c9d1ae1e482313263dbcee25508bd606ff207225b747|50|" or from the /TestLedger example: "7fbbceeea88cebeff25137bcea4ae182547e306c213be4c7837e211c2004bfc7|0|"
  • The remaining information is easy, we just tell GenerateRawTx where to send the Dash to, how much and if there is any remainder left where to send that to (usually back to our own address):
    		var utxosTextWithOutputIndices = "7fbbceeea88cebeff25137bcea4ae182547e306c213be4c7837e211c2004bfc7|0|"; //assume this has 0.0001 Dash left
    		var amountToSend = 0.00009;
    		var   useInstantSend = false;
    		var toAddress = "XvHR2v53PyUMTnXgX9wBmw8N4WstZT92xG";
    		var txFee = (0.00078 + 0.00148 * 1)/1000; // 1 duff per byte, minimum possible fee (78 duff per output, 148 duff for the 1 input, see updateTxFee for details)
    		var remainingDash = 0.00001 - txFee;
    		var remainingAddress = "Xv1Tfr7aFwfSsaYkTMtVe3nBK6XsWgtiFy";
    		$.getJSON("" + utxosTextWithOutputIndices + "&amountToAddress=" + amountToSend + "|" + toAddress + "&remainingAmountToAddress=" + remainingDash + "|" + remainingAddress).done(
    		function (data) {
    			var txHashes = data["txHashes"];
    			var rawtx = data["rawtx"];
    			console.log("txHashes: %O", txHashes);
    			console.log("rawtx: %O", rawtx);
    // here you would have to sign the rawtx with your private keys, hardware wallet, hd wallet, keystore, etc.
    // for examples you can check , and now you can call 
    					$.get("" + signedTx + "&instantSend=" + useInstantSend,
    						function (finalTx) {
    							$("#response").css("color", "black")
    								.html("Successfully signed transaction and broadcasted it to the Dash network now " +
    								"(you can see the transaction in a few minutes in any Dash explorer): "+finalTx+"");
    						}).fail(function (jqxhr) {
    							$("#response").css("color", "red").text("Server Error: " + jqxhr.responseText);
    		// finally some error handling if things go wrong with GenerateRawTx
    		}).fail(function (jqxhr) {
    			$("#response").css("color", "red").text("Server Error: " + jqxhr.responseText);

Allows a raw tx (usually generated via GenerateRawTx) to be signed locally on the client side and then send it out into the dash network. This is the same as if you would call SendRawTransaction on any node yourself. SendSignedTx is very simple, all it does is execute the "SendRawTransaction" rpc call to broadcast a signed transaction into the Dash network. This is the only method that cannot be done on the client side as it must be executed on a full node with connections to other full nodes to broadcast the signed transaction. You can also see whats happening when you send a transaction on and click on "Show details for geeks after generating a transaction", users can also execute this command themselves in any dash node or rpc connected node or on other services.
  • signedTx: List of utxos as input (all of them must belong to you so you can sign them). The list is separated by | and contains the tx first and the index second.
  • useInstantSend: Use instant send, should match GenerateRawTx instantSend parameter.
Returns the final tx in the dash network you can check with any explorer.

Currently the API is available via Http Get calls, you can also use any of the javascript code yourself. Feel free to contact us to support more use cases. Btw: There are many hidden features on the website and bot, ask the team and others to find them all out, e.g. ?AccountNumber=1 appended to your url lets you access your second account, third account, etc. on your hd wallet or hardware wallet.