Enable API-Access and Extract the current API-Definitions

[BotMaster3000]

API-Access needs to be enabled, and the current API-Definitions are to be extracted.

[BotMaster3000]

To enable API-Access, one has to edit the keys.dat file. On Fedora(or most likely on most other Linux-Systems too) it is located in ~/.config/PyBitmessage.

The following lines need to be added there:
apienabled = true
apiusername = username
apipassword = password

The following two lines should already be there, but in case they are missing they are required too:
apiport = 8442
apiinterface = 127.0.0.1

Extracting the API-Definition seems to be a little harder than originally thought. Originally it was thought that the Models were provided by the API itself, by calling a specific URL, but it seems they still have to be acquired by reading through the following file, looking for the '@command'-Lines:

https://github.com/Bitmessage/PyBitmessage/blob/v0.6/src/api.py

[BotMaster3000]

Below is a list of all the Commands and their descriptions, as extracted from the api.py-File

@command('decodeAddress')
def HandleDecodeAddress(self, address):
    """
    Decode given address and return dict with
    status, addressVersion, streamNumber and ripe keys
    """
@command('listAddresses', 'listAddresses2')
def HandleListAddresses(self):
    """
    Returns dict with a list of all used addresses with their properties
    in the *addresses* key.
    """

# the listAddressbook alias should be removed eventually.
@command('listAddressBookEntries', 'legacy:listAddressbook')
def HandleListAddressBookEntries(self, label=None):
    """
    Returns dict with a list of all address book entries (address and label)
    in the *addresses* key.
    """

# the addAddressbook alias should be deleted eventually.
@command('addAddressBookEntry', 'legacy:addAddressbook')
def HandleAddAddressBookEntry(self, address, label):
    """Add an entry to address book. label must be base64 encoded."""

# the deleteAddressbook alias should be deleted eventually.
@command('deleteAddressBookEntry', 'legacy:deleteAddressbook')
def HandleDeleteAddressBookEntry(self, address):
    """Delete an entry from address book."""

@command('createRandomAddress')
def HandleCreateRandomAddress(
    self, label, eighteenByteRipe=False, totalDifficulty=0,
    smallMessageDifficulty=0
):
    """
    Create one address using the random number generator.

    :param str label: base64 encoded label for the address
    :param bool eighteenByteRipe: is telling Bitmessage whether to
      generate an address with an 18 byte RIPE hash
      (as opposed to a 19 byte hash).
    """
@command('createDeterministicAddresses')
def HandleCreateDeterministicAddresses(
    self, passphrase, numberOfAddresses=1, addressVersionNumber=0,
    streamNumber=0, eighteenByteRipe=False, totalDifficulty=0,
    smallMessageDifficulty=0
):
    """
    Create many addresses deterministically using the passphrase.

    :param str passphrase: base64 encoded passphrase
    :param int numberOfAddresses: number of addresses to create,
      up to 999

    *addressVersionNumber* and *streamNumber* may be set to 0
    which will tell Bitmessage to use the most up-to-date
    address version and the most available stream.
    """
@command('getDeterministicAddress')
def HandleGetDeterministicAddress(
        self, passphrase, addressVersionNumber, streamNumber):
    """
    Similar to *createDeterministicAddresses* except that the one
    address that is returned will not be added to the Bitmessage
    user interface or the keys.dat file.
    """
@command('createChan')
def HandleCreateChan(self, passphrase):
    """
    Creates a new chan. passphrase must be base64 encoded.
    Returns the corresponding Bitmessage address.
    """
@command('joinChan')
def HandleJoinChan(self, passphrase, suppliedAddress):
    """
    Join a chan. passphrase must be base64 encoded. Returns 'success'.
    """
@command('leaveChan')
def HandleLeaveChan(self, address):
    """
    Leave a chan. Returns 'success'.

    .. note:: at this time, the address is still shown in the UI
      until a restart.
    """
@command('deleteAddress')
def HandleDeleteAddress(self, address):
    """
    Permanently delete the address from keys.dat file. Returns 'success'.
    """
@command('enableAddress')
def HandleEnableAddress(self, address, enable=True):
    """Enable or disable the address depending on the *enable* value"""
@command('getAllInboxMessages')
def HandleGetAllInboxMessages(self):
    """
    Returns a dict with all inbox messages in the *inboxMessages* key.
    The message is a dict with such keys:
    *msgid*, *toAddress*, *fromAddress*, *subject*, *message*,
    *encodingType*, *receivedTime*, *read*.
    *msgid* is hex encoded string.
    *subject* and *message* are base64 encoded.
    """
@command('getAllInboxMessageIds', 'getAllInboxMessageIDs')
def HandleGetAllInboxMessageIds(self):
    """
    The same as *getAllInboxMessages* but returns only *msgid*s,
    result key - *inboxMessageIds*.
    """
@command('getInboxMessageById', 'getInboxMessageByID')
def HandleGetInboxMessageById(self, hid, readStatus=None):
    """
    Returns a dict with list containing single message in the result
    key *inboxMessage*. May also return None if message was not found.

    :param str hid: hex encoded msgid
    :param bool readStatus: sets the message's read status if present
    """
@command('getAllSentMessages')
def HandleGetAllSentMessages(self):
    """
    The same as *getAllInboxMessages* but for sent,
    result key - *sentMessages*. Message dict keys are:
    *msgid*, *toAddress*, *fromAddress*, *subject*, *message*,
    *encodingType*, *lastActionTime*, *status*, *ackData*.
    *ackData* is also a hex encoded string.
    """
@command('getAllSentMessageIds', 'getAllSentMessageIDs')
def HandleGetAllSentMessageIds(self):
    """
    The same as *getAllInboxMessageIds* but for sent,
    result key - *sentMessageIds*.
    """
# after some time getInboxMessagesByAddress should be removed
@command('getInboxMessagesByReceiver', 'legacy:getInboxMessagesByAddress')
def HandleInboxMessagesByReceiver(self, toAddress):
    """
    The same as *getAllInboxMessages* but returns only messages
    for toAddress.
    """
@command('getSentMessageById', 'getSentMessageByID')
def HandleGetSentMessageById(self, hid):
    """
    Similiar to *getInboxMessageById* but doesn't change message's
    read status (sent messages have no such field).
    Result key is *sentMessage*
    """
@command('getSentMessagesByAddress', 'getSentMessagesBySender')
def HandleGetSentMessagesByAddress(self, fromAddress):
    """
    The same as *getAllSentMessages* but returns only messages
    from fromAddress.
    """
@command('getSentMessageByAckData')
def HandleGetSentMessagesByAckData(self, ackData):
    """
    Similiar to *getSentMessageById* but searches by ackdata
    (also hex encoded).
    """
@command('trashMessage')
def HandleTrashMessage(self, msgid):
    """
    Trash message by msgid (encoded in hex). Returns a simple message
    saying that the message was trashed assuming it ever even existed.
    Prior existence is not checked.
    """
@command('trashInboxMessage')
def HandleTrashInboxMessage(self, msgid):
    """Trash inbox message by msgid (encoded in hex)."""

@command('trashSentMessage')
def HandleTrashSentMessage(self, msgid):
    """Trash sent message by msgid (encoded in hex)."""
    msgid = self._decode(msgid, "hex")
    sqlExecute('''UPDATE sent SET folder='trash' WHERE msgid=?''', msgid)
    return 'Trashed sent message (assuming message existed).'
@command('sendMessage')
def HandleSendMessage(
    self, toAddress, fromAddress, subject, message,
    encodingType=2, TTL=4 * 24 * 60 * 60
):
    """
    Send the message and return ackdata (hex encoded string).
    subject and message must be encoded in base64 which may optionally
    include line breaks. TTL is specified in seconds; values outside
    the bounds of 3600 to 2419200 will be moved to be within those
    bounds. TTL defaults to 4 days.
    """
@command('sendBroadcast')
def HandleSendBroadcast(
    self, fromAddress, subject, message, encodingType=2,
        TTL=4 * 24 * 60 * 60):
    """Send the broadcast message. Similiar to *sendMessage*."""

@command('getStatus')
def HandleGetStatus(self, ackdata):
    """
    Get the status of sent message by its ackdata (hex encoded).
    Returns one of these strings: notfound, msgqueued,
    broadcastqueued, broadcastsent, doingpubkeypow, awaitingpubkey,
    doingmsgpow, forcepow, msgsent, msgsentnoackexpected or ackreceived.
    """
@command('addSubscription')
def HandleAddSubscription(self, address, label=''):
    """Subscribe to the address. label must be base64 encoded."""

@command('deleteSubscription')
def HandleDeleteSubscription(self, address):
    """
    Unsubscribe from the address. The program does not check whether
    you were subscribed in the first place.
    """

@command('listSubscriptions')
def ListSubscriptions(self):
    """
    Returns dict with a list of all subscriptions
    in the *subscriptions* key.
    """
@command('disseminatePreEncryptedMsg')
def HandleDisseminatePreEncryptedMsg(
    self, encryptedPayload, requiredAverageProofOfWorkNonceTrialsPerByte,
        requiredPayloadLengthExtraBytes):
    """Handle a request to disseminate an encrypted message"""

@command('trashSentMessageByAckData')
def HandleTrashSentMessageByAckDAta(self, ackdata):
    """Trash a sent message by ackdata (hex encoded)"""

@command('disseminatePubkey')
def HandleDissimatePubKey(self, payload):
    """Handle a request to disseminate a public key"""

@command(
    'getMessageDataByDestinationHash', 'getMessageDataByDestinationTag')
def HandleGetMessageDataByDestinationHash(self, requestedHash):
    """Handle a request to get message data by destination hash"""

@command('clientStatus')
def HandleClientStatus(self):
    """
    Returns the bitmessage status as dict with keys *networkConnections*,
    *numberOfMessagesProcessed*, *numberOfBroadcastsProcessed*,
    *numberOfPubkeysProcessed*, *pendingDownload*, *networkStatus*,
    *softwareName*, *softwareVersion*. *networkStatus* will be one of
    these strings: "notConnected",
    "connectedButHaveNotReceivedIncomingConnections",
    or "connectedAndReceivingIncomingConnections".
    """
@command('helloWorld')
def HandleHelloWorld(self, a, b):
    """Test two string params"""

@command('add')
def HandleAdd(self, a, b):
    """Test two numeric params"""

@command('statusBar')
def HandleStatusBar(self, message):
    """Update GUI statusbar message"""

@command('deleteAndVacuum')
def HandleDeleteAndVacuum(self):
    """Cleanup trashes and vacuum messages database"""

@command('shutdown')
def HandleShutdown(self):
    """Shutdown the bitmessage. Returns 'done'."""

[BotMaster3000]

There also is the API-Reference, which might have some more info on some of the required Types etc:
https://wiki.bitmessage.org/index.php/API_Reference