xenial (1) aria2c.1.gz

Provided by: aria2_1.19.0-1build1_amd64 bug

NAME

       aria2c - The ultra fast download utility

SYNOPSIS

       aria2c [<OPTIONS>] [<URI>|<MAGNET>|<TORRENT_FILE>|<METALINK_FILE>] ...

DESCRIPTION

       aria2 is a utility for downloading files. The supported protocols are HTTP(S), FTP, SFTP, BitTorrent, and
       Metalink. aria2 can download a file from multiple sources/protocols and tries  to  utilize  your  maximum
       download  bandwidth.  It  supports  downloading  a file from HTTP(S)/FTP /SFTP and BitTorrent at the same
       time, while the data downloaded from HTTP(S)/FTP/SFTP is uploaded to the BitTorrent swarm. Using Metalink
       chunk checksums, aria2 automatically validates chunks of data while downloading a file.

OPTIONS

       NOTE:
          Most  FTP related options are applicable to SFTP as well.  Some options are not effective against SFTP
          (e.g., --ftp-pasv)

   Basic Options
       -d, --dir=<DIR>
              The directory to store the downloaded file.

       -i, --input-file=<FILE>
              Downloads the URIs listed in FILE. You can specify multiple sources for a single entity by putting
              multiple  URIs  on  a  single  line  separated by the TAB character.  Additionally, options can be
              specified after each URI line. Option lines must start with one or  more  white  space  characters
              (SPACE  or  TAB) and must only contain one option per line.  Input files can use gzip compression.
              When FILE is specified as -, aria2 will read the input from stdin.  See the Input File  subsection
              for details.  See also the --deferred-input option.  See also the --save-session-file option.

       -l, --log=<LOG>
              The file name of the log file. If - is specified, log is written to stdout. If empty string("") is
              specified, or this option is omitted, no log is written to disk at all.

       -j, --max-concurrent-downloads=<N>
              Set the maximum number of parallel downloads for every queue item.  See also the  --split  option.
              Default: 5

       -V, --check-integrity[=true|false]
              Check  file integrity by validating piece hashes or a hash of entire file.  This option has effect
              only in BitTorrent, Metalink downloads with checksums or  HTTP(S)/FTP  downloads  with  --checksum
              option.   If  piece  hashes  are  provided,  this option can detect damaged portions of a file and
              re-download them.  If a hash of entire file is provided, hash check is only  done  when  file  has
              been  already  download.  This  is  determined  by  file  length.  If  hash  check  fails, file is
              re-downloaded from scratch.  If both piece hashes and a hash of entire  file  are  provided,  only
              piece hashes are used. Default: false

       -c, --continue[=true|false]
              Continue downloading a partially downloaded file.  Use this option to resume a download started by
              a web browser or another program which downloads files sequentially from the beginning.  Currently
              this option is only applicable to HTTP(S)/FTP downloads.

       -h, --help[=<TAG>|<KEYWORD>]
              The help messages are classified with tags. A tag starts with #. For example, type --help=#http to
              get the usage for the options tagged with #http. If non-tag word is given, print the usage for the
              options  whose name includes that word.  Available Values: #basic, #advanced, #http, #https, #ftp,
              #metalink, #bittorrent, #cookie, #hook, #file, #rpc, #checksum, #experimental, #deprecated, #help,
              #all Default: #basic

   HTTP/FTP/SFTP Options
       --all-proxy=<PROXY>
              Use  a  proxy server for all protocols.  To override a previously defined proxy, use "".  You also
              can override this setting and specify a proxy server for a particular protocol using --http-proxy,
              --https-proxy  and  --ftp-proxy  options.   This  affects  all  downloads.  The format of PROXY is
              [http://][USER:PASSWORD@]HOST[:PORT].  See also ENVIRONMENT section.

              NOTE:
                 If  user  and  password  are  embedded  in  proxy  URI  and  they   are   also   specified   by
                 --{http,https,ftp,all}-proxy-{user,passwd}   options,  those  specified  later  override  prior
                 options. For example, if  you  specified  http-proxy-user=myname,  http-proxy-passwd=mypass  in
                 aria2.conf  and  you  specified --http-proxy="http://proxy" on the command-line, then you'd get
                 HTTP proxy http://proxy with user myname and password mypass.

                 Another example: if you specified  on  the  command-line  --http-proxy="http://user:pass@proxy"
                 --http-proxy-user="myname" --http-proxy-passwd="mypass", then you'd get HTTP proxy http://proxy
                 with user myname and password mypass.

                 One   more   example:   if   you   specified   in    command-line    --http-proxy-user="myname"
                 --http-proxy-passwd="mypass"  --http-proxy="http://user:pass@proxy",  then you'd get HTTP proxy
                 http://proxy with user user and password pass.

       --all-proxy-passwd=<PASSWD>
              Set password for --all-proxy option.

       --all-proxy-user=<USER>
              Set user for --all-proxy option.

       --checksum=<TYPE>=<DIGEST>
              Set checksum. TYPE is hash type. The supported hash type is listed in Hash  Algorithms  in  aria2c
              -v.   DIGEST   is   hex   digest.    For   example,   setting   sha-1   digest  looks  like  this:
              sha-1=0192ba11326fe2298c8cb4de616f4d4140213838 This option applies only to HTTP(S)/FTP downloads.

       --connect-timeout=<SEC>
              Set the connect timeout in seconds to establish connection to  HTTP/FTP/proxy  server.  After  the
              connection  is  established,  this  option  makes  no effect and --timeout option is used instead.
              Default: 60

       --dry-run[=true|false]
              If true is given, aria2 just checks whether the remote file  is  available  and  doesn't  download
              data.  This  option has effect on HTTP/FTP download.  BitTorrent downloads are canceled if true is
              specified.  Default: false

       --lowest-speed-limit=<SPEED>
              Close connection if download speed is lower than or equal to this value(bytes per sec).   0  means
              aria2  does  not  have a lowest speed limit.  You can append K or M (1K = 1024, 1M = 1024K).  This
              option does not affect BitTorrent downloads.  Default: 0

       -x, --max-connection-per-server=<NUM>
              The maximum number of connections to one server for each download.  Default: 1

       --max-file-not-found=<NUM>
              If aria2 receives "file not found" status from the  remote  HTTP/FTP  servers  NUM  times  without
              getting  a  single  byte,  then force the download to fail. Specify 0 to disable this option. This
              options is effective only when using HTTP/FTP servers.  Default: 0

       -m, --max-tries=<N>
              Set number of tries. 0 means unlimited.  See also --retry-wait.  Default: 5

       -k, --min-split-size=<SIZE>
              aria2 does not split less than 2*SIZE byte range.  For example, let's consider  downloading  20MiB
              file.  If  SIZE is 10M, aria2 can split file into 2 range [0-10MiB) and [10MiB-20MiB) and download
              it using 2 sources(if --split >= 2, of course).  If SIZE is 15M, since 2*15M > 20MiB,  aria2  does
              not  split  file  and  download it using 1 source.  You can append K or M (1K = 1024, 1M = 1024K).
              Possible Values: 1M -1024M Default: 20M

       --netrc-path=<FILE>
              Specify the path to the netrc file.  Default: $(HOME)/.netrc

              NOTE:
                 Permission of the .netrc file must be 600.  Otherwise, the file will be ignored.

       -n, --no-netrc[=true|false]
              Disables netrc support. netrc support is enabled by default.

              NOTE:
                 netrc file is only read at the startup if --no-netrc is false.  So if --no-netrc is true at the
                 startup,  no  netrc  is available throughout the session.  You cannot get netrc enabled even if
                 you send --no-netrc=false using aria2.changeGlobalOption().

       --no-proxy=<DOMAINS>
              Specify a comma separated list of host names, domains and network  addresses  with  or  without  a
              subnet mask where no proxy should be used.

              NOTE:
                 For  network  addresses  with  a  subnet  mask, both IPv4 and IPv6 addresses work.  The current
                 implementation does not resolve the host name in an URI to compare network addresses  specified
                 in --no-proxy. So it is only effective if URI has numeric IP addresses.

       -o, --out=<FILE>
              The  file  name of the downloaded file. When the --force-sequential option is used, this option is
              ignored.

              NOTE:
                 You cannot specify a file name for Metalink or BitTorrent downloads.  The file  name  specified
                 here  is  only  used when the URIs fed to aria2 are given on the command line directly, but not
                 when using --input-file, --force-sequential option.

                 Example:

                     $ aria2c -o myfile.zip "http://mirror1/file.zip" "http://mirror2/file.zip"

       --proxy-method=<METHOD>
              Set the method to use in proxy request.  METHOD is either get or tunnel.  HTTPS  downloads  always
              use tunnel regardless of this option.  Default: get

       -R, --remote-time[=true|false]
              Retrieve  timestamp  of  the  remote  file from the remote HTTP/FTP server and if it is available,
              apply it to the local file.  Default: false

       --reuse-uri[=true|false]
              Reuse already used URIs if no unused URIs are left.  Default: true

       --retry-wait=<SEC>
              Set the seconds to wait between retries. When SEC > 0, aria2 will retry downloads  when  the  HTTP
              server returns a 503 response. Default: 0

       --server-stat-of=<FILE>
              Specify  the  file  name  to which performance profile of the servers is saved. You can load saved
              data using --server-stat-if option. See Server  Performance  Profile  subsection  below  for  file
              format.

       --server-stat-if=<FILE>
              Specify  the file name to load performance profile of the servers. The loaded data will be used in
              some URI selector such as feedback.   See  also  --uri-selector  option.  See  Server  Performance
              Profile subsection below for file format.

       --server-stat-timeout=<SEC>
              Specifies  timeout  in  seconds  to  invalidate  performance profile of the servers since the last
              contact to them.  Default: 86400 (24hours)

       -s, --split=<N>
              Download a file using N connections.  If more than N URIs are given, first N  URIs  are  used  and
              remaining  URIs are used for backup.  If less than N URIs are given, those URIs are used more than
              once so that N connections total are made simultaneously.  The number of connections to  the  same
              host  is  restricted  by  the  --max-connection-per-server  option.  See also the --min-split-size
              option.  Default: 5

              NOTE:
                 Some Metalinks regulate the number of servers to connect.  aria2 strictly respects them.   This
                 means  that  if Metalink defines the maxconnections attribute lower than N, then aria2 uses the
                 value of this lower value instead of N.

       --stream-piece-selector=<SELECTOR>
              Specify piece selection algorithm used in HTTP/FTP download.  Piece  means  fixed  length  segment
              which is downloaded in parallel in segmented download. If default is given, aria2 selects piece so
              that it reduces the number of establishing connection. This is reasonable default behavior because
              establishing connection is an expensive operation.  If inorder is given, aria2 selects piece which
              has minimum index. Index=0 means first of the file. This  will  be  useful  to  view  movie  while
              downloading  it.   --enable-http-pipelining option may be useful to reduce re-connection overhead.
              Please note that aria2 honors --min-split-size option, so  it  will  be  necessary  to  specify  a
              reasonable  value  to  --min-split-size  option.  If geom is given, at the beginning aria2 selects
              piece which has minimum index like inorder, but it exponentially  increasingly  keeps  space  from
              previously  selected piece. This will reduce the number of establishing connection and at the same
              time it will download the beginning part of the file first. This will  be  useful  to  view  movie
              while downloading it.  Default: default

       -t, --timeout=<SEC>
              Set timeout in seconds.  Default: 60

       --uri-selector=<SELECTOR>
              Specify  URI  selection  algorithm.  The  possible  values are inorder, feedback and adaptive.  If
              inorder is given, URI is tried in the order appeared in the URI list.  If feedback is given, aria2
              uses  download speed observed in the previous downloads and choose fastest server in the URI list.
              This also effectively skips dead mirrors. The observed download speed is  a  part  of  performance
              profile  of  servers  mentioned  in --server-stat-of and --server-stat-if options.  If adaptive is
              given, selects one of the best mirrors for the first and reserved connections.  For  supplementary
              ones,  it  returns  mirrors  which  has  not been tested yet, and if each of them has already been
              tested, returns mirrors which has to  be  tested  again.  Otherwise,  it  doesn't  select  anymore
              mirrors. Like feedback, it uses a performance profile of servers.  Default: feedback

   HTTP Specific Options
       --ca-certificate=<FILE>
              Use  the certificate authorities in FILE to verify the peers.  The certificate file must be in PEM
              format and can contain  multiple  CA  certificates.   Use  --check-certificate  option  to  enable
              verification.

              NOTE:
                 If    you    build    with    OpenSSL   or   the   recent   version   of   GnuTLS   which   has
                 gnutls_certificate_set_x509_system_trust() function and the library is properly  configured  to
                 locate  the system-wide CA certificates store, aria2 will automatically load those certificates
                 at the startup.

              NOTE:
                 WinTLS and AppleTLS do not support this option. Instead you will have to import the certificate
                 into the OS trust store.

       --certificate=<FILE>
              Use  the  client  certificate in FILE. The certificate must be either in PKCS12 (.p12, .pfx) or in
              PEM format.

              PKCS12  files  must  contain  the  certificate,  a  key  and  optionally  a  chain  of  additional
              certificates. Only PKCS12 files with a blank import password can be opened!

              When using PEM, you have to specify the private key via --private-key as well.

              NOTE:
                 WinTLS does not support PEM files at the moment. Users have to use PKCS12 files.

              NOTE:
                 AppleTLS  users should use the KeyChain Access utility to import the client certificate and get
                 the SHA-1 fingerprint from the Information dialog corresponding to that certificate.  To  start
                 aria2c  use  --certificate=<SHA-1>.   Alternatively PKCS12 files are also supported. PEM files,
                 however, are not supported.

       --check-certificate[=true|false]
              Verify the peer using certificates specified in --ca-certificate option.  Default: true

       --http-accept-gzip[=true|false]
              Send Accept: deflate, gzip request header and inflate response  if  remote  server  responds  with
              Content-Encoding: gzip or Content-Encoding: deflate.  Default: false

              NOTE:
                 Some  server responds with Content-Encoding: gzip for files which itself is gzipped file. aria2
                 inflates them anyway because of the response header.

       --http-auth-challenge[=true|false]
              Send HTTP authorization header only when it is requested by the server.  If  false  is  set,  then
              authorization  header  is  always  sent  to  the  server.  There is an exception: if user name and
              password are embedded in URI, authorization header is always sent to the server regardless of this
              option.  Default: false

       --http-no-cache[=true|false]
              Send  Cache-Control:  no-cache  and  Pragma: no-cache header to avoid cached content.  If false is
              given, these headers are not sent and you can add Cache-Control header with a directive  you  like
              using --header option. Default: false

       --http-user=<USER>
              Set HTTP user. This affects all URIs.

       --http-passwd=<PASSWD>
              Set HTTP password. This affects all URIs.

       --http-proxy=<PROXY>
              Use  a  proxy  server  for  HTTP.   To  override a previously defined proxy, use "".  See also the
              --all-proxy  option.    This   affects   all   http   downloads.    The   format   of   PROXY   is
              [http://][USER:PASSWORD@]HOST[:PORT]

       --http-proxy-passwd=<PASSWD>
              Set password for --http-proxy.

       --http-proxy-user=<USER>
              Set user for --http-proxy.

       --https-proxy=<PROXY>
              Use  a  proxy  server  for  HTTPS.  To  override a previously defined proxy, use "".  See also the
              --all-proxy  option.    This   affects   all   https   download.    The   format   of   PROXY   is
              [http://][USER:PASSWORD@]HOST[:PORT]

       --https-proxy-passwd=<PASSWD>
              Set password for --https-proxy.

       --https-proxy-user=<USER>
              Set user for --https-proxy.

       --private-key=<FILE>
              Use  the  private key in FILE.  The private key must be decrypted and in PEM format.  The behavior
              when encrypted one is given is undefined.  See also --certificate option.

       --referer=<REFERER>
              Set an http referrer (Referer). This affects  all  http/https  downloads.   If  *  is  given,  the
              download  URI  is  also  used  as  the  referrer.   This may be useful when used together with the
              --parameterized-uri option.

       --enable-http-keep-alive[=true|false]
              Enable HTTP/1.1 persistent connection.  Default: true

       --enable-http-pipelining[=true|false]
              Enable HTTP/1.1 pipelining.  Default: false

              NOTE:
                 In performance perspective, there is usually no advantage to enable this option.

       --header=<HEADER>
              Append HEADER to HTTP request header.  You can use this option repeatedly to specify more than one
              header:

                 $ aria2c --header="X-A: b78" --header="X-B: 9J1" "http://host/file"

       --load-cookies=<FILE>
              Load  Cookies  from FILE using the Firefox3 format (SQLite3), Chromium/Google Chrome (SQLite3) and
              the Mozilla/Firefox(1.x/2.x)/Netscape format.

              NOTE:
                 If aria2 is built without libsqlite3, then it  doesn't  support  Firefox3  and  Chromium/Google
                 Chrome cookie format.

       --save-cookies=<FILE>
              Save  Cookies  to FILE in Mozilla/Firefox(1.x/2.x)/ Netscape format. If FILE already exists, it is
              overwritten. Session Cookies are also saved and their expiry values are treated  as  0.   Possible
              Values: /path/to/file

       --use-head[=true|false]
              Use HEAD method for the first request to the HTTP server.  Default: false

       -U, --user-agent=<USER_AGENT>
              Set  user  agent  for HTTP(S) downloads.  Default: aria2/$VERSION, $VERSION is replaced by package
              version.

   FTP/SFTP Specific Options
       --ftp-user=<USER>
              Set FTP user. This affects all URIs.  Default: anonymous

       --ftp-passwd=<PASSWD>
              Set FTP password. This affects all URIs.  If user name is embedded but password is missing in URI,
              aria2  tries  to  resolve  password  using  .netrc. If password is found in .netrc, then use it as
              password. If not, use the password specified in this option.  Default: ARIA2USER@

       -p, --ftp-pasv[=true|false]
              Use the passive mode in FTP.  If false is given, the active mode will be used.  Default: true

              NOTE:
                 This option is ignored for SFTP transfer.

       --ftp-proxy=<PROXY>
              Use a proxy server for FTP.  To override a  previously  defined  proxy,  use  "".   See  also  the
              --all-proxy   option.    This   affects   all   ftp   downloads.    The   format   of   PROXY   is
              [http://][USER:PASSWORD@]HOST[:PORT]

       --ftp-proxy-passwd=<PASSWD>
              Set password for --ftp-proxy option.

       --ftp-proxy-user=<USER>
              Set user for --ftp-proxy option.

       --ftp-type=<TYPE>
              Set FTP transfer type. TYPE is either binary or ascii.  Default: binary

              NOTE:
                 This option is ignored for SFTP transfer.

       --ftp-reuse-connection[=true|false]
              Reuse connection in FTP.  Default: true

       --ssh-host-key-md=<TYPE>=<DIGEST>
              Set checksum for SSH host public key. TYPE is hash type. The supported hash type is sha-1 or  md5.
              DIGEST  is  hex  digest. For example: sha-1=b030503d4de4539dc7885e6f0f5e256704edf4c3.  This option
              can be used to validate server's public key when SFTP is used. If this option is not set, which is
              default, no validation takes place.

   BitTorrent/Metalink Options
       --select-file=<INDEX>...
              Set  file to download by specifying its index.  You can find the file index using the --show-files
              option.  Multiple indexes can be specified by using ,, for example: 3,6.  You can also  use  -  to
              specify a range: 1-5.  , and - can be used together: 1-5,8,9.  When used with the -M option, index
              may vary depending on the query (see --metalink-* options).

              NOTE:
                 In multi file torrent, the adjacent files specified by this option may also be downloaded. This
                 is  by design, not a bug.  A single piece may include several files or part of files, and aria2
                 writes the piece to the appropriate files.

       -S, --show-files[=true|false]
              Print file listing of ".torrent", ".meta4" and ".metalink" file and exit.  In case  of  ".torrent"
              file, additional information (infohash, piece length, etc) is also printed.

   BitTorrent Specific Options
       --bt-detach-seed-only[=true|false]
              Exclude seed only downloads when counting concurrent active downloads (See -j option).  This means
              that if -j3 is given and this option is turned on and 3 downloads are  active  and  one  of  those
              enters seed mode, then it is excluded from active download count (thus it becomes 2), and the next
              download waiting in queue gets started. But be aware that seeding  item  is  still  recognized  as
              active download in RPC method.  Default: false

       --bt-enable-lpd[=true|false]
              Enable  Local  Peer  Discovery.   If  a  private  flag is set in a torrent, aria2 doesn't use this
              feature for that download even if true is given.  Default: false

       --bt-exclude-tracker=<URI>[,...]
              Comma separated list of BitTorrent tracker's announce URI to remove. You can use special  value  *
              which  matches  all URIs, thus removes all announce URIs. When specifying * in shell command-line,
              don't forget to escape or quote it.  See also --bt-tracker option.

       --bt-external-ip=<IPADDRESS>
              Specify the external IP address to report to a BitTorrent tracker. Although this function is named
              external, it can accept any kind of IP addresses. IPADDRESS must be a numeric IP address.

       --bt-force-encryption[=true|false]
              Requires   BitTorrent   message   payload   encryption   with   arc4.   This  is  a  shorthand  of
              --bt-require-crypto --bt-min-crypto-level=arc4.  This option does not change the option  value  of
              those  options.   If  true  is  given,  deny  legacy BitTorrent handshake and only use Obfuscation
              handshake and always encrypt message payload.  Default: false

       --bt-hash-check-seed[=true|false]
              If true is given, after hash check using --check-integrity option and file is  complete,  continue
              to seed file. If you want to check file and download it only when it is damaged or incomplete, set
              this option to false.  This option has effect only on BitTorrent download.  Default: true

       --bt-lpd-interface=<INTERFACE>
              Use given interface for Local Peer Discovery.  If  this  option  is  not  specified,  the  default
              interface  is  chosen. You can specify interface name and IP address.  Possible Values: interface,
              IP address

       --bt-max-open-files=<NUM>
              Specify maximum number of files to  open  in  multi-file  BitTorrent/Metalink  download  globally.
              Default: 100

       --bt-max-peers=<NUM>
              Specify   the   maximum   number   of   peers   per   torrent.    0  means  unlimited.   See  also
              --bt-request-peer-speed-limit option.  Default: 55

       --bt-metadata-only[=true|false]
              Download meta data only. The file(s) described in meta data will not be  downloaded.  This  option
              has  effect only when BitTorrent Magnet URI is used. See also --bt-save-metadata option.  Default:
              false

       --bt-min-crypto-level=plain|arc4
              Set minimum level of encryption method.  If several encryption methods are  provided  by  a  peer,
              aria2 chooses the lowest one which satisfies the given level.  Default: plain

       --bt-prioritize-piece=head[=<SIZE>],tail[=<SIZE>]
              Try to download first and last pieces of each file first. This is useful for previewing files. The
              argument can contain 2 keywords: head and tail. To include both keywords, they must  be  separated
              by  comma.  These keywords can take one parameter, SIZE. For example, if head=<SIZE> is specified,
              pieces in the range of first SIZE bytes of each file get higher priority.  tail=<SIZE>  means  the
              range of last SIZE bytes of each file. SIZE can include K or M (1K = 1024, 1M = 1024K). If SIZE is
              omitted, SIZE=1M is used.

       --bt-remove-unselected-file[=true|false]
              Removes the unselected files when download is  completed  in  BitTorrent.  To  select  files,  use
              --select-file  option.  If  it  is not used, all files are assumed to be selected. Please use this
              option with care because it will actually remove files from your disk.  Default: false

       --bt-require-crypto[=true|false]
              If  true  is  given,  aria2  doesn't  accept  and  establish  connection  with  legacy  BitTorrent
              handshake(\19BitTorrent protocol).  Thus aria2 always uses Obfuscation handshake.  Default: false

       --bt-request-peer-speed-limit=<SPEED>
              If  the whole download speed of every torrent is lower than SPEED, aria2 temporarily increases the
              number of peers to try for more download  speed.  Configuring  this  option  with  your  preferred
              download  speed can increase your download speed in some cases.  You can append K or M (1K = 1024,
              1M = 1024K).  Default: 50K

       --bt-save-metadata[=true|false]
              Save meta data as ".torrent" file. This option has effect only when BitTorrent Magnet URI is used.
              The  file  name  is hex encoded info hash with suffix ".torrent". The directory to be saved is the
              same directory where download file is saved. If the same file already exists,  meta  data  is  not
              saved. See also --bt-metadata-only option. Default: false

       --bt-seed-unverified[=true|false]
              Seed previously downloaded files without verifying piece hashes.  Default: false

       --bt-stop-timeout=<SEC>
              Stop  BitTorrent  download  if download speed is 0 in consecutive SEC seconds. If 0 is given, this
              feature is disabled.  Default: 0

       --bt-tracker=<URI>[,...]
              Comma separated list of additional BitTorrent tracker's announce URI. These URIs are not  affected
              by  --bt-exclude-tracker  option  because they are added after URIs in --bt-exclude-tracker option
              are removed.

       --bt-tracker-connect-timeout=<SEC>
              Set the connect timeout in seconds to establish connection to tracker.  After  the  connection  is
              established,  this  option  makes  no  effect  and  --bt-tracker-timeout  option  is used instead.
              Default: 60

       --bt-tracker-interval=<SEC>
              Set the interval in seconds between tracker requests. This completely overrides interval value and
              aria2  just  uses  this  value  and ignores the min interval and interval value in the response of
              tracker. If 0 is set, aria2 determines interval based on the response of tracker and the  download
              progress.  Default: 0

       --bt-tracker-timeout=<SEC>
              Set timeout in seconds. Default: 60

       --dht-entry-point=<HOST>:<PORT>
              Set host and port as an entry point to IPv4 DHT network.

       --dht-entry-point6=<HOST>:<PORT>
              Set host and port as an entry point to IPv6 DHT network.

       --dht-file-path=<PATH>
              Change the IPv4 DHT routing table file to PATH.  Default: $HOME/.aria2/dht.dat

       --dht-file-path6=<PATH>
              Change the IPv6 DHT routing table file to PATH.  Default: $HOME/.aria2/dht6.dat

       --dht-listen-addr6=<ADDR>
              Specify  address  to  bind socket for IPv6 DHT.  It should be a global unicast IPv6 address of the
              host.

       --dht-listen-port=<PORT>...
              Set UDP listening port used by DHT(IPv4, IPv6) and UDP tracker.  Multiple ports can  be  specified
              by using ,, for example: 6881,6885.  You can also use - to specify a range: 6881-6999. , and - can
              be used together.  Default: 6881-6999

              NOTE:
                 Make sure that the specified ports are open for incoming UDP traffic.

       --dht-message-timeout=<SEC>
              Set timeout in seconds. Default: 10

       --enable-dht[=true|false]
              Enable IPv4 DHT functionality. It also enables UDP tracker support. If a private flag is set in  a
              torrent, aria2 doesn't use DHT for that download even if true is given.  Default: true

       --enable-dht6[=true|false]
              Enable  IPv6  DHT  functionality. If a private flag is set in a torrent, aria2 doesn't use DHT for
              that download even if true is given. Use --dht-listen-port option to specify port number to listen
              on. See also --dht-listen-addr6 option.

       --enable-peer-exchange[=true|false]
              Enable  Peer  Exchange  extension. If a private flag is set in a torrent, this feature is disabled
              for that download even if true is given.  Default: true

       --follow-torrent=true|false|mem
              If true or  mem  is  specified,  when  a  file  whose  suffix  is  .torrent  or  content  type  is
              application/x-bittorrent  is  downloaded,  aria2  parses  it as a torrent file and downloads files
              mentioned in it.  If mem is specified, a torrent file is not written to the disk, but is just kept
              in  memory.  If false is specified, the .torrent file is downloaded to the disk, but is not parsed
              as a torrent and its contents are not downloaded.  Default: true

       -O, --index-out=<INDEX>=<PATH>
              Set file path for file with index=INDEX. You can  find  the  file  index  using  the  --show-files
              option.   PATH  is  a relative path to the path specified in --dir option. You can use this option
              multiple times. Using this option, you can specify the output file names of BitTorrent downloads.

       --listen-port=<PORT>...
              Set TCP port number for BitTorrent downloads.  Multiple ports can be specified by  using  ,,   for
              example:  6881,6885.   You  can  also  use  -  to specify a range: 6881-6999.  , and - can be used
              together: 6881-6889,6999.  Default: 6881-6999

              NOTE:
                 Make sure that the specified ports are open for incoming TCP traffic.

       --max-overall-upload-limit=<SPEED>
              Set max overall upload speed in bytes/sec.  0 means unrestricted.  You can append K  or  M  (1K  =
              1024,  1M  =  1024K).   To  limit  the  upload  speed  per torrent, use --max-upload-limit option.
              Default: 0

       -u, --max-upload-limit=<SPEED>
              Set max upload speed per each torrent in bytes/sec.  0 means unrestricted.  You can append K or  M
              (1K  =  1024,  1M  =  1024K).   To  limit the overall upload speed, use --max-overall-upload-limit
              option.  Default: 0

       --peer-id-prefix=<PEER_ID_PREFIX>
              Specify the prefix of peer ID. The peer ID in BitTorrent is 20 byte length. If more than 20  bytes
              are specified, only first 20 bytes are used. If less than 20 bytes are specified, random byte data
              are added to make its length 20 bytes.

              Default: A2-$MAJOR-$MINOR-$PATCH-, $MAJOR, $MINOR and $PATCH are  replaced  by  major,  minor  and
              patch version number respectively.  For instance, aria2 version 1.18.8 has prefix ID A2-1-18-8-.

       --seed-ratio=<RATIO>
              Specify  share  ratio.  Seed completed torrents until share ratio reaches RATIO.  You are strongly
              encouraged to specify equals or more than 1.0 here.  Specify 0.0  if  you  intend  to  do  seeding
              regardless  of  share  ratio.   If --seed-time option is specified along with this option, seeding
              ends when at least one of the conditions is satisfied.  Default: 1.0

       --seed-time=<MINUTES>
              Specify seeding time in minutes. Also see the --seed-ratio option.

              NOTE:
                 Specifying --seed-time=0 disables seeding after download completed.

       -T, --torrent-file=<TORRENT_FILE>
              The path to the ".torrent" file.  You are not required to use this option because you can  specify
              ".torrent" files without --torrent-file.

   Metalink Specific Options
       --follow-metalink=true|false|mem
              If  true  or  mem is specified, when a file whose suffix is .meta4 or .metalink or content type of
              application/metalink4+xml or application/metalink+xml is downloaded, aria2 parses it as a metalink
              file  and downloads files mentioned in it.  If mem is specified, a metalink file is not written to
              the disk, but is just kept in memory.  If false is specified, the .metalink file is downloaded  to
              the disk, but is not parsed as a metalink file and its contents are not downloaded.  Default: true

       --metalink-base-uri=<URI>
              Specify  base  URI  to  resolve  relative  URI  in  metalink:url and metalink:metaurl element in a
              metalink file stored in local disk. If URI points to a directory, URI must end with /.

       -M, --metalink-file=<METALINK_FILE>
              The file path to ".meta4" and ".metalink" file. Reads input from stdin when - is  specified.   You
              are  not  required  to  use  this  option  because  you  can  specify  ".metalink"  files  without
              --metalink-file.

       --metalink-language=<LANGUAGE>
              The language of the file to download.

       --metalink-location=<LOCATION>[,...]
              The location of the preferred server.  A comma-delimited list  of  locations  is  acceptable,  for
              example, jp,us.

       --metalink-os=<OS>
              The operating system of the file to download.

       --metalink-version=<VERSION>
              The version of the file to download.

       --metalink-preferred-protocol=<PROTO>
              Specify  preferred  protocol.  The possible values are http, https, ftp and none.  Specify none to
              disable this feature.  Default: none

       --metalink-enable-unique-protocol[=true|false]
              If true is given and several protocols are available for a mirror in a metalink file,  aria2  uses
              one  of  them.   Use  --metalink-preferred-protocol  option to specify the preference of protocol.
              Default: true

   RPC Options
       --enable-rpc[=true|false]
              Enable JSON-RPC/XML-RPC server.  It is strongly recommended  to  set  secret  authorization  token
              using --rpc-secret option.  See also --rpc-listen-port option.  Default: false

       --pause[=true|false]
              Pause  download  after  added.  This  option  is  effective  only when --enable-rpc=true is given.
              Default: false

       --pause-metadata[=true|false]
              Pause downloads created as a result of metadata download. There are 3 types of metadata  downloads
              in  aria2:  (1) downloading .torrent file. (2) downloading torrent metadata using magnet link. (3)
              downloading metalink file.  These metadata downloads will generate downloads using their metadata.
              This   option   pauses   these   subsequent   downloads.   This  option  is  effective  only  when
              --enable-rpc=true is given.  Default: false

       --rpc-allow-origin-all[=true|false]
              Add Access-Control-Allow-Origin header field with value * to the RPC response.  Default: false

       --rpc-certificate=<FILE>
              Use the certificate in FILE for RPC server. The certificate must be either in PKCS12 (.p12,  .pfx)
              or in PEM format.

              PKCS12  files  must  contain  the  certificate,  a  key  and  optionally  a  chain  of  additional
              certificates. Only PKCS12 files with a blank import password can be opened!

              When using PEM,  you  have  to  specify  the  private  key  via  --rpc-private-key  as  well.  Use
              --rpc-secure option to enable encryption.

              NOTE:
                 WinTLS does not support PEM files at the moment. Users have to use PKCS12 files.

              NOTE:
                 AppleTLS  users  should  use  the  KeyChain  Access  utility  to  first  generate a self-signed
                 SSL-Server certificate, e.g.  using  the  wizard,  and  get  the  SHA-1  fingerprint  from  the
                 Information  dialog  corresponding  to that new certificate.  To start aria2c with --rpc-secure
                 use --rpc-certificate=<SHA-1>.  Alternatively PKCS12  files  are  also  supported.  PEM  files,
                 however, are not supported.

       --rpc-listen-all[=true|false]
              Listen  incoming  JSON-RPC/XML-RPC  requests  on all network interfaces. If false is given, listen
              only on local loopback interface.  Default: false

       --rpc-listen-port=<PORT>
              Specify a port number for JSON-RPC/XML-RPC server to listen  to.   Possible  Values:  1024  -65535
              Default: 6800

       --rpc-max-request-size=<SIZE>
              Set max size of JSON-RPC/XML-RPC request. If aria2 detects the request is more than SIZE bytes, it
              drops connection. Default: 2M

       --rpc-passwd=<PASSWD>
              Set JSON-RPC/XML-RPC password.

              WARNING:
                 --rpc-passwd option will be deprecated in the future release. Migrate to --rpc-secret option as
                 soon as possible.

       --rpc-private-key=<FILE>
              Use  the private key in FILE for RPC server.  The private key must be decrypted and in PEM format.
              Use --rpc-secure option to enable encryption. See also --rpc-certificate option.

       --rpc-save-upload-metadata[=true|false]
              Save the uploaded torrent or metalink meta data in the directory specified by  --dir  option.  The
              file  name  consists  of  SHA-1  hash  hex  string  of  meta data plus extension. For torrent, the
              extension is '.torrent'. For metalink, it is '.meta4'.  If false is  given  to  this  option,  the
              downloads  added  by aria2.addTorrent() or aria2.addMetalink() will not be saved by --save-session
              option. Default: false

       --rpc-secret=<TOKEN>
              Set RPC secret authorization token. Read RPC authorization secret token to know  how  this  option
              value is used.

       --rpc-secure[=true|false]
              RPC  transport  will be encrypted by SSL/TLS.  The RPC clients must use https scheme to access the
              server. For WebSocket client, use wss scheme. Use --rpc-certificate and --rpc-private-key  options
              to specify the server certificate and private key.

       --rpc-user=<USER>
              Set JSON-RPC/XML-RPC user.

              WARNING:
                 --rpc-user  option  will be deprecated in the future release. Migrate to --rpc-secret option as
                 soon as possible.

   Advanced Options
       --allow-overwrite[=true|false]
              Restart download from  scratch  if  the  corresponding  control  file  doesn't  exist.   See  also
              --auto-file-renaming option.  Default: false

       --allow-piece-length-change[=true|false]
              If  false  is  given, aria2 aborts download when a piece length is different from one in a control
              file.  If true is given, you can proceed but some download progress will be lost.  Default: false

       --always-resume[=true|false]
              Always resume download. If true is given, aria2 always tries to resume download and if  resume  is
              not  possible,  aborts  download.  If false is given, when all given URIs do not support resume or
              aria2 encounters  N  URIs  which  does  not  support  resume  (N  is  the  value  specified  using
              --max-resume-failure-tries     option),     aria2    downloads    file    from    scratch.     See
              --max-resume-failure-tries option. Default: true

       --async-dns[=true|false]
              Enable asynchronous DNS.  Default: true

       --async-dns-server=<IPADDRESS>[,...]
              Comma separated list of DNS server address used in asynchronous DNS resolver. Usually asynchronous
              DNS  resolver  reads DNS server addresses from /etc/resolv.conf. When this option is used, it uses
              DNS servers specified in this option instead of ones in /etc/resolv.conf.  You  can  specify  both
              IPv4  and  IPv6  address. This option is useful when the system does not have /etc/resolv.conf and
              user does not have the permission to create it.

       --auto-file-renaming[=true|false]
              Rename file name if the same file already exists.  This option works only in HTTP(S)/FTP download.
              The new file name has a dot and a number(1..9999) appended.  Default: true

       --auto-save-interval=<SEC>
              Save a control file(*.aria2) every SEC seconds.  If 0 is given, a control file is not saved during
              download. aria2 saves a control file when it stops regardless of the value.  The  possible  values
              are between 0 to 600.  Default: 60

       --conditional-get[=true|false]
              Download  file  only  when the local file is older than remote file. This function only works with
              HTTP(S) downloads only.  It does not work if file size is specified in Metalink. It  also  ignores
              Content-Disposition header.  If a control file exists, this option will be ignored.  This function
              uses If-Modified-Since header to get only newer file conditionally. When getting modification time
              of  local  file,  it  uses  user supplied file name (see --out option) or file name part in URI if
              --out is not specified.  To overwrite existing  file,  --allow-overwrite  is  required.   Default:
              false

       --conf-path=<PATH>
              Change the configuration file path to PATH.  Default: $HOME/.aria2/aria2.conf

       --console-log-level=<LEVEL>
              Set log level to output to console.  LEVEL is either debug, info, notice, warn or error.  Default:
              notice

       -D, --daemon[=true|false]
              Run as daemon. The current working directory will be changed to /  and  standard  input,  standard
              output and standard error will be redirected to /dev/null. Default: false

       --deferred-input[=true|false]
              If  true  is  given,  aria2 does not read all URIs and options from file specified by --input-file
              option at startup, but it reads one by one when it needs later. This may reduce  memory  usage  if
              input  file  contains  a  lot  of  URIs  to download.  If false is given, aria2 reads all URIs and
              options at startup.  Default: false

       --disable-ipv6[=true|false]
              Disable IPv6. This is useful if you have to use broken DNS and want to avoid  terribly  slow  AAAA
              record lookup. Default: false

       --disk-cache=<SIZE>
              Enable  disk  cache.  If SIZE is 0, the disk cache is disabled. This feature caches the downloaded
              data in memory, which grows to at most SIZE bytes. The cache storage is created for aria2 instance
              and  shared  by  all downloads. The one advantage of the disk cache is reduce the disk I/O because
              the data are written in larger unit and it is reordered by  the  offset  of  the  file.   If  hash
              checking  is involved and the data are cached in memory, we don't need to read them from the disk.
              SIZE can include K or M (1K = 1024, 1M = 1024K). Default: 16M

       --download-result=<OPT>
              This option changes the way Download Results is formatted. If OPT is default, print  GID,  status,
              average  download  speed and path/URI. If multiple files are involved, path/URI of first requested
              file is printed and remaining ones are omitted.  If  OPT  is  full,  print  GID,  status,  average
              download  speed,  percentage of progress and path/URI. The percentage of progress and path/URI are
              printed for each requested file in each row.  Default: default

       --dscp=<DSCP>
              Set DSCP value in outgoing IP packets of BitTorrent traffic for QoS. This parameter sets only DSCP
              bits   in   TOS   field   of   IP   packets,  not  the  whole  field.  If  you  take  values  from
              /usr/include/netinet/ip.h divide them by 4 (otherwise values would be  incorrect,  e.g.  your  CS1
              class  would  turn  into  CS4).  If  you  take  commonly  used  values  from RFC, network vendors'
              documentation, Wikipedia or any other source, use them as they are.

       --rlimit-nofile=<NUM>
              Set the soft limit of open file descriptors.  This open will only have effect when:

                 a. The system supports it (posix)

                 b. The limit does not exceed the hard limit.

                 c. The specified limit is larger than the current soft limit.

              This is equivalent to setting nofile via ulimit, except that it will never decrease the limit.

              This option is only available on systems supporting the rlimit API.

       --enable-color[=true|false]
              Enable color output for a terminal.  Default: true

       --enable-mmap[=true|false]
              Map files into memory. This option may not work if  the  file  space  is  not  pre-allocated.  See
              --file-allocation.

              Default: false

       --event-poll=<POLL>
              Specify  the  method  for  polling  events.  The possible values are epoll, kqueue, port, poll and
              select.  For each epoll, kqueue, port and poll, it is available if system supports it.   epoll  is
              available on recent Linux. kqueue is available on various *BSD systems including Mac OS X. port is
              available on Open Solaris. The default value may vary depending on the system you use.

       --file-allocation=<METHOD>
              Specify file allocation method.  none doesn't pre-allocate file space. prealloc pre-allocates file
              space  before  download begins. This may take some time depending on the size of the file.  If you
              are using newer file systems such as ext4 (with extents support), btrfs, xfs or  NTFS(MinGW  build
              only),  falloc  is your best choice. It allocates large(few GiB) files almost instantly. Don't use
              falloc with legacy file systems such as ext3 and FAT32  because  it  takes  almost  same  time  as
              prealloc  and  it  blocks aria2 entirely until allocation finishes. falloc may not be available if
              your system doesn't have posix_fallocate(3) function.  trunc  uses  ftruncate(2)  system  call  or
              platform-specific counterpart to truncate a file to a specified length.

              Possible Values: none, prealloc, trunc, falloc Default: prealloc

       --force-save[=true|false]
              Save download with --save-session option even if the download is completed or removed. This option
              also saves control file in that situations. This may be useful to save BitTorrent seeding which is
              recognized as completed state.  Default: false

       --gid=<GID>
              Set  GID manually. aria2 identifies each download by the ID called GID. The GID must be hex string
              of 16 characters, thus [0-9a-zA-Z] are allowed and leading zeros must not be stripped. The GID all
              0  is  reserved  and must not be used. The GID must be unique, otherwise error is reported and the
              download  is  not  added.   This  option  is  useful  when  restoring  the  sessions  saved  using
              --save-session option. If this option is not used, new GID is generated by aria2.

       --hash-check-only[=true|false]
              If  true  is given, after hash check using --check-integrity option, abort download whether or not
              download is complete.  Default: false

       --human-readable[=true|false]
              Print sizes and speed in human readable format  (e.g.,  1.2Ki,  3.4Mi)  in  the  console  readout.
              Default: true

       --interface=<INTERFACE>
              Bind  sockets  to  given  interface.  You  can  specify  interface name, IP address and host name.
              Possible Values: interface, IP address, host name

              NOTE:
                 If an interface has multiple  addresses,  it  is  highly  recommended  to  specify  IP  address
                 explicitly.  See  also  --disable-ipv6.  If your system doesn't have getifaddrs(3), this option
                 doesn't accept interface name.

       --max-download-result=<NUM>
              Set  maximum  number  of  download   result   kept   in   memory.   The   download   results   are
              completed/error/removed  downloads. The download results are stored in FIFO queue and it can store
              at most NUM download results. When queue is full  and  new  download  result  is  created,  oldest
              download  result is removed from the front of the queue and new one is pushed to the back. Setting
              big number in this option may  result  high  memory  consumption  after  thousands  of  downloads.
              Specifying 0 means no download result is kept. Default: 1000

       --max-resume-failure-tries=<N>
              When  used  with  --always-resume=false,  aria2  downloads  file from scratch when aria2 detects N
              number of URIs that does not support resume. If N is 0, aria2 downloads file from scratch when all
              given URIs do not support resume.  See --always-resume option.  Default: 0

       --min-tls-version=<VERSION>
              Specify  minimum  SSL/TLS  version  to  enable.   Possible  Values: SSLv3, TLSv1, TLSv1.1, TLSv1.2
              Default: TLSv1

       --multiple-interface=<INTERFACES>
              Comma separated list of interfaces to  bind  sockets  to.  Requests  will  be  splited  among  the
              interfaces  to  achieve link aggregation. You can specify interface name, IP address and hostname.
              If --interface is used, this option will be ignored.   Possible  Values:  interface,  IP  address,
              hostname

       --log-level=<LEVEL>
              Set log level to output.  LEVEL is either debug, info, notice, warn or error.  Default: debug

       --on-bt-download-complete=<COMMAND>
              For  BitTorrent,  a command specified in --on-download-complete is called after download completed
              and seeding is over. On the other hand, this option set the command to be executed after  download
              completed  but  before  seeding.  See Event Hook for more details about COMMAND.  Possible Values:
              /path/to/command

       --on-download-complete=<COMMAND>
              Set the command to be executed after download completed.  See See  Event  Hook  for  more  details
              about COMMAND.  See also --on-download-stop option.  Possible Values: /path/to/command

       --on-download-error=<COMMAND>
              Set  the  command  to  be  executed  after download aborted due to error.  See Event Hook for more
              details about COMMAND.  See also --on-download-stop option.  Possible Values: /path/to/command

       --on-download-pause=<COMMAND>
              Set the command to be executed after download was paused.  See Event Hook for more  details  about
              COMMAND.  Possible Values: /path/to/command

       --on-download-start=<COMMAND>
              Set  the command to be executed after download got started.  See Event Hook for more details about
              COMMAND.  Possible Values: /path/to/command

       --on-download-stop=<COMMAND>
              Set the command to be executed after download stopped. You can override the command to be executed
              for  particular  download result using --on-download-complete and --on-download-error. If they are
              specified, command specified in this option is not executed.  See  Event  Hook  for  more  details
              about COMMAND.  Possible Values: /path/to/command

       --piece-length=<LENGTH>
              Set  a  piece  length  for  HTTP/FTP downloads. This is the boundary when aria2 splits a file. All
              splits occur at multiple of this length. This option will be ignored in BitTorrent downloads.   It
              will be also ignored if Metalink file contains piece hashes.  Default: 1M

              NOTE:
                 The  possible  use  case  of  --piece-length  option  is  change  the request range in one HTTP
                 pipelined request.  To enable HTTP pipelining use --enable-http-pipelining.

       --show-console-readout[=true|false]
              Show console readout. Default: true

       --summary-interval=<SEC>
              Set interval in seconds to output download progress summary.  Setting  0  suppresses  the  output.
              Default: 60

              NOTE:
                 In  multi  file  torrent  downloads, the files adjacent forward to the specified files are also
                 allocated if they share the same piece.

       -Z, --force-sequential[=true|false]
              Fetch URIs in the command-line sequentially and download each URI in a separate session, like  the
              usual command-line download utilities.  Default: false

       --max-overall-download-limit=<SPEED>
              Set  max  overall download speed in bytes/sec.  0 means unrestricted.  You can append K or M (1K =
              1024, 1M = 1024K).  To limit the download speed per  download,  use  --max-download-limit  option.
              Default: 0

       --max-download-limit=<SPEED>
              Set  max download speed per each download in bytes/sec. 0 means unrestricted.  You can append K or
              M (1K = 1024, 1M = 1024K).  To limit the overall download speed, use  --max-overall-download-limit
              option.  Default: 0

       --no-conf[=true|false]
              Disable loading aria2.conf file.

       --no-file-allocation-limit=<SIZE>
              No file allocation is made for files whose size is smaller than SIZE.  You can append K or M (1K =
              1024, 1M = 1024K).  Default: 5M

       -P, --parameterized-uri[=true|false]
              Enable parameterized URI support.  You can specify  set  of  parts:  http://{sv1,sv2,sv3}/foo.iso.
              Also  you  can  specify  numeric sequences with step counter: http://host/image[000-100:2].img.  A
              step counter can be omitted.  If all URIs do not point to  the  same  file,  such  as  the  second
              example above, -Z option is required.  Default: false

       -q, --quiet[=true|false]
              Make aria2 quiet (no console output).  Default: false

       --realtime-chunk-checksum[=true|false]
              Validate  chunk  of  data  by calculating checksum while downloading a file if chunk checksums are
              provided.  Default: true

       --remove-control-file[=true|false]
              Remove control file before download. Using with  --allow-overwrite=true,  download  always  starts
              from scratch. This will be useful for users behind proxy server which disables resume.

       --save-session=<FILE>
              Save  error/unfinished  downloads  to  FILE on exit.  You can pass this output file to aria2c with
              --input-file option on restart. If you like the output to be gzipped append a .gz extension to the
              file  name.   Please  note  that downloads added by aria2.addTorrent() and aria2.addMetalink() RPC
              method and whose meta data could not be saved as a file are not saved.   Downloads  removed  using
              aria2.remove()  and  aria2.forceRemove()  will not be saved. GID is also saved with gid, but there
              are some restrictions, see below.

              NOTE:
                 Normally, GID of the download itself  is  saved.  But  some  downloads  use  meta  data  (e.g.,
                 BitTorrent and Metalink). In this case, there are some restrictions.

                 1.

                    magnet URI, and followed by torrent download
                           GID of BitTorrent meta data download is saved.

                 2.

                    URI to torrent file, and followed by torrent download
                           GID of torrent file download is saved.

                 3.

                    URI to metalink file, and followed by file downloads described in metalink file
                           GID of metalink file download is saved.

                 4.

                    local torrent file
                           GID of torrent download is saved.

                 5.

                    local metalink file
                           Any meaningful GID is not saved.

       --save-session-interval=<SEC>
              Save error/unfinished downloads to a file specified by --save-session option every SEC seconds. If
              0 is given, file will be saved only when aria2 exits. Default: 0

       --stop=<SEC>
              Stop application after SEC seconds has passed.  If 0 is given, this feature is disabled.  Default:
              0

       --stop-with-process=<PID>
              Stop  application when process PID is not running.  This is useful if aria2 process is forked from
              a parent process. The parent process can fork aria2 with its own pid and when parent process exits
              for some reason, aria2 can detect it and shutdown itself.

       --truncate-console-readout[=true|false]
              Truncate console readout to fit in a single line.  Default: true

       -v, --version
              Print the version number, copyright and the configuration information and exit.

   Notes for Options
   Optional arguments
       The  options  that have its argument surrounded by square brackets([]) take an optional argument. Usually
       omitting the argument is evaluated to true.  If you use short form of these options(such as -V) and  give
       an  argument,  then the option name and its argument should be concatenated(e.g.  -Vfalse). If any spaces
       are inserted between the option name and the argument, the argument will be treated as  URI  and  usually
       this is not what you expect.

   Units (K and M)
       Some  options takes K and M to conveniently represent 1024 and 1048576 respectively.  aria2 detects these
       characters in case-insensitive way. In other words, k and m can be used as well as K and M respectively.

   URI, MAGNET, TORRENT_FILE, METALINK_FILE
       You can specify multiple URIs in command-line.  Unless you specify --force-sequential  option,  all  URIs
       must point to the same file or downloading will fail.

       You  can specify arbitrary number of BitTorrent Magnet URI. Please note that they are always treated as a
       separate download.  Both hex encoded 40 characters Info Hash and Base32 encoded 32 characters  Info  Hash
       are  supported.  The  multiple  tr  parameters are supported.  Because BitTorrent Magnet URI is likely to
       contain & character, it is highly recommended to always quote URI with single(') or double(")  quotation.
       It   is   strongly   recommended   to   enable   DHT   especially  when  tr  parameter  is  missing.  See
       http://www.bittorrent.org/beps/bep_0009.html for more details about BitTorrent Magnet URI.

       You can also specify arbitrary number of torrent files and Metalink documents stored on  a  local  drive.
       Please  note that they are always treated as a separate download. Both Metalink4 and Metalink version 3.0
       are supported.

       You can specify both torrent file with -T option and URIs. By doing this, you can download  a  file  from
       both torrent swarm and HTTP(S)/FTP/SFTP server at the same time, while the data from HTTP(S)/FTP/SFTP are
       uploaded to the torrent swarm.  For single file torrents, URI can be  a  complete  URI  pointing  to  the
       resource  or  if URI ends with /, name in torrent file in torrent is added. For multi-file torrents, name
       and path are added to form a URI for each file.

       NOTE:
          Make sure that URI is quoted with single(') or double(") quotation if it contains & or any  characters
          that have special meaning in shell.

   Resuming Download
       Usually,  you  can  resume transfer by just issuing same command (aria2c URI) if the previous transfer is
       made by aria2.

       If the previous transfer is made by a  browser  or  wget  like  sequential  download  manager,  then  use
       --continue option to continue the transfer.

   Event Hook
       aria2  provides  options  to specify arbitrary command after specific event occurred. Currently following
       options   are   available:   --on-bt-download-complete,   --on-download-pause,    --on-download-complete.
       --on-download-start, --on-download-error, --on-download-stop.

       aria2  passes 3 arguments to specified command when it is executed.  These arguments are: GID, the number
       of files and file path.  For HTTP, FTP, and SFTP downloads, usually the number of files is 1.  BitTorrent
       download  can  contain  multiple files.  If number of files is more than one, file path is first one.  In
       other words, this is the value of path key of first struct whose selected key is true in the response  of
       aria2.getFiles()  RPC  method.   If  you  want  to  get all file paths, consider to use JSON-RPC/XML-RPC.
       Please  note  that  file  path  may  change  during  download  in  HTTP   because   of   redirection   or
       Content-Disposition header.

       Let's see an example of how arguments are passed to command:

          $ cat hook.sh
          #!/bin/sh
          echo "Called with [$1] [$2] [$3]"
          $ aria2c --on-download-complete hook.sh http://example.org/file.iso
          Called with [1] [1] [/path/to/file.iso]

EXIT STATUS

       Because  aria2  can  handle multiple downloads at once, it encounters lots of errors in a session.  aria2
       returns the following exit status based on the last error encountered.

       0      If all downloads were successful.

       1      If an unknown error occurred.

       2      If time out occurred.

       3      If a resource was not found.

       4      If aria2 saw the specified number of "resource not found" error.  See --max-file-not-found option.

       5      If a download aborted because download speed was too slow.  See --lowest-speed-limit option.

       6      If network problem occurred.

       7      If there were unfinished downloads. This error is only reported if  all  finished  downloads  were
              successful  and there were unfinished downloads in a queue when aria2 exited by pressing Ctrl-C by
              an user or sending TERM or INT signal.

       8      If remote server did not support resume when resume was required to complete download.

       9      If there was not enough disk space available.

       10     If piece length was different from one in .aria2  control  file.  See  --allow-piece-length-change
              option.

       11     If aria2 was downloading same file at that moment.

       12     If aria2 was downloading same info hash torrent at that moment.

       13     If file already existed. See --allow-overwrite option.

       14     If renaming file failed. See --auto-file-renaming option.

       15     If aria2 could not open existing file.

       16     If aria2 could not create new file or truncate existing file.

       17     If file I/O error occurred.

       18     If aria2 could not create directory.

       19     If name resolution failed.

       20     If aria2 could not parse Metalink document.

       21     If FTP command failed.

       22     If HTTP response header was bad or unexpected.

       23     If too many redirects  occurred.

       24     If HTTP authorization failed.

       25     If aria2 could not parse bencoded file (usually ".torrent" file).

       26     If ".torrent" file was corrupted or missing information that aria2 needed.

       27     If Magnet URI was bad.

       28     If bad/unrecognized option was given or unexpected option argument was given.

       29     If  the  remote  server  was  unable  to  handle  the  request  due  to a temporary overloading or
              maintenance.

       30     If aria2 could not parse JSON-RPC request.

       31     Reserved.  Not used.

       32     If checksum validation failed.

       NOTE:
          An error occurred in a finished download will not be reported as exit status.

ENVIRONMENT

       aria2 recognizes the following environment variables.

       http_proxy [http://][USER:PASSWORD@]HOST[:PORT]
              Specify proxy server for use in HTTP.  Overrides http-proxy  value  in  configuration  file.   The
              command-line option --http-proxy overrides this value.

       https_proxy [http://][USER:PASSWORD@]HOST[:PORT]
              Specify  proxy  server  for use in HTTPS.  Overrides https-proxy value in configuration file.  The
              command-line option --https-proxy overrides this value.

       ftp_proxy [http://][USER:PASSWORD@]HOST[:PORT]
              Specify proxy server for use in FTP.   Overrides  ftp-proxy  value  in  configuration  file.   The
              command-line option --ftp-proxy overrides this value.

       all_proxy [http://][USER:PASSWORD@]HOST[:PORT]
              Specify  proxy  server  for  use  if no protocol-specific proxy is specified.  Overrides all-proxy
              value in configuration file.  The command-line option --all-proxy overrides this value.

       NOTE:
          Although aria2 accepts ftp:// and https:// scheme in proxy URI, it  simply  assumes  that  http://  is
          specified and does not change its behavior based on the specified scheme.

       no_proxy [DOMAIN,...]
              Specify  a  comma-separated  list  of  host names, domains and network addresses with or without a
              subnet mask where no proxy should be used.  Overrides the no-proxy value  in  configuration  file.
              The command-line option --no-proxy overrides this value.

FILES

   aria2.conf
       By  default,  aria2  parses  $HOME/.aria2/aria2.conf as a configuration file. You can specify the path to
       configuration file using --conf-path option.  If you don't  want  to  use  the  configuration  file,  use
       --no-conf option.

       The  configuration  file  is  a  text  file and has 1 option per each line. In each line, you can specify
       name-value pair in the format: NAME=VALUE, where name is the long command-line  option  name  without  --
       prefix.  You  can  use  same  syntax  for  the  command-line option. The lines beginning # are treated as
       comments:

          # sample configuration file for aria2c
          listen-port=60000
          dht-listen-port=60000
          seed-ratio=1.0
          max-upload-limit=50K
          ftp-pasv=true

       NOTE:
          The confidential information such as user/password might be included in the configuration file. It  is
          recommended  to  change file mode bits of the configuration file (e.g., chmod 600 aria2.conf), so that
          other user cannot see the contents of the file.

   dht.dat
       By default, the routing table of IPv4 DHT is saved to the path $HOME/.aria2/dht.dat and the routing table
       of IPv6 DHT is saved to the path $HOME/.aria2/dht6.dat.

   Netrc
       Netrc  support  is enabled by default for HTTP(S)/FTP/SFTP.  To disable netrc support, specify --no-netrc
       option.  Your .netrc file should have correct permissions(600).

       If machine name starts ., aria2 performs domain-match instead of exact match. This  is  an  extension  of
       aria2. For example of domain match, imagine the following .netrc entry:

          machine .example.org login myid password mypasswd

       aria2.example.org domain-matches .example.org and uses myid and mypasswd.

       Some  domain-match  example  follow: example.net does not domain-match .example.org. example.org does not
       domain-match .example.org because of preceding .. If you want to match example.org, specify example.org.

   Control File
       aria2 uses a control file to track the progress of a download.  A control file  is  placed  in  the  same
       directory  as  the  downloading  file  and its file name is the file name of downloading file with .aria2
       appended.  For example, if you are downloading file.zip, then the control file should be  file.zip.aria2.
       (There  is  a  exception for this naming convention.  If you are downloading a multi torrent, its control
       file is the "top directory" name of the torrent with .aria2 appended.  The  "top  directory"  name  is  a
       value of "name" key in "info" directory in a torrent file.)

       Usually  a  control  file  is  deleted once download completed.  If aria2 decides that download cannot be
       resumed(for example, when downloading a file from a HTTP server which doesn't support resume), a  control
       file is not created.

       Normally  if  you lose a control file, you cannot resume download.  But if you have a torrent or metalink
       with chunk checksums for the file, you can resume the download without a control file by giving -V option
       to aria2c in command-line.

   Input File
       The  input  file  can  contain a list of URIs for aria2 to download.  You can specify multiple URIs for a
       single entity: separate URIs on a single line using the TAB character.

       Each line is treated as if it is provided in command-line  argument.   Therefore  they  are  affected  by
       --force-sequential and --parameterized-uri options.

       Since  URIs  in  the  input  file  are  directly read by aria2, they must not be quoted with single(') or
       double(") quotation.

       Lines starting with # are treated as comments and skipped.

       Additionally, the following options can be specified after each line of URIs. These optional  lines  must
       start with white space(s).

         • all-proxyall-proxy-passwdall-proxy-userallow-overwriteallow-piece-length-changealways-resumeasync-dnsauto-file-renamingbt-enable-lpdbt-exclude-trackerbt-external-ipbt-force-encryptionbt-hash-check-seedbt-max-peersbt-metadata-onlybt-min-crypto-levelbt-prioritize-piecebt-remove-unselected-filebt-request-peer-speed-limitbt-require-cryptobt-save-metadatabt-seed-unverifiedbt-stop-timeoutbt-trackerbt-tracker-connect-timeoutbt-tracker-intervalbt-tracker-timeoutcheck-integritychecksumconditional-getconnect-timeoutcontinuedirdry-runenable-http-keep-aliveenable-http-pipeliningenable-mmapenable-peer-exchangefile-allocationfollow-metalinkfollow-torrentforce-saveftp-passwdftp-pasvftp-proxyftp-proxy-passwdftp-proxy-userftp-reuse-connectionftp-typeftp-usergidhash-check-onlyheaderhttp-accept-gziphttp-auth-challengehttp-no-cachehttp-passwdhttp-proxyhttp-proxy-passwdhttp-proxy-userhttp-userhttps-proxyhttps-proxy-passwdhttps-proxy-userindex-outlowest-speed-limitmax-connection-per-servermax-download-limitmax-file-not-foundmax-resume-failure-triesmax-triesmax-upload-limitmetalink-base-urimetalink-enable-unique-protocolmetalink-languagemetalink-locationmetalink-osmetalink-preferred-protocolmetalink-versionmin-split-sizeno-file-allocation-limitno-netrcno-proxyoutparameterized-uripausepause-metadatapiece-lengthproxy-methodrealtime-chunk-checksumrefererremote-timeremove-control-fileretry-waitreuse-urirpc-save-upload-metadataseed-ratioseed-timeselect-filesplitssh-host-key-mdstream-piece-selectortimeouturi-selectoruse-headuser-agent

       These  options  have exactly same meaning of the ones in the command-line options, but it just applies to
       the URIs it belongs to.  Please note that for options in input file -- prefix must be stripped.

       For example, the content of uri.txt is:

          http://server/file.iso http://mirror/file.iso
            dir=/iso_images
            out=file.img
          http://foo/bar

       If aria2 is executed with -i uri.txt -d /tmp options, then file.iso is saved as /iso_images/file.img  and
       it is downloaded from http://server/file.iso and http://mirror/file.iso.  The file bar is downloaded from
       http://foo/bar and saved as /tmp/bar.

       In some cases, out parameter has no effect.  See note of --out option for the restrictions.

   Server Performance Profile
       This section describes the format of server performance profile.  The file is plain text  and  each  line
       has several NAME=VALUE pair, delimited by comma.  Currently following NAMEs are recognized:

       host   Host name of the server. Required.

       protocol
              Protocol for this profile, such as ftp, http. Required.

       dl_speed
              The average download speed observed in the previous download in bytes per sec.  Required.

       sc_avg_speed
              The  average download speed observed in the previous download in bytes per sec. This value is only
              updated  if  the  download  is  done  in  single  connection  environment   and   only   used   by
              AdaptiveURISelector. Optional.

       mc_avg_speed
              The  average download speed observed in the previous download in bytes per sec. This value is only
              updated  if  the  download  is  done  in  multi  connection   environment   and   only   used   by
              AdaptiveURISelector. Optional.

       counter
              How  many  times  the  server  is  used. Currently this value is only used by AdaptiveURISelector.
              Optional.

       last_updated
              Last contact time in GMT with this server, specified in the seconds since  the  Epoch(00:00:00  on
              January 1, 1970, UTC). Required.

       status ERROR is set when server cannot be reached or out-of-service or timeout occurred. Otherwise, OK is
              set.

       Those fields must exist in one line. The order of the fields is not significant. You can put pairs  other
       than the above; they are simply ignored.

       An example follows:

          host=localhost, protocol=http, dl_speed=32000, last_updated=1222491640, status=OK
          host=localhost, protocol=ftp, dl_speed=0, last_updated=1222491632, status=ERROR

RPC INTERFACE

       aria2  provides  JSON-RPC  over  HTTP  and  XML-RPC  over  HTTP  interfaces that offer basically the same
       functionality.  aria2 also provides JSON-RPC over WebSocket. JSON-RPC over WebSocket uses the same method
       signatures  and  response  format  as  JSON-RPC  over  HTTP,  but  additionally provides server-initiated
       notifications. See JSON-RPC over WebSocket section for more information.

       The request path of the JSON-RPC interface (for both over HTTP and  over  WebSocket)  is  /jsonrpc.   The
       request path of the XML-RPC interface is /rpc.

       The  WebSocket  URI  for  JSON-RPC  over  WebSocket  is  ws://HOST:PORT/jsonrpc.  If  you enabled SSL/TLS
       encryption, use wss://HOST:PORT/jsonrpc instead.

       The implemented JSON-RPC is based on JSON-RPC 2.0 <http://jsonrpc.org/specification>, and  supports  HTTP
       POST and GET (JSONP).  The WebSocket transport is an aria2 extension.

       The  JSON-RPC  interface  does  not  support  notifications  over  HTTP,  but  the  RPC  server will send
       notifications over WebSocket. It also does not support floating point  numbers.  The  character  encoding
       must be UTF-8.

       When reading the following documentation for JSON-RPC, interpret structs as JSON objects.

   Terminology
       GID
          The  GID  (or  gid) is a key to manage each download. Each download will be assigned a unique GID. The
          GID is stored as 64-bit binary value in aria2.  For RPC access, it is represented as a hex  string  of
          16  characters (e.g., 2089b05ecca3d829). Normally, aria2 generates this GID for each download, but the
          user can specify GIDs manually using the --gid option. When querying downloads by GID, you can specify
          only the prefix of a GID as long as it is unique among others.

   RPC authorization secret token
       As  of 1.18.4, in addition to HTTP basic authorization, aria2 provides RPC method-level authorization. In
       a future release, HTTP basic authorization will be removed and RPC method-level authorization will become
       mandatory.

       To  use  RPC  method-level authorization, the user has to specify an RPC secret authorization token using
       the --rpc-secret option. For each RPC method call, the caller has to  include  the  token  prefixed  with
       token:.  Even  when  the  --rpc-secret  option is not used, if the first parameter in the RPC method is a
       string and starts with token:, it will removed from the  parameter  list  before  the  request  is  being
       processed.

       For  example,  if the RPC secret authorization token is $$secret$$, calling aria2.addUri RPC method would
       have to look like this:

          aria2.addUri("token:$$secret$$", ["http://example.org/file"])

       The system.multicall RPC method is treated specially. Since  the  XML-RPC  specification  only  allows  a
       single array as a parameter for this method, we don't specify the token in the call. Instead, each nested
       method call has to provide the token as the first parameter as described above.

       NOTE:
          The secret token validation in aria2 is designed to take at least a certain amount of time to mitigate
          brute-force/dictionary  attacks against the RPC interface. Therefore it is recommended to prefer Batch
          or system.multicall requests when appropriate.

   Methods
       All code examples are compatible with  the  Python  2.7  interpreter.   For  information  on  the  secret
       parameter, see RPC authorization secret token.

       aria2.addUri([secret], uris[, options[, position]])
              This  method  adds  a  new  download.  uris is an array of HTTP/FTP/SFTP/BitTorrent URIs (strings)
              pointing to the same resource.  If you mix URIs pointing to different resources, then the download
              may fail or be corrupted without aria2 complaining.  When adding BitTorrent Magnet URIs, uris must
              have only one element and it should be BitTorrent Magnet URI.  options is a struct and its members
              are pairs of option name and value.  See Options below for more details.  If position is given, it
              must be an integer starting from 0. The new download will be inserted at position in  the  waiting
              queue.  If  position  is omitted or position is larger than the current size of the queue, the new
              download is appended to the end of the queue.  This method returns the GID of the newly registered
              download.

              JSON-RPC Example

              The following example adds http://example.org/file:

                 >>> import urllib2, json
                 >>> jsonreq = json.dumps({'jsonrpc':'2.0', 'id':'qwer',
                 ...                       'method':'aria2.addUri',
                 ...                       'params':[['http://example.org/file']]})
                 >>> c = urllib2.urlopen('http://localhost:6800/jsonrpc', jsonreq)
                 >>> c.read()
                 '{"id":"qwer","jsonrpc":"2.0","result":"2089b05ecca3d829"}'

              XML-RPC Example

              The following example adds http://example.org/file:

                 >>> import xmlrpclib
                 >>> s = xmlrpclib.ServerProxy('http://localhost:6800/rpc')
                 >>> s.aria2.addUri(['http://example.org/file'])
                 '2089b05ecca3d829'

              The following example adds a new download with two sources and some options:

                 >>> s.aria2.addUri(['http://example.org/file', 'http://mirror/file'],
                                     dict(dir="/tmp"))
                 'd2703803b52216d1'

              The following example adds a download and inserts it to the front of the queue:

                 >>> s.aria2.addUri(['http://example.org/file'], {}, 0)
                 'ca3d829cee549a4d'

       aria2.addTorrent([secret], torrent[, uris[, options[, position]]])
              This  method  adds  a  BitTorrent  download  by uploading a ".torrent" file.  If you want to add a
              BitTorrent Magnet URI, use the aria2.addUri() method instead.  torrent must  be  a  base64-encoded
              string containing the contents of the ".torrent" file.  uris is an array of URIs (string). uris is
              used for Web-seeding.  For single file torrents, the URI can be a complete  URI  pointing  to  the
              resource;  if  URI  ends  with /, name in torrent file is added. For multi-file torrents, name and
              path in torrent are added to form a URI for each file.  options is a struct and  its  members  are
              pairs  of  option  name  and value.  See Options below for more details.  If position is given, it
              must be an integer starting from 0. The new download will be inserted at position in  the  waiting
              queue.  If  position  is omitted or position is larger than the current size of the queue, the new
              download is appended to the end of the queue.  This method returns the GID of the newly registered
              download.   If  --rpc-save-upload-metadata  is true, the uploaded data is saved as a file named as
              the hex string of SHA-1 hash of data plus ".torrent" in the directory specified by  --dir  option.
              E.g.  a  file  name might be 0a3893293e27ac0490424c06de4d09242215f0a6.torrent.  If a file with the
              same name already exists, it is  overwritten!   If  the  file  cannot  be  saved  successfully  or
              --rpc-save-upload-metadata  is  false,  the  downloads  added  by  this  method  are  not saved by
              --save-session.

              The following examples add local file file.torrent.

              JSON-RPC Example

                 >>> import urllib2, json, base64
                 >>> torrent = base64.b64encode(open('file.torrent').read())
                 >>> jsonreq = json.dumps({'jsonrpc':'2.0', 'id':'asdf',
                 ...                       'method':'aria2.addTorrent', 'params':[torrent]})
                 >>> c = urllib2.urlopen('http://localhost:6800/jsonrpc', jsonreq)
                 >>> c.read()
                 '{"id":"asdf","jsonrpc":"2.0","result":"2089b05ecca3d829"}'

              XML-RPC Example

                 >>> import xmlrpclib
                 >>> s = xmlrpclib.ServerProxy('http://localhost:6800/rpc')
                 >>> s.aria2.addTorrent(xmlrpclib.Binary(open('file.torrent').read()))
                 '2089b05ecca3d829'

       aria2.addMetalink([secret], metalink[, options[, position]])
              This  method  adds  a  Metalink  download  by  uploading  a  ".metalink"  file.   metalink  is   a
              base64-encoded  string  which  contains the contents of the ".metalink" file.  options is a struct
              and its members are pairs of option name and value.  See  Options  below  for  more  details.   If
              position  is  given,  it  must be an integer starting from 0. The new download will be inserted at
              position in the waiting queue. If position is omitted or position is larger than the current  size
              of  the queue, the new download is appended to the end of the queue.  This method returns an array
              of GIDs of newly registered downloads.  If --rpc-save-upload-metadata is true, the  uploaded  data
              is  saved  as  a  file  named  hex  string of SHA-1 hash of data plus ".metalink" in the directory
              specified      by      --dir      option.       E.g.      a      file      name      might      be
              0a3893293e27ac0490424c06de4d09242215f0a6.metalink.   If  a file with the same name already exists,
              it is overwritten!  If the file cannot be  saved  successfully  or  --rpc-save-upload-metadata  is
              false, the downloads added by this method are not saved by --save-session.

              The following examples add local file file.meta4.

              JSON-RPC Example

                 >>> import urllib2, json, base64
                 >>> metalink = base64.b64encode(open('file.meta4').read())
                 >>> jsonreq = json.dumps({'jsonrpc':'2.0', 'id':'qwer',
                 ...                       'method':'aria2.addMetalink',
                 ...                       'params':[metalink]})
                 >>> c = urllib2.urlopen('http://localhost:6800/jsonrpc', jsonreq)
                 >>> c.read()
                 '{"id":"qwer","jsonrpc":"2.0","result":["2089b05ecca3d829"]}'

              XML-RPC Example

                 >>> import xmlrpclib
                 >>> s = xmlrpclib.ServerProxy('http://localhost:6800/rpc')
                 >>> s.aria2.addMetalink(xmlrpclib.Binary(open('file.meta4').read()))
                 ['2089b05ecca3d829']

       aria2.remove([secret], gid)
              This  method  removes  the  download  denoted  by  gid  (string).  If the specified download is in
              progress, it is first stopped.  The status of the removed download becomes removed.   This  method
              returns GID of removed download.

              The following examples remove a download with GID#2089b05ecca3d829.

              JSON-RPC Example

                 >>> import urllib2, json
                 >>> jsonreq = json.dumps({'jsonrpc':'2.0', 'id':'qwer',
                 ...                       'method':'aria2.remove',
                 ...                       'params':['2089b05ecca3d829']})
                 >>> c = urllib2.urlopen('http://localhost:6800/jsonrpc', jsonreq)
                 >>> c.read()
                 '{"id":"qwer","jsonrpc":"2.0","result":"2089b05ecca3d829"}'

              XML-RPC Example

                 >>> import xmlrpclib
                 >>> s = xmlrpclib.ServerProxy('http://localhost:6800/rpc')
                 >>> s.aria2.remove('2089b05ecca3d829')
                 '2089b05ecca3d829'

       aria2.forceRemove([secret], gid)
              This  method  removes  the  download denoted by gid.  This method behaves just like aria2.remove()
              except that this method removes the download without performing any actions which take time,  such
              as contacting BitTorrent trackers to unregister the download first.

       aria2.pause([secret], gid)
              This  method  pauses  the download denoted by gid (string).  The status of paused download becomes
              paused.  If the download was active, the download is placed in the front of waiting queue.   While
              the  status  is  paused,  the  download  is  not  started.   To  change status to waiting, use the
              aria2.unpause() method.  This method returns GID of paused download.

       aria2.pauseAll([secret])
              This method is equal to calling aria2.pause() for  every  active/waiting  download.  This  methods
              returns OK.

       aria2.forcePause([secret], gid)
              This  method  pauses  the  download  denoted  by gid.  This method behaves just like aria2.pause()
              except that this method pauses downloads without performing any actions which take time,  such  as
              contacting BitTorrent trackers to unregister the download first.

       aria2.forcePauseAll([secret])
              This method is equal to calling aria2.forcePause() for every active/waiting download. This methods
              returns OK.

       aria2.unpause([secret], gid)
              This method changes the status of the download denoted by gid (string)  from  paused  to  waiting,
              making  the  download  eligible  to  be  restarted.   This  method returns the GID of the unpaused
              download.

       aria2.unpauseAll([secret])
              This method is equal to calling aria2.unpause() for every active/waiting  download.  This  methods
              returns OK.

       aria2.tellStatus([secret], gid[, keys])
              This  method  returns  the  progress of the download denoted by gid (string).  keys is an array of
              strings. If specified, the response contains only keys in the keys array.  If  keys  is  empty  or
              omitted, the response contains all keys. This is useful when you just want specific keys and avoid
              unnecessary  transfers.   For  example,  aria2.tellStatus("2089b05ecca3d829",  ["gid",  "status"])
              returns  the  gid  and  status  keys  only.  The response is a struct and contains following keys.
              Values are strings.

              gid    GID of the download.

              status active for currently downloading/seeding downloads.  waiting for downloads  in  the  queue;
                     download  is  not  started.   paused  for  paused downloads.  error for downloads that were
                     stopped  because of error.  complete for stopped and completed downloads.  removed for  the
                     downloads removed by user.

              totalLength
                     Total length of the download in bytes.

              completedLength
                     Completed length of the download in bytes.

              uploadLength
                     Uploaded length of the download in bytes.

              bitfield
                     Hexadecimal  representation  of  the  download progress. The highest bit corresponds to the
                     piece at index 0. Any set bits indicate loaded pieces, while unset bits  indicate  not  yet
                     loaded  and/or  missing  pieces.  Any  overflow  bits at the end are set to zero.  When the
                     download was not started yet, this key will not be included in the response.

              downloadSpeed
                     Download speed of this download measured in bytes/sec.

              uploadSpeed
                     Upload speed of this download measured in bytes/sec.

              infoHash
                     InfoHash. BitTorrent only.

              numSeeders
                     The number of seeders aria2 has connected to. BitTorrent only.

              pieceLength
                     Piece length in bytes.

              numPieces
                     The number of pieces.

              connections
                     The number of peers/servers aria2 has connected to.

              errorCode
                     The code of the last error for this item, if any. The value is a string.  The  error  codes
                     are defined in the EXIT STATUS section.  This value is only available for stopped/completed
                     downloads.

              followedBy
                     List of GIDs which are generated as the result of this download. For  example,  when  aria2
                     downloads  a  Metalink  file,  it  generates  downloads  described in the Metalink (see the
                     --follow-metalink option). This value is useful to track auto-generated downloads. If there
                     are no such downloads, this key will not be included in the response.

              belongsTo
                     GID of a parent download. Some downloads are a part of another download.  For example, if a
                     file in a Metalink has BitTorrent resources, the downloads of ".torrent" files are parts of
                     that  parent.   If  this  download  has  no  parent,  this  key will not be included in the
                     response.

              dir    Directory to save files.

              files  Returns the list of files. The  elements  of  this  list  are  the  same  structs  used  in
                     aria2.getFiles() method.

              bittorrent
                     Struct  which  contains information retrieved from the .torrent (file). BitTorrent only. It
                     contains following keys.

                     announceList
                            List  of  lists  of  announce  URIs.  If  the  torrent  contains  announce  and   no
                            announce-list, announce is converted to the announce-list format.

                     comment
                            The comment of the torrent. comment.utf-8 is used if available.

                     creationDate
                            The  creation time of the torrent. The value is an integer since the epoch, measured
                            in seconds.

                     mode   File mode of the torrent. The value is either single or multi.

                     info   Struct which contains data from Info dictionary. It contains following keys.

                            name   name in info dictionary. name.utf-8 is used if available.

              JSON-RPC Example

              The following example gets information about a download with GID#2089b05ecca3d829:

                 >>> import urllib2, json
                 >>> from pprint import pprint
                 >>> jsonreq = json.dumps({'jsonrpc':'2.0', 'id':'qwer',
                 ...                       'method':'aria2.tellStatus',
                 ...                       'params':['2089b05ecca3d829']})
                 >>> c = urllib2.urlopen('http://localhost:6800/jsonrpc', jsonreq)
                 >>> pprint(json.loads(c.read()))
                 {u'id': u'qwer',
                  u'jsonrpc': u'2.0',
                  u'result': {u'bitfield': u'0000000000',
                              u'completedLength': u'901120',
                              u'connections': u'1',
                              u'dir': u'/downloads',
                              u'downloadSpeed': u'15158',
                              u'files': [{u'index': u'1',
                                          u'length': u'34896138',
                                          u'completedLength': u'34896138',
                                          u'path': u'/downloads/file',
                                          u'selected': u'true',
                                          u'uris': [{u'status': u'used',
                                                     u'uri': u'http://example.org/file'}]}],
                              u'gid': u'2089b05ecca3d829',
                              u'numPieces': u'34',
                              u'pieceLength': u'1048576',
                              u'status': u'active',
                              u'totalLength': u'34896138',
                              u'uploadLength': u'0',
                              u'uploadSpeed': u'0'}}

              The following example gets only specific keys:

                 >>> jsonreq = json.dumps({'jsonrpc':'2.0', 'id':'qwer',
                 ...                       'method':'aria2.tellStatus',
                 ...                       'params':['2089b05ecca3d829',
                 ...                                 ['gid',
                 ...                                  'totalLength',
                 ...                                  'completedLength']]})
                 >>> c = urllib2.urlopen('http://localhost:6800/jsonrpc', jsonreq)
                 >>> pprint(json.loads(c.read()))
                 {u'id': u'qwer',
                  u'jsonrpc': u'2.0',
                  u'result': {u'completedLength': u'5701632',
                              u'gid': u'2089b05ecca3d829',
                              u'totalLength': u'34896138'}}

              XML-RPC Example

              The following example gets information about a download with GID#2089b05ecca3d829:

                 >>> import xmlrpclib
                 >>> from pprint import pprint
                 >>> s = xmlrpclib.ServerProxy('http://localhost:6800/rpc')
                 >>> r = s.aria2.tellStatus('2089b05ecca3d829')
                 >>> pprint(r)
                 {'bitfield': 'ffff80',
                  'completedLength': '34896138',
                  'connections': '0',
                  'dir': '/downloads',
                  'downloadSpeed': '0',
                  'errorCode': '0',
                  'files': [{'index': '1',
                             'length': '34896138',
                             'completedLength': '34896138',
                             'path': '/downloads/file',
                             'selected': 'true',
                             'uris': [{'status': 'used',
                                       'uri': 'http://example.org/file'}]}],
                  'gid': '2089b05ecca3d829',
                  'numPieces': '17',
                  'pieceLength': '2097152',
                  'status': 'complete',
                  'totalLength': '34896138',
                  'uploadLength': '0',
                  'uploadSpeed': '0'}

              The following example gets only specific keys:

                 >>> r = s.aria2.tellStatus('2089b05ecca3d829', ['gid', 'totalLength', 'completedLength'])
                 >>> pprint(r)
                 {'completedLength': '34896138', 'gid': '2089b05ecca3d829', 'totalLength': '34896138'}

       aria2.getUris([secret], gid)
              This method returns the URIs used in the download denoted by gid (string).   The  response  is  an
              array of structs and it contains following keys.  Values are string.

              uri    URI

              status 'used' if the URI is in use. 'waiting' if the URI is still waiting in the queue.

              JSON-RPC Example

                 >>> import urllib2, json
                 >>> from pprint import pprint
                 >>> jsonreq = json.dumps({'jsonrpc':'2.0', 'id':'qwer',
                 ...                       'method':'aria2.getUris',
                 ...                       'params':['2089b05ecca3d829']})
                 >>> c = urllib2.urlopen('http://localhost:6800/jsonrpc', jsonreq)
                 >>> pprint(json.loads(c.read()))
                 {u'id': u'qwer',
                  u'jsonrpc': u'2.0',
                  u'result': [{u'status': u'used',
                               u'uri': u'http://example.org/file'}]}

              XML-RPC Example

                 >>> import xmlrpclib
                 >>> from pprint import pprint
                 >>> s = xmlrpclib.ServerProxy('http://localhost:6800/rpc')
                 >>> r = s.aria2.getUris('2089b05ecca3d829')
                 >>> pprint(r)
                 [{'status': 'used', 'uri': 'http://example.org/file'}]

       aria2.getFiles([secret], gid)
              This  method  returns  the  file list of the download denoted by gid (string).  The response is an
              array of structs which contain following keys.  Values are strings.

              index  Index of the file, starting at 1, in the same order  as  files  appear  in  the  multi-file
                     torrent.

              path   File path.

              length File size in bytes.

              completedLength
                     Completed  length  of  this  file  in  bytes.   Please note that it is possible that sum of
                     completedLength is less than the completedLength returned by the aria2.tellStatus() method.
                     This  is because completedLength in aria2.getFiles() only includes completed pieces. On the
                     other hand, completedLength in aria2.tellStatus() also includes partially completed pieces.

              selected
                     true if this file is selected by --select-file option. If --select-file is not specified or
                     this  is  single-file  torrent or not a torrent download at all, this value is always true.
                     Otherwise false.

              uris   Returns a list of URIs for this file. The element type is  the  same  struct  used  in  the
                     aria2.getUris() method.

              JSON-RPC Example

                 >>> import urllib2, json
                 >>> from pprint import pprint
                 >>> jsonreq = json.dumps({'jsonrpc':'2.0', 'id':'qwer',
                 ...                       'method':'aria2.getFiles',
                 ...                       'params':['2089b05ecca3d829']})
                 >>> c = urllib2.urlopen('http://localhost:6800/jsonrpc', jsonreq)
                 >>> pprint(json.loads(c.read()))
                 {u'id': u'qwer',
                  u'jsonrpc': u'2.0',
                  u'result': [{u'index': u'1',
                               u'length': u'34896138',
                               u'completedLength': u'34896138',
                               u'path': u'/downloads/file',
                               u'selected': u'true',
                               u'uris': [{u'status': u'used',
                                          u'uri': u'http://example.org/file'}]}]}

              XML-RPC Example

                 >>> import xmlrpclib
                 >>> from pprint import pprint
                 >>> s = xmlrpclib.ServerProxy('http://localhost:6800/rpc')
                 >>> r = s.aria2.getFiles('2089b05ecca3d829')
                 >>> pprint(r)
                 [{'index': '1',
                   'length': '34896138',
                   'completedLength': '34896138',
                   'path': '/downloads/file',
                   'selected': 'true',
                   'uris': [{'status': 'used',
                             'uri': 'http://example.org/file'}]}]

       aria2.getPeers([secret], gid)
              This  method  returns  a  list  peers of the download denoted by gid (string).  This method is for
              BitTorrent only.  The response is an array of structs and contains the following keys. Values  are
              strings.

              peerId Percent-encoded peer ID.

              ip     IP address of the peer.

              port   Port number of the peer.

              bitfield
                     Hexadecimal  representation  of  the  download  progress  of  the  peer.  The  highest  bit
                     corresponds to the piece at index 0. Set bits indicate the piece  is  available  and  unset
                     bits indicate the piece is missing. Any spare bits at the end are set to zero.

              amChoking
                     true if aria2 is choking the peer. Otherwise false.

              peerChoking
                     true if the peer is choking aria2. Otherwise false.

              downloadSpeed
                     Download speed (byte/sec) that this client obtains from the peer.

              uploadSpeed
                     Upload speed(byte/sec) that this client uploads to the peer.

              seeder true is this peer is a seeder. Otherwise false.

              JSON-RPC Example

                 >>> import urllib2, json
                 >>> from pprint import pprint
                 >>> jsonreq = json.dumps({'jsonrpc':'2.0', 'id':'qwer',
                 ...                       'method':'aria2.getPeers',
                 ...                       'params':['2089b05ecca3d829']})
                 >>> c = urllib2.urlopen('http://localhost:6800/jsonrpc', jsonreq)
                 >>> pprint(json.loads(c.read()))
                 {u'id': u'qwer',
                  u'jsonrpc': u'2.0',
                  u'result': [{u'amChoking': u'true',
                               u'bitfield': u'ffffffffffffffffffffffffffffffffffffffff',
                               u'downloadSpeed': u'10602',
                               u'ip': u'10.0.0.9',
                               u'peerChoking': u'false',
                               u'peerId': u'aria2%2F1%2E10%2E5%2D%87%2A%EDz%2F%F7%E6',
                               u'port': u'6881',
                               u'seeder': u'true',
                               u'uploadSpeed': u'0'},
                              {u'amChoking': u'false',
                               u'bitfield': u'ffffeff0fffffffbfffffff9fffffcfff7f4ffff',
                               u'downloadSpeed': u'8654',
                               u'ip': u'10.0.0.30',
                               u'peerChoking': u'false',
                               u'peerId': u'bittorrent client758',
                               u'port': u'37842',
                               u'seeder': u'false',
                               u'uploadSpeed': u'6890'}]}

              XML-RPC Example

                 >>> import xmlrpclib
                 >>> from pprint import pprint
                 >>> s = xmlrpclib.ServerProxy('http://localhost:6800/rpc')
                 >>> r = s.aria2.getPeers('2089b05ecca3d829')
                 >>> pprint(r)
                 [{'amChoking': 'true',
                   'bitfield': 'ffffffffffffffffffffffffffffffffffffffff',
                   'downloadSpeed': '10602',
                   'ip': '10.0.0.9',
                   'peerChoking': 'false',
                   'peerId': 'aria2%2F1%2E10%2E5%2D%87%2A%EDz%2F%F7%E6',
                   'port': '6881',
                   'seeder': 'true',
                   'uploadSpeed': '0'},
                  {'amChoking': 'false',
                   'bitfield': 'ffffeff0fffffffbfffffff9fffffcfff7f4ffff',
                   'downloadSpeed': '8654',
                   'ip': '10.0.0.30',
                   'peerChoking': 'false',
                   'peerId': 'bittorrent client758',
                   'port': '37842',
                   'seeder': 'false,
                   'uploadSpeed': '6890'}]

       aria2.getServers([secret], gid)
              This  method  returns  currently connected HTTP(S)/FTP/SFTP servers of the download denoted by gid
              (string). The response is an array of structs and contains the following keys. Values are strings.

              index  Index of the file, starting at 1, in the same order  as  files  appear  in  the  multi-file
                     metalink.

              servers
                     A list of structs which contain the following keys.

                     uri    Original URI.

                     currentUri
                            This  is  the  URI  currently  used  for  downloading.  If  redirection is involved,
                            currentUri and uri may differ.

                     downloadSpeed
                            Download speed (byte/sec)

              JSON-RPC Example

                 >>> import urllib2, json
                 >>> from pprint import pprint
                 >>> jsonreq = json.dumps({'jsonrpc':'2.0', 'id':'qwer',
                 ...                       'method':'aria2.getServers',
                 ...                       'params':['2089b05ecca3d829']})
                 >>> c = urllib2.urlopen('http://localhost:6800/jsonrpc', jsonreq)
                 >>> pprint(json.loads(c.read()))
                 {u'id': u'qwer',
                  u'jsonrpc': u'2.0',
                  u'result': [{u'index': u'1',
                               u'servers': [{u'currentUri': u'http://example.org/file',
                                             u'downloadSpeed': u'10467',
                                             u'uri': u'http://example.org/file'}]}]}

              XML-RPC Example

                 >>> import xmlrpclib
                 >>> from pprint import pprint
                 >>> s = xmlrpclib.ServerProxy('http://localhost:6800/rpc')
                 >>> r = s.aria2.getServers('2089b05ecca3d829')
                 >>> pprint(r)
                 [{'index': '1',
                   'servers': [{'currentUri': 'http://example.org/dl/file',
                                'downloadSpeed': '20285',
                                'uri': 'http://example.org/file'}]}]

       aria2.tellActive([secret][, keys])
              This method returns a list of active downloads.  The response is an array of the same  structs  as
              returned  by  the  aria2.tellStatus()  method.   For  the  keys  parameter,  please  refer  to the
              aria2.tellStatus() method.

       aria2.tellWaiting([secret], offset, num[, keys])
              This method returns a list of waiting downloads, including paused ones.  offset is an integer  and
              specifies  the offset from the download waiting at the front.  num is an integer and specifies the
              max. number  of  downloads  to  be  returned.   For  the  keys  parameter,  please  refer  to  the
              aria2.tellStatus() method.

              If  offset  is a positive integer, this method returns downloads in the range of [offset, offset +
              num).

              offset can be a negative integer. offset == -1 points last  download  in  the  waiting  queue  and
              offset  ==  -2  points the download before the last download, and so on. Downloads in the response
              are in reversed order then.

              For  example,  imagine  three  downloads  "A","B"   and   "C"   are   waiting   in   this   order.
              aria2.tellWaiting(0,   1)   returns   ["A"].   aria2.tellWaiting(1,   2)   returns   ["B",   "C"].
              aria2.tellWaiting(-1, 2) returns ["C", "B"].

              The response is an array of the same structs as returned by aria2.tellStatus() method.

       aria2.tellStopped([secret], offset, num[, keys])
              This method returns a list of stopped downloads.  offset is an integer and  specifies  the  offset
              from  the  least  recently  stopped  download.  num is an integer and specifies the max. number of
              downloads to be returned.  For the keys parameter, please refer to the aria2.tellStatus() method.

              offset and num have the same semantics as described in the aria2.tellWaiting() method.

              The response is an array of the same structs as returned by the aria2.tellStatus() method.

       aria2.changePosition([secret], gid, pos, how)
              This method changes the position of the download denoted by gid in the queue.  pos is an  integer.
              how  is a string. If how is POS_SET, it moves the download to a position relative to the beginning
              of the queue.  If how is POS_CUR, it moves the download to a  position  relative  to  the  current
              position. If how is POS_END, it moves the download to a position relative to the end of the queue.
              If the destination position is less than 0 or beyond the end of the queue, it moves  the  download
              to  the  beginning  or  the end of the queue respectively. The response is an integer denoting the
              resulting position.

              For     example,     if     GID#2089b05ecca3d829     is     currently     in      position      3,
              aria2.changePosition('2089b05ecca3d829',   -1,   'POS_CUR')   will   change  its  position  to  2.
              Additionally aria2.changePosition('2089b05ecca3d829', 0, 'POS_SET') will change its position to  0
              (the beginning of the queue).

              The following examples move the download GID#2089b05ecca3d829 to the front of the queue.

              JSON-RPC Example

                 >>> import urllib2, json
                 >>> from pprint import pprint
                 >>> jsonreq = json.dumps({'jsonrpc':'2.0', 'id':'qwer',
                 ...                       'method':'aria2.changePosition',
                 ...                       'params':['2089b05ecca3d829', 0, 'POS_SET']})
                 >>> c = urllib2.urlopen('http://localhost:6800/jsonrpc', jsonreq)
                 >>> pprint(json.loads(c.read()))
                 {u'id': u'qwer', u'jsonrpc': u'2.0', u'result': 0}

              XML-RPC Example

                 >>> import xmlrpclib
                 >>> s = xmlrpclib.ServerProxy('http://localhost:6800/rpc')
                 >>> s.aria2.changePosition('2089b05ecca3d829', 0, 'POS_SET')
                 0

       aria2.changeUri([secret], gid, fileIndex, delUris, addUris[, position])
              This  method  removes the URIs in delUris from and appends the URIs in addUris to download denoted
              by gid. delUris and addUris are lists of strings. A download can contain multiple files  and  URIs
              are  attached  to  each file.  fileIndex is used to select which file to remove/attach given URIs.
              fileIndex is 1-based. position is used to specify where URIs are inserted in the existing  waiting
              URI  list.  position  is  0-based.  When position is omitted, URIs are appended to the back of the
              list.  This method first executes the removal and then the  addition.  position  is  the  position
              after URIs are removed, not the position when this method is called.  When removing an URI, if the
              same URIs exist in download, only one of them is removed for each URI in delUris. In other  words,
              if there are three URIs http://example.org/aria2 and you want remove them all, you have to specify
              (at least) 3 http://example.org/aria2 in delUris.  This method returns a list which  contains  two
              integers.  The  first  integer  is the number of URIs deleted. The second integer is the number of
              URIs added.

              The following examples add the URI http://example.org/file to  the  file  whose  index  is  1  and
              belongs to the download GID#2089b05ecca3d829.

              JSON-RPC Example

                 >>> import urllib2, json
                 >>> from pprint import pprint
                 >>> jsonreq = json.dumps({'jsonrpc':'2.0', 'id':'qwer',
                 ...                       'method':'aria2.changeUri',
                 ...                       'params':['2089b05ecca3d829', 1, [],
                                                     ['http://example.org/file']]})
                 >>> c = urllib2.urlopen('http://localhost:6800/jsonrpc', jsonreq)
                 >>> pprint(json.loads(c.read()))
                 {u'id': u'qwer', u'jsonrpc': u'2.0', u'result': [0, 1]}

              XML-RPC Example

                 >>> import xmlrpclib
                 >>> s = xmlrpclib.ServerProxy('http://localhost:6800/rpc')
                 >>> s.aria2.changeUri('2089b05ecca3d829', 1, [],
                                       ['http://example.org/file'])
                 [0, 1]

       aria2.getOption([secret], gid)
              This  method  returns options of the download denoted by gid.  The response is a struct where keys
              are the names of options.  The values are strings.  Note that this method does not return  options
              which  have  no default value and have not been set on the command-line, in configuration files or
              RPC methods.

              The following examples get options of the download GID#2089b05ecca3d829.

              JSON-RPC Example

                 >>> import urllib2, json
                 >>> from pprint import pprint
                 >>> jsonreq = json.dumps({'jsonrpc':'2.0', 'id':'qwer',
                 ...                       'method':'aria2.getOption',
                 ...                       'params':['2089b05ecca3d829']})
                 >>> c = urllib2.urlopen('http://localhost:6800/jsonrpc', jsonreq)
                 >>> pprint(json.loads(c.read()))
                 {u'id': u'qwer',
                  u'jsonrpc': u'2.0',
                  u'result': {u'allow-overwrite': u'false',
                              u'allow-piece-length-change': u'false',
                              u'always-resume': u'true',
                              u'async-dns': u'true',
                  ...

              XML-RPC Example

                 >>> import xmlrpclib
                 >>> from pprint import pprint
                 >>> s = xmlrpclib.ServerProxy('http://localhost:6800/rpc')
                 >>> r = s.aria2.getOption('2089b05ecca3d829')
                 >>> pprint(r)
                 {'allow-overwrite': 'false',
                  'allow-piece-length-change': 'false',
                  'always-resume': 'true',
                  'async-dns': 'true',
                  ....

       aria2.changeOption([secret], gid, options)
              This method changes options of the download denoted by gid (string)  dynamically.   options  is  a
              struct.  The following options are available for active downloads:

              • bt-max-peersbt-request-peer-speed-limitbt-remove-unselected-fileforce-savemax-download-limitmax-upload-limit

              For  waiting  or  paused downloads, in addition to the above options, options listed in Input File
              subsection  are   available,   except   for   following   options:   dry-run,   metalink-base-uri,
              parameterized-uri,  pause,  piece-length and rpc-save-upload-metadata option.  This method returns
              OK for success.

              The  following  examples  set  the   max-download-limit   option   to   20K   for   the   download
              GID#2089b05ecca3d829.

              JSON-RPC Example

                 >>> import urllib2, json
                 >>> from pprint import pprint
                 >>> jsonreq = json.dumps({'jsonrpc':'2.0', 'id':'qwer',
                 ...                       'method':'aria2.changeOption',
                 ...                       'params':['2089b05ecca3d829',
                 ...                                 {'max-download-limit':'10K'}]})
                 >>> c = urllib2.urlopen('http://localhost:6800/jsonrpc', jsonreq)
                 >>> pprint(json.loads(c.read()))
                 {u'id': u'qwer', u'jsonrpc': u'2.0', u'result': u'OK'}

              XML-RPC Example

                 >>> import xmlrpclib
                 >>> s = xmlrpclib.ServerProxy('http://localhost:6800/rpc')
                 >>> s.aria2.changeOption('2089b05ecca3d829', {'max-download-limit':'20K'})
                 'OK'

       aria2.getGlobalOption([secret])
              This  method  returns  the  global  options.   The response is a struct. Its keys are the names of
              options.  Values are strings.  Note that this method does not return options which have no default
              value  and  have  not been set on the command-line, in configuration files or RPC methods. Because
              global options are used as a template for the options  of  newly  added  downloads,  the  response
              contains keys returned by the aria2.getOption() method.

       aria2.changeGlobalOption([secret], options)
              This  method  changes global options dynamically.  options is a struct.  The following options are
              available:

              • bt-max-open-filesdownload-resultloglog-levelmax-concurrent-downloadsmax-download-resultmax-overall-download-limitmax-overall-upload-limitsave-cookiessave-sessionserver-stat-of

              In addition, options listed in the Input File  subsection  are  available,  except  for  following
              options: checksum, index-out, out, pause and select-file.

              With  the  log  option,  you  can  dynamically  start logging or change log file. To stop logging,
              specify an empty string("") as the parameter value. Note that log file is always opened in  append
              mode. This method returns OK for success.

       aria2.getGlobalStat([secret])
              This method returns global statistics such as the overall download and upload speeds. The response
              is a struct and contains the following keys. Values are strings.

              downloadSpeed
                     Overall download speed (byte/sec).

              uploadSpeed
                     Overall upload speed(byte/sec).

              numActive
                     The number of active downloads.

              numWaiting
                     The number of waiting downloads.

              numStopped
                     The number of stopped downloads in the  current  session.  This  value  is  capped  by  the
                     --max-download-result option.

              numStoppedTotal
                     The   number   of  stopped  downloads  in  the  current  session  and  not  capped  by  the
                     --max-download-result option.

              JSON-RPC Example

                 >>> import urllib2, json
                 >>> from pprint import pprint
                 >>> jsonreq = json.dumps({'jsonrpc':'2.0', 'id':'qwer',
                 ...                       'method':'aria2.getGlobalStat'})
                 >>> c = urllib2.urlopen('http://localhost:6800/jsonrpc', jsonreq)
                 >>> pprint(json.loads(c.read()))
                 {u'id': u'qwer',
                  u'jsonrpc': u'2.0',
                  u'result': {u'downloadSpeed': u'21846',
                              u'numActive': u'2',
                              u'numStopped': u'0',
                              u'numWaiting': u'0',
                              u'uploadSpeed': u'0'}}

              XML-RPC Example

                 >>> import xmlrpclib
                 >>> from pprint import pprint
                 >>> s = xmlrpclib.ServerProxy('http://localhost:6800/rpc')
                 >>> r = s.aria2.getGlobalStat()
                 >>> pprint(r)
                 {'downloadSpeed': '23136',
                  'numActive': '2',
                  'numStopped': '0',
                  'numWaiting': '0',
                  'uploadSpeed': '0'}

       aria2.purgeDownloadResult([secret])
              This method purges completed/error/removed downloads to free memory.  This method returns OK.

       aria2.removeDownloadResult([secret], gid)
              This method removes a completed/error/removed download denoted by gid  from  memory.  This  method
              returns OK for success.

              The following examples remove the download result of the download GID#2089b05ecca3d829.

              JSON-RPC Example

                 >>> import urllib2, json
                 >>> from pprint import pprint
                 >>> jsonreq = json.dumps({'jsonrpc':'2.0', 'id':'qwer',
                 ...                       'method':'aria2.removeDownloadResult',
                 ...                       'params':['2089b05ecca3d829']})
                 >>> c = urllib2.urlopen('http://localhost:6800/jsonrpc', jsonreq)
                 >>> pprint(json.loads(c.read()))
                 {u'id': u'qwer', u'jsonrpc': u'2.0', u'result': u'OK'}

              XML-RPC Example

                 >>> import xmlrpclib
                 >>> s = xmlrpclib.ServerProxy('http://localhost:6800/rpc')
                 >>> s.aria2.removeDownloadResult('2089b05ecca3d829')
                 'OK'

       aria2.getVersion([secret])
              This  method  returns  the  version  of  aria2 and the list of enabled features. The response is a
              struct and contains following keys.

              version
                     Version number of aria2 as a string.

              enabledFeatures
                     List of enabled features. Each feature is given as a string.

              JSON-RPC Example

                 >>> import urllib2, json
                 >>> from pprint import pprint
                 >>> jsonreq = json.dumps({'jsonrpc':'2.0', 'id':'qwer',
                 ...                       'method':'aria2.getVersion'})
                 >>> c = urllib2.urlopen('http://localhost:6800/jsonrpc', jsonreq)
                 >>> pprint(json.loads(c.read()))
                 {u'id': u'qwer',
                  u'jsonrpc': u'2.0',
                  u'result': {u'enabledFeatures': [u'Async DNS',
                                                   u'BitTorrent',
                                                   u'Firefox3 Cookie',
                                                   u'GZip',
                                                   u'HTTPS',
                                                   u'Message Digest',
                                                   u'Metalink',
                                                   u'XML-RPC'],
                              u'version': u'1.11.0'}}

              XML-RPC Example

                 >>> import xmlrpclib
                 >>> from pprint import pprint
                 >>> s = xmlrpclib.ServerProxy('http://localhost:6800/rpc')
                 >>> r = s.aria2.getVersion()
                 >>> pprint(r)
                 {'enabledFeatures': ['Async DNS',
                                      'BitTorrent',
                                      'Firefox3 Cookie',
                                      'GZip',
                                      'HTTPS',
                                      'Message Digest',
                                      'Metalink',
                                      'XML-RPC'],
                  'version': '1.11.0'}

       aria2.getSessionInfo([secret])
              This method returns session information.  The response is a struct and contains following key.

              sessionId
                     Session ID, which is generated each time when aria2 is invoked.

              JSON-RPC Example

                 >>> import urllib2, json
                 >>> from pprint import pprint
                 >>> jsonreq = json.dumps({'jsonrpc':'2.0', 'id':'qwer',
                 ...                       'method':'aria2.getSessionInfo'})
                 >>> c = urllib2.urlopen('http://localhost:6800/jsonrpc', jsonreq)
                 >>> pprint(json.loads(c.read()))
                 {u'id': u'qwer',
                  u'jsonrpc': u'2.0',
                  u'result': {u'sessionId': u'cd6a3bc6a1de28eb5bfa181e5f6b916d44af31a9'}}

              XML-RPC Example

                 >>> import xmlrpclib
                 >>> s = xmlrpclib.ServerProxy('http://localhost:6800/rpc')
                 >>> s.aria2.getSessionInfo()
                 {'sessionId': 'cd6a3bc6a1de28eb5bfa181e5f6b916d44af31a9'}

       aria2.shutdown([secret])
              This method shuts down aria2.  This method returns OK.

       aria2.forceShutdown([secret])
              This method shuts down aria2(). This method behaves like :func:'aria2.shutdown` without performing
              any actions which take time, such as contacting BitTorrent trackers to unregister downloads first.
              This method returns OK.

       aria2.saveSession([secret])
              This method saves the current session to a file  specified  by  the  --save-session  option.  This
              method returns OK if it succeeds.

       system.multicall(methods)
              This  methods  encapsulates  multiple  method  calls  in a single request.  methods is an array of
              structs.  The structs contain two keys: methodName and params.  methodName is the method  name  to
              call  and  params is array containing parameters to the method call.  This method returns an array
              of responses.  The elements will be either a one-item array containing the  return  value  of  the
              method call or a struct of fault element if an encapsulated method call fails.

              In  the  following  examples, we add 2 downloads. The first one is http://example.org/file and the
              second one is file.torrent.

              JSON-RPC Example

                 >>> import urllib2, json, base64
                 >>> from pprint import pprint
                 >>> jsonreq = json.dumps({'jsonrpc':'2.0', 'id':'qwer',
                 ...                       'method':'system.multicall',
                 ...                       'params':[[{'methodName':'aria2.addUri',
                 ...                                   'params':[['http://example.org']]},
                 ...                                  {'methodName':'aria2.addTorrent',
                 ...                                   'params':[base64.b64encode(open('file.torrent').read())]}]]})
                 >>> c = urllib2.urlopen('http://localhost:6800/jsonrpc', jsonreq)
                 >>> pprint(json.loads(c.read()))
                 {u'id': u'qwer', u'jsonrpc': u'2.0', u'result': [[u'2089b05ecca3d829'], [u'd2703803b52216d1']]}

              JSON-RPC additionally supports Batch requests as described in the JSON-RPC 2.0 Specification:

                 >>> jsonreq = json.dumps([{'jsonrpc':'2.0', 'id':'qwer',
                 ...                        'method':'aria2.addUri',
                 ...                        'params':[['http://example.org']]},
                 ...                       {'jsonrpc':'2.0', 'id':'asdf',
                 ...                        'method':'aria2.addTorrent',
                 ...                        'params':[base64.b64encode(open('file.torrent').read())]}])
                 >>> c = urllib2.urlopen('http://localhost:6800/jsonrpc', jsonreq)
                 >>> pprint(json.loads(c.read()))
                 [{u'id': u'qwer', u'jsonrpc': u'2.0', u'result': u'2089b05ecca3d829'},
                  {u'id': u'asdf', u'jsonrpc': u'2.0', u'result': u'd2703803b52216d1'}]

              XML-RPC Example

                 >>> import xmlrpclib
                 >>> s = xmlrpclib.ServerProxy('http://localhost:6800/rpc')
                 >>> mc = xmlrpclib.MultiCall(s)
                 >>> mc.aria2.addUri(['http://example.org/file'])
                 >>> mc.aria2.addTorrent(xmlrpclib.Binary(open('file.torrent').read()))
                 >>> r = mc()
                 >>> tuple(r)
                 ('2089b05ecca3d829', 'd2703803b52216d1')

   Error Handling
       Over JSON-RPC, aria2 returns a JSON object which contains an error code in code and the error message  in
       message.

       Over XML-RPC, aria2 returns faultCode=1 and the error message in faultString.

   Options
       The  same options as for --input-file are available. See the Input File subsection for a complete list of
       options.

       In the option struct, the name element is the option name  (without  the  preceding  --)  and  the  value
       element is the argument as a string.

   JSON-RPC Example
          {'split':'1', 'http-proxy':'http://proxy/'}

   XML-RPC Example
          <struct>
            <member>
              <name>split</name>
              <value><string>1</string></value>
            </member>
            <member>
              <name>http-proxy</name>
              <value><string>http://proxy/</string></value>
            </member>
          </struct>

       The header and index-out options are allowed multiple times on the command-line. Since the name should be
       unique in a struct (many XML-RPC library implementations use a hash or dict for struct), a single  string
       is not enough. To overcome this limitation, you may use an array as the value as well as a string.

   JSON-RPC Example
          {'header':['Accept-Language: ja', 'Accept-Charset: utf-8']}

   XML-RPC Example
          <struct>
            <member>
              <name>header</name>
              <value>
                <array>
                  <data>
                    <value><string>Accept-Language: ja</string></value>
                    <value><string>Accept-Charset: utf-8</string></value>
                  </data>
                </array>
              </value>
            </member>
          </struct>

       The  following  example adds a download with two options: dir and header.  The header option requires two
       values, so it uses a list:

          >>> import xmlrpclib
          >>> s = xmlrpclib.ServerProxy('http://localhost:6800/rpc')
          >>> opts = dict(dir='/tmp',
          ...             header=['Accept-Language: ja',
          ...                     'Accept-Charset: utf-8'])
          >>> s.aria2.addUri(['http://example.org/file'], opts)
          '1'

   JSON-RPC using HTTP GET
       The JSON-RPC interface also supports requests via HTTP GET.  The encoding scheme  in  GET  parameters  is
       based on JSON-RPC over HTTP Specification [2008-1-15(RC1)].  The encoding of GET parameters are follows:

          /jsonrpc?method=METHOD_NAME&id=ID&params=BASE64_ENCODED_PARAMS

       The method and id are always treated as JSON string and their encoding must be UTF-8.

       For example, The encoded string of aria2.tellStatus('2089b05ecca3d829') with id='foo' looks like this:

          /jsonrpc?method=aria2.tellStatus&id=foo&params=WyIyMDg5YjA1ZWNjYTNkODI5Il0%3D

       The  params  parameter is Base64-encoded JSON array which usually appears in params attribute in JSON-RPC
       request object.  In the above example, the params is ["2089b05ecca3d829"], therefore:

          ["2089b05ecca3d829"] --(Base64)--> WyIyMDg5YjA1ZWNjYTNkODI5Il0=
                       --(Percent Encode)--> WyIyMDg5YjA1ZWNjYTNkODI5Il0%3D

       The JSON-RPC interface also supports JSONP. You can specify the callback  function  in  the  jsoncallback
       parameter:

          /jsonrpc?method=aria2.tellStatus&id=foo&params=WyIyMDg5YjA1ZWNjYTNkODI5Il0%3D&jsoncallback=cb

       For  Batch  requests,  the  method  and  id  parameters must not be specified.  The whole request must be
       specified in the params parameter. For example, a Batch request:

          [{'jsonrpc':'2.0', 'id':'qwer', 'method':'aria2.getVersion'},
           {'jsonrpc':'2.0', 'id':'asdf', 'method':'aria2.tellActive'}]

       must be encoded like this:

          /jsonrpc?params=W3sianNvbnJwYyI6ICIyLjAiLCAiaWQiOiAicXdlciIsICJtZXRob2QiOiAiYXJpYTIuZ2V0VmVyc2lvbiJ9LCB7Impzb25ycGMiOiAiMi4wIiwgImlkIjogImFzZGYiLCAibWV0aG9kIjogImFyaWEyLnRlbGxBY3RpdmUifV0%3D

   JSON-RPC over WebSocket
       JSON-RPC over WebSocket uses same method signatures and  response  format  as  JSON-RPC  over  HTTP.  The
       supported WebSocket version is 13 which is detailed in RFC 6455.

       To send a RPC request to the RPC server, send a serialized JSON string in a Text frame. The response from
       the RPC server is delivered also in a Text frame.

   Notifications
       The RPC server might send notifications to the client. Notifications  is  unidirectional,  therefore  the
       client  which receives the notification must not respond to it. The method signature of a notification is
       much like a normal method request but lacks the id key. The value of the params key  is  the  data  which
       this notification carries. The format of the value varies depending on the notification method. Following
       notification methods are defined.

       aria2.onDownloadStart(event)
              This notification will be sent when a download is started.  The event is of  type  struct  and  it
              contains following keys.  The value type is string.

              gid    GID of the download.

       aria2.onDownloadPause(event)
              This  notification  will  be  sent when a download is paused.  The event is the same struct as the
              event argument of aria2.onDownloadStart() method.

       aria2.onDownloadStop(event)
              This notification will be sent when a download is stopped by the user.   The  event  is  the  same
              struct as the event argument of aria2.onDownloadStart() method.

       aria2.onDownloadComplete(event)
              This  notification  will  be  sent  when  a  download is complete.  For BitTorrent downloads, this
              notification is sent when the download is complete and seeding is over.  The  event  is  the  same
              struct of the event argument of aria2.onDownloadStart() method.

       aria2.onDownloadError(event)
              This  notification will be sent when a download is stopped due to an error.  The event is the same
              struct as the event argument of aria2.onDownloadStart() method.

       aria2.onBtDownloadComplete(event)
              This notification will be sent when a torrent download is complete but seeding is still going  on.
              The event is the same struct as the event argument of aria2.onDownloadStart() method.

   Sample XML-RPC Client Code
       The  following  Ruby  script  adds  http://localhost/aria2.tar.bz2  to aria2c (running on localhost) with
       option --dir=/downloads and prints the RPC response:

          #!/usr/bin/env ruby

          require 'xmlrpc/client'
          require 'pp'

          client=XMLRPC::Client.new2("http://localhost:6800/rpc")

          options={ "dir" => "/downloads" }
          result=client.call("aria2.addUri", [ "http://localhost/aria2.tar.bz2" ], options)

          pp result

       If you are a Python lover, you can use xmlrpclib (Python3 uses xmlrpc.client instead)  to  interact  with
       aria2:

          import xmlrpclib
          from pprint import pprint

          s = xmlrpclib.ServerProxy("http://localhost:6800/rpc")
          r = s.aria2.addUri(["http://localhost/aria2.tar.bz2"], {"dir":"/downloads"})
          pprint(r)

MISC

   Console Readout
       While downloading files, aria2 prints a readout to the console to show the progress of the downloads. The
       console readout looks like this:

          [#2089b0 400.0KiB/33.2MiB(1%) CN:1 DL:115.7KiB ETA:4m51s]

       This section describes what these numbers and strings mean.

       #NNNNNN
              The first 6 characters of the GID as a hex string. The GID is an  unique  ID  for  each  download,
              internal  to  aria2.  The  GID  is  particularly  useful when interacting with aria2 using the RPC
              interface.

       X/Y(Z%)
              Completed length, the total file length and its progress. If --select-file is used,  this  is  the
              sum of selected files.

       SEED   Share ratio when the aria2 is seeding a finished torrent.

       CN     The number of connections aria2 has established.

       SD     The number of seeders aria2 is connected to.

       DL     Download speed (bytes per second).

       UL     Upload speed (bytes per second) and the number of uploaded bytes.

       ETA    Expected time to finish the download.

       When  more  than  one download is in progress, some of the information described above will be omitted in
       order to show information for several downloads. And the overall download and upload speeds are shown  at
       the beginning of the line.

       When aria2 is allocating file space or validating checksums, it additionally prints the progress of these
       operations:

       FileAlloc
              GID, already allocated length and total length in bytes.

       Checksum
              GID, already validated length and total length in bytes.

EXAMPLE

   HTTP/FTP Segmented Downloads
   Download a file
          $ aria2c "http://host/file.zip"

       NOTE:
          To stop a download, press Ctrl-C. You can resume the transfer by running aria2c with the same argument
          in the same directory. You can change URIs as long as they are pointing to the same file.

   Download a file from two different HTTP servers
          $ aria2c "http://host/file.zip" "http://mirror/file.zip"

   Download a file from one host using multiple connections
          $ aria2c -x2 -k1M "http://host/file.zip"

       NOTE:
          The  -x  option specified the number of allowed connections, while the -k option specified the size of
          chunks.

   Download a file from HTTP and FTP servers at the same time
          $ aria2c "http://host1/file.zip" "ftp://host2/file.zip"

   Download files listed in a text file concurrently
          $ aria2c -ifiles.txt -j2

       NOTE:
          -j option specifies the number of parallel downloads.

   Using a proxy
       For HTTP:

          $ aria2c --http-proxy="http://proxy:8080" "http://host/file"

          $ aria2c --http-proxy="http://proxy:8080" --no-proxy="localhost,127.0.0.1,192.168.0.0/16" "http://host/file"

       For FTP:

          $ aria2c --ftp-proxy="http://proxy:8080" "ftp://host/file"

       NOTE:
          See --http-proxy, --https-proxy, --ftp-proxy, --all-proxy and --no-proxy for details.  You can specify
          proxy in the environment variables. See ENVIRONMENT section.

   Using a Proxy with authorization
          $ aria2c --http-proxy="http://username:password@proxy:8080" "http://host/file"

          $ aria2c --http-proxy="http://proxy:8080" --http-proxy-user="username" --http-proxy-passwd="password" "http://host/file"

   Metalink Download
   Download files with remote Metalink
          $ aria2c --follow-metalink=mem "http://host/file.metalink"

   Download using a local metalink file
          $ aria2c -p --lowest-speed-limit=4000 file.metalink

       NOTE:
          To  stop  a  download,  press  Ctrl-C.   You  can  resume the transfer by running aria2c with the same
          argument in the same directory.

   Download several local metalink files
          $ aria2c -j2 file1.metalink file2.metalink

   Download only selected files
          $ aria2c --select-file=1-4,8 file.metalink

       NOTE:
          The index is printed to the console using -S option.

   Download a file using a local metalink file with user preference
          $ aria2c --metalink-location=jp,us --metalink-version=1.1 --metalink-language=en-US file.metalink

   BitTorrent Download
   Download files using a remote BitTorrent file
          $ aria2c --follow-torrent=mem "http://host/file.torrent"

   Download using a local torrent file
          $ aria2c --max-upload-limit=40K file.torrent

       NOTE:
          --max-upload-limit specifies the max of upload rate.

       NOTE:
          To stop a download, press Ctrl-C. You can resume the transfer later by running aria2c  with  the  same
          argument in the same directory.

   Download using BitTorrent Magnet URI
          $ aria2c "magnet:?xt=urn:btih:248D0A1CD08284299DE78D5C1ED359BB46717D8C&dn=aria2"

       NOTE:
          Don't  forget  to  quote BitTorrent Magnet URIs which include & characters with single(') or double(")
          quotes when specifying URIs on the command-line.

   Download 2 torrents
          $ aria2c -j2 file1.torrent file2.torrent

   Download a file via torrent and HTTP/FTP server in parallel
          $ aria2c -Ttest.torrent "http://host1/file" "ftp://host2/file"

       NOTE:
          Downloading a multi-file torrent while also using HTTP/FTP is not supported.

   Only download specific files (usually called selected download )
          $ aria2c --select-file=1-4,8 file.torrent

       NOTE:
          The index is printed to the console using -S option.

   Download a .torrent file, but do not download the torrent
          $ aria2c --follow-torrent=false "http://host/file.torrent"

   Specify the output file name
       To specify the output file name for BitTorrent downloads, you need to know  the  index  of  file  in  the
       torrent (see --show-files). For example, the output looks like this:

          idx|path/length
          ===+======================
            1|dist/base-2.6.18.iso
             |99.9MiB
          ---+----------------------
            2|dist/driver-2.6.18.iso
             |169.0MiB
          ---+----------------------

       To    save    'dist/base-2.6.18.iso'    in    '/tmp/mydir/base.iso'   and   'dist/driver-2.6.18.iso'   in
       '/tmp/dir/driver.iso', use the following command:

          $ aria2c --dir=/tmp --index-out=1=mydir/base.iso --index-out=2=dir/driver.iso file.torrent

   Change the listening ports for incoming peer connections
          $ aria2c --listen-port=7000-7001,8000 file.torrent

       NOTE:
          Since aria2 doesn't configure firewalls or routers for port forwarding,  it's  up  to  you  to  do  so
          manually.

   Specify conditions to stop seeding after torrent downloads finish
          $ aria2c --seed-time=120 --seed-ratio=1.0 file.torrent

       NOTE:
          In  the  above  example,  the program stops seeding after 120 minutes since download completed or seed
          ratio reaches 1.0.

   Throttle upload speed
          $ aria2c --max-upload-limit=100K file.torrent

   Enable IPv4 DHT
          $ aria2c --enable-dht --dht-listen-port=6881 file.torrent

       NOTE:
          DHT uses UDP. Since aria2 doesn't configure firewalls or routers for port forwarding, it's up  to  you
          to do it manually.

   Enable IPv6 DHT
          $ aria2c --enable-dht6 --dht-listen-port=6881 --dht-listen-addr6=YOUR_GLOBAL_UNICAST_IPV6_ADDR

       NOTE:
          aria2 uses the same ports as IPv4 for IPv6.

   Add and remove tracker URIs
       Ignore   all  tracker  announce  URIs  defined  in  file.torrent  and  use  http://tracker1/announce  and
       http://tracker2/announce instead:

          $ aria2c --bt-exclude-tracker="*" --bt-tracker="http://tracker1/announce,http://tracker2/announce" file.torrent

   More advanced HTTP features
   Load cookies
          $ aria2c --load-cookies=cookies.txt "http://host/file.zip"

       NOTE:
          You can use Firefox/Mozilla/Chromium's cookie files without modification.

   Resume download started by web browsers or other programs
          $ aria2c -c -s2 "http://host/partiallydownloadedfile.zip"

       NOTE:
          This will only work when the initial download was not multi-segmented.

   Client certificate authorization for SSL/TLS
       Specify a PKCS12 file as follows:

          $ aria2c --certificate=/path/to/mycert.p12

       NOTE:
          The file specified in --certificate must be contain  one  PKCS12  encoded  certificate  and  key.  The
          password must be blank.

       Alternatively, if PEM files are supported, use a command like the following:

          $ aria2c --certificate=/path/to/mycert.pem --private-key=/path/to/mykey.pem https://host/file

       NOTE:
          The  file  specified  in  --private-key must be decrypted. The behavior when encrypted one is given is
          undefined.

   Verify SSL/TLS servers using given CA certificates
          $ aria2c --ca-certificate=/path/to/ca-certificates.crt --check-certificate https://host/file

       NOTE:
          This option is only available when aria2 was compiled against GnuTLS or OpenSSL.  WinTLS and  AppleTLS
          will  always use the system certificate store. Instead of `--ca-certificate install the certificate in
          that store.

   RPC
   Encrypt RPC traffic with SSL/TLS
       Specify a server PKC12 file:

          $ aria2c --enable-rpc --rpc-certificate=/path/to/server.p12 --rpc-secure

       NOTE:
          The file specified in --rpc-certificate must be contain one PKCS12 encoded certificate  and  key.  The
          password must be blank.

       Alternatively, when PEM files are supported (GnuTLS and OpenSSL), specify the server certificate file and
       private key file as follows:

          $ aria2c --enable-rpc --rpc-certificate=/path/to/server.crt --rpc-private-key=/path/to/server.key --rpc-secure

   And more advanced features
   Throttle the download speed
       Per-download:

          $ aria2c --max-download-limit=100K file.metalink

       Overall:

          $ aria2c --max-overall-download-limit=100K file.metalink

   Repair a damaged download
          $ aria2c -V file.metalink

       NOTE:
          Repairing damaged downloads can be done efficiently when used with BitTorrent or Metalink  with  chunk
          checksums.

   Drop connections if download speed is lower than a specified limit
          $ aria2c --lowest-speed-limit=10K file.metalink

   Parameterized URI support
       You can specify set of parts:

          $ aria2c -P "http://{host1,host2,host3}/file.iso"

       You can specify numeric sequence:

          $ aria2c -Z -P "http://host/image[000-100].png"

       NOTE:
          The -Z option is required if the URIs don't point to the same file, such as in the above example.

       You can specify step counter:

          $ aria2c -Z -P "http://host/image[A-Z:2].png"

   Verifying checksums
          $ aria2c --checksum=sha-1=0192ba11326fe2298c8cb4de616f4d4140213837 http://example.org/file

   Parallel downloads of an arbitrary number of URIs, metalink, torrent
          $ aria2c -j3 -Z "http://host/file1" file2.torrent file3.metalink

   BitTorrent Encryption
       Encrypt the whole payload using ARC4 (obfuscation):

          $ aria2c --bt-min-crypto-level=arc4 --bt-require-crypto=true file.torrent

SEE ALSO

       Project Web Site: http://aria2.sourceforge.net/

       Metalink Homepage: http://www.metalinker.org/

       The Metalink Download Description Format: RFC 5854

       Copyright (C) 2006, 2014 Tatsuhiro Tsujikawa

       This  program  is  free  software;  you  can  redistribute it and/or modify it under the terms of the GNU
       General Public License as published by the Free Software Foundation; either version 2 of the License,  or
       (at your option) any later version.

       This  program  is  distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
       the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General  Public
       License for more details.

       You  should have received a copy of the GNU General Public License along with this program; if not, write
       to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

       In addition, as a special exception, the copyright holders give permission to link the code  of  portions
       of  this program with the OpenSSL library under certain conditions as described in each individual source
       file, and distribute linked combinations including the two.  You must obey the GNU General Public License
       in  all respects for all of the code used other than OpenSSL.  If you modify file(s) with this exception,
       you may extend this exception to your version of the file(s), but you are not obligated to do so.  If you
       do  not  wish  to do so, delete this exception statement from your version.  If you delete this exception
       statement from all source files in the program, then also delete it here.