Lightning Labs Lightning API

swagger: '2.0'
info:
  title: Labs LND Lightning API
  description: REST API for the Lightning Network Daemon (lnd) by Lightning Labs, providing programmatic access to Lightning Network nodes for sending and receiving Bitcoin payments, channel management, wallet operations, and routing.
  version: 1.0.0
consumes:
- application/json
produces:
- application/json
tags:
- name: Lightning
paths:
  /v1/aliases/list:
    get:
      summary: 'lncli: `listaliases`

        ListAliases returns the set of all aliases that have ever existed with

        their confirmed SCID (if it exists) and/or the base SCID (in the case of

        zero conf).'
      operationId: Lightning_ListAliases
      responses:
        '200':
          description: A successful response.
          schema:
            $ref: '#/definitions/lnrpcListAliasesResponse'
        default:
          description: An unexpected error response.
          schema:
            $ref: '#/definitions/rpcStatus'
      tags:
      - Lightning
  /v1/balance/blockchain:
    get:
      summary: 'lncli: `walletbalance`

        WalletBalance returns total unspent outputs(confirmed and unconfirmed), all

        confirmed unspent outputs and all unconfirmed unspent outputs under control

        of the wallet.'
      operationId: Lightning_WalletBalance
      responses:
        '200':
          description: A successful response.
          schema:
            $ref: '#/definitions/lnrpcWalletBalanceResponse'
        default:
          description: An unexpected error response.
          schema:
            $ref: '#/definitions/rpcStatus'
      parameters:
      - name: account
        description: 'The wallet account the balance is shown for.

          If this is not specified, the balance of the "default" account is shown.'
        in: query
        required: false
        type: string
      - name: min_confs
        description: 'The minimum number of confirmations each one of your outputs used for the

          funding transaction must satisfy. If this is not specified, the default

          value of 1 is used.'
        in: query
        required: false
        type: integer
        format: int32
      tags:
      - Lightning
  /v1/balance/channels:
    get:
      summary: 'lncli: `channelbalance`

        ChannelBalance returns a report on the total funds across all open channels,

        categorized in local/remote, pending local/remote and unsettled local/remote

        balances.'
      operationId: Lightning_ChannelBalance
      responses:
        '200':
          description: A successful response.
          schema:
            $ref: '#/definitions/lnrpcChannelBalanceResponse'
        default:
          description: An unexpected error response.
          schema:
            $ref: '#/definitions/rpcStatus'
      tags:
      - Lightning
  /v1/channels:
    get:
      summary: 'lncli: `listchannels`

        ListChannels returns a description of all the open channels that this node

        is a participant in.'
      operationId: Lightning_ListChannels
      responses:
        '200':
          description: A successful response.
          schema:
            $ref: '#/definitions/lnrpcListChannelsResponse'
        default:
          description: An unexpected error response.
          schema:
            $ref: '#/definitions/rpcStatus'
      parameters:
      - name: active_only
        in: query
        required: false
        type: boolean
      - name: inactive_only
        in: query
        required: false
        type: boolean
      - name: public_only
        in: query
        required: false
        type: boolean
      - name: private_only
        in: query
        required: false
        type: boolean
      - name: peer
        description: 'Filters the response for channels with a target peer''s pubkey. If peer is

          empty, all channels will be returned.'
        in: query
        required: false
        type: string
        format: byte
      - name: peer_alias_lookup
        description: 'Informs the server if the peer alias lookup per channel should be

          enabled. It is turned off by default in order to avoid degradation of

          performance for existing clients.'
        in: query
        required: false
        type: boolean
      tags:
      - Lightning
    post:
      summary: 'OpenChannelSync is a synchronous version of the OpenChannel RPC call. This

        call is meant to be consumed by clients to the REST proxy. As with all

        other sync calls, all byte slices are intended to be populated as hex

        encoded strings.'
      operationId: Lightning_OpenChannelSync
      responses:
        '200':
          description: A successful response.
          schema:
            $ref: '#/definitions/lnrpcChannelPoint'
        default:
          description: An unexpected error response.
          schema:
            $ref: '#/definitions/rpcStatus'
      parameters:
      - name: body
        in: body
        required: true
        schema:
          $ref: '#/definitions/lnrpcOpenChannelRequest'
      tags:
      - Lightning
  /v1/channels/abandon/{channel_point.funding_txid_str}/{channel_point.output_index}:
    delete:
      summary: 'lncli: `abandonchannel`

        AbandonChannel removes all channel state from the database except for a

        close summary. This method can be used to get rid of permanently unusable

        channels due to bugs fixed in newer versions of lnd. This method can also be

        used to remove externally funded channels where the funding transaction was

        never broadcast. Only available for non-externally funded channels in dev

        build.'
      operationId: Lightning_AbandonChannel
      responses:
        '200':
          description: A successful response.
          schema:
            $ref: '#/definitions/lnrpcAbandonChannelResponse'
        default:
          description: An unexpected error response.
          schema:
            $ref: '#/definitions/rpcStatus'
      parameters:
      - name: channel_point.funding_txid_str
        description: 'Hex-encoded string representing the byte-reversed hash of the funding

          transaction.'
        in: path
        required: true
        type: string
      - name: channel_point.output_index
        description: The index of the output of the funding transaction
        in: path
        required: true
        type: integer
        format: int64
      - name: channel_point.funding_txid_bytes
        description: 'Txid of the funding transaction. When using REST, this field must be

          encoded as base64.'
        in: query
        required: false
        type: string
        format: byte
      - name: pending_funding_shim_only
        in: query
        required: false
        type: boolean
      - name: i_know_what_i_am_doing
        description: 'Override the requirement for being in dev mode by setting this to true and

          confirming the user knows what they are doing and this is a potential foot

          gun to lose funds if used on active channels.'
        in: query
        required: false
        type: boolean
      tags:
      - Lightning
  /v1/channels/acceptor:
    post:
      summary: 'ChannelAcceptor dispatches a bi-directional streaming RPC in which

        OpenChannel requests are sent to the client and the client responds with

        a boolean that tells LND whether or not to accept the channel. This allows

        node operators to specify their own criteria for accepting inbound channels

        through a single persistent connection.'
      operationId: Lightning_ChannelAcceptor
      responses:
        '200':
          description: A successful response.(streaming responses)
          schema:
            type: object
            properties:
              result:
                $ref: '#/definitions/lnrpcChannelAcceptRequest'
              error:
                $ref: '#/definitions/rpcStatus'
            title: Stream result of lnrpcChannelAcceptRequest
        default:
          description: An unexpected error response.
          schema:
            $ref: '#/definitions/rpcStatus'
      parameters:
      - name: body
        description: ' (streaming inputs)'
        in: body
        required: true
        schema:
          $ref: '#/definitions/lnrpcChannelAcceptResponse'
      tags:
      - Lightning
  /v1/channels/backup:
    get:
      summary: 'ExportAllChannelBackups returns static channel backups for all existing

        channels known to lnd. A set of regular singular static channel backups for

        each channel are returned. Additionally, a multi-channel backup is returned

        as well, which contains a single encrypted blob containing the backups of

        each channel.'
      operationId: Lightning_ExportAllChannelBackups
      responses:
        '200':
          description: A successful response.
          schema:
            $ref: '#/definitions/lnrpcChanBackupSnapshot'
        default:
          description: An unexpected error response.
          schema:
            $ref: '#/definitions/rpcStatus'
      tags:
      - Lightning
  /v1/channels/backup/restore:
    post:
      summary: 'lncli: `restorechanbackup`

        RestoreChannelBackups accepts a set of singular channel backups, or a

        single encrypted multi-chan backup and attempts to recover any funds

        remaining within the channel. If we are able to unpack the backup, then the

        new channel will be shown under listchannels, as well as pending channels.'
      operationId: Lightning_RestoreChannelBackups
      responses:
        '200':
          description: A successful response.
          schema:
            $ref: '#/definitions/lnrpcRestoreBackupResponse'
        default:
          description: An unexpected error response.
          schema:
            $ref: '#/definitions/rpcStatus'
      parameters:
      - name: body
        in: body
        required: true
        schema:
          $ref: '#/definitions/lnrpcRestoreChanBackupRequest'
      tags:
      - Lightning
  /v1/channels/backup/subscribe:
    get:
      summary: 'SubscribeChannelBackups allows a client to sub-subscribe to the most up to

        date information concerning the state of all channel backups. Each time a

        new channel is added, we return the new set of channels, along with a

        multi-chan backup containing the backup info for all channels. Each time a

        channel is closed, we send a new update, which contains new new chan back

        ups, but the updated set of encrypted multi-chan backups with the closed

        channel(s) removed.'
      operationId: Lightning_SubscribeChannelBackups
      responses:
        '200':
          description: A successful response.(streaming responses)
          schema:
            type: object
            properties:
              result:
                $ref: '#/definitions/lnrpcChanBackupSnapshot'
              error:
                $ref: '#/definitions/rpcStatus'
            title: Stream result of lnrpcChanBackupSnapshot
        default:
          description: An unexpected error response.
          schema:
            $ref: '#/definitions/rpcStatus'
      tags:
      - Lightning
  /v1/channels/backup/verify:
    post:
      summary: 'lncli: `verifychanbackup`

        VerifyChanBackup allows a caller to verify the integrity of a channel backup

        snapshot. This method will accept either a packed Single or a packed Multi.

        Specifying both will result in an error.'
      operationId: Lightning_VerifyChanBackup
      responses:
        '200':
          description: A successful response.
          schema:
            $ref: '#/definitions/lnrpcVerifyChanBackupResponse'
        default:
          description: An unexpected error response.
          schema:
            $ref: '#/definitions/rpcStatus'
      parameters:
      - name: body
        in: body
        required: true
        schema:
          $ref: '#/definitions/lnrpcChanBackupSnapshot'
      tags:
      - Lightning
  /v1/channels/backup/{chan_point.funding_txid_str}/{chan_point.output_index}:
    get:
      summary: 'lncli: `exportchanbackup`

        ExportChannelBackup attempts to return an encrypted static channel backup

        for the target channel identified by it channel point. The backup is

        encrypted with a key generated from the aezeed seed of the user. The

        returned backup can either be restored using the RestoreChannelBackup

        method once lnd is running, or via the InitWallet and UnlockWallet methods

        from the WalletUnlocker service.'
      operationId: Lightning_ExportChannelBackup
      responses:
        '200':
          description: A successful response.
          schema:
            $ref: '#/definitions/lnrpcChannelBackup'
        default:
          description: An unexpected error response.
          schema:
            $ref: '#/definitions/rpcStatus'
      parameters:
      - name: chan_point.funding_txid_str
        description: 'Hex-encoded string representing the byte-reversed hash of the funding

          transaction.'
        in: path
        required: true
        type: string
      - name: chan_point.output_index
        description: The index of the output of the funding transaction
        in: path
        required: true
        type: integer
        format: int64
      - name: chan_point.funding_txid_bytes
        description: 'Txid of the funding transaction. When using REST, this field must be

          encoded as base64.'
        in: query
        required: false
        type: string
        format: byte
      tags:
      - Lightning
  /v1/channels/batch:
    post:
      summary: 'lncli: `batchopenchannel`

        BatchOpenChannel attempts to open multiple single-funded channels in a

        single transaction in an atomic way. This means either all channel open

        requests succeed at once or all attempts are aborted if any of them fail.

        This is the safer variant of using PSBTs to manually fund a batch of

        channels through the OpenChannel RPC.'
      operationId: Lightning_BatchOpenChannel
      responses:
        '200':
          description: A successful response.
          schema:
            $ref: '#/definitions/lnrpcBatchOpenChannelResponse'
        default:
          description: An unexpected error response.
          schema:
            $ref: '#/definitions/rpcStatus'
      parameters:
      - name: body
        in: body
        required: true
        schema:
          $ref: '#/definitions/lnrpcBatchOpenChannelRequest'
      tags:
      - Lightning
  /v1/channels/closed:
    get:
      summary: 'lncli: `closedchannels`

        ClosedChannels returns a description of all the closed channels that

        this node was a participant in.'
      operationId: Lightning_ClosedChannels
      responses:
        '200':
          description: A successful response.
          schema:
            $ref: '#/definitions/lnrpcClosedChannelsResponse'
        default:
          description: An unexpected error response.
          schema:
            $ref: '#/definitions/rpcStatus'
      parameters:
      - name: cooperative
        in: query
        required: false
        type: boolean
      - name: local_force
        in: query
        required: false
        type: boolean
      - name: remote_force
        in: query
        required: false
        type: boolean
      - name: breach
        in: query
        required: false
        type: boolean
      - name: funding_canceled
        in: query
        required: false
        type: boolean
      - name: abandoned
        in: query
        required: false
        type: boolean
      tags:
      - Lightning
  /v1/channels/pending:
    get:
      summary: 'lncli: `pendingchannels`

        PendingChannels returns a list of all the channels that are currently

        considered "pending". A channel is pending if it has finished the funding

        workflow and is waiting for confirmations for the funding txn, or is in the

        process of closure, either initiated cooperatively or non-cooperatively.'
      operationId: Lightning_PendingChannels
      responses:
        '200':
          description: A successful response.
          schema:
            $ref: '#/definitions/lnrpcPendingChannelsResponse'
        default:
          description: An unexpected error response.
          schema:
            $ref: '#/definitions/rpcStatus'
      parameters:
      - name: include_raw_tx
        description: 'Indicates whether to include the raw transaction hex for

          waiting_close_channels.'
        in: query
        required: false
        type: boolean
      tags:
      - Lightning
  /v1/channels/stream:
    post:
      summary: 'lncli: `openchannel`

        OpenChannel attempts to open a singly funded channel specified in the

        request to a remote peer. Users are able to specify a target number of

        blocks that the funding transaction should be confirmed in, or a manual fee

        rate to us for the funding transaction. If neither are specified, then a

        lax block confirmation target is used. Each OpenStatusUpdate will return

        the pending channel ID of the in-progress channel. Depending on the

        arguments specified in the OpenChannelRequest, this pending channel ID can

        then be used to manually progress the channel funding flow.'
      operationId: Lightning_OpenChannel
      responses:
        '200':
          description: A successful response.(streaming responses)
          schema:
            type: object
            properties:
              result:
                $ref: '#/definitions/lnrpcOpenStatusUpdate'
              error:
                $ref: '#/definitions/rpcStatus'
            title: Stream result of lnrpcOpenStatusUpdate
        default:
          description: An unexpected error response.
          schema:
            $ref: '#/definitions/rpcStatus'
      parameters:
      - name: body
        in: body
        required: true
        schema:
          $ref: '#/definitions/lnrpcOpenChannelRequest'
      tags:
      - Lightning
  /v1/channels/subscribe:
    get:
      summary: 'SubscribeChannelEvents creates a uni-directional stream from the server to

        the client in which any updates relevant to the state of the channels are

        sent over. Events include new active channels, inactive channels, and closed

        channels.'
      operationId: Lightning_SubscribeChannelEvents
      responses:
        '200':
          description: A successful response.(streaming responses)
          schema:
            type: object
            properties:
              result:
                $ref: '#/definitions/lnrpcChannelEventUpdate'
              error:
                $ref: '#/definitions/rpcStatus'
            title: Stream result of lnrpcChannelEventUpdate
        default:
          description: An unexpected error response.
          schema:
            $ref: '#/definitions/rpcStatus'
      tags:
      - Lightning
  /v1/channels/transaction-stream:
    post:
      summary: 'lncli: `sendpayment`

        Deprecated, use routerrpc.SendPaymentV2. SendPayment dispatches a

        bi-directional streaming RPC for sending payments through the Lightning

        Network. A single RPC invocation creates a persistent bi-directional

        stream allowing clients to rapidly send payments through the Lightning

        Network with a single persistent connection.'
      operationId: Lightning_SendPayment
      responses:
        '200':
          description: A successful response.(streaming responses)
          schema:
            type: object
            properties:
              result:
                $ref: '#/definitions/lnrpcSendResponse'
              error:
                $ref: '#/definitions/rpcStatus'
            title: Stream result of lnrpcSendResponse
        default:
          description: An unexpected error response.
          schema:
            $ref: '#/definitions/rpcStatus'
      parameters:
      - name: body
        description: ' (streaming inputs)'
        in: body
        required: true
        schema:
          $ref: '#/definitions/lnrpcSendRequest'
      tags:
      - Lightning
  /v1/channels/transactions:
    post:
      summary: 'Deprecated, use routerrpc.SendPaymentV2. SendPaymentSync is the synchronous

        non-streaming version of SendPayment. This RPC is intended to be consumed by

        clients of the REST proxy. Additionally, this RPC expects the destination''s

        public key and the payment hash (if any) to be encoded as hex strings.'
      operationId: Lightning_SendPaymentSync
      responses:
        '200':
          description: A successful response.
          schema:
            $ref: '#/definitions/lnrpcSendResponse'
        default:
          description: An unexpected error response.
          schema:
            $ref: '#/definitions/rpcStatus'
      parameters:
      - name: body
        in: body
        required: true
        schema:
          $ref: '#/definitions/lnrpcSendRequest'
      tags:
      - Lightning
  /v1/channels/transactions/route:
    post:
      summary: 'Deprecated, use routerrpc.SendToRouteV2. SendToRouteSync is a synchronous

        version of SendToRoute. It Will block until the payment either fails or

        succeeds.'
      operationId: Lightning_SendToRouteSync
      responses:
        '200':
          description: A successful response.
          schema:
            $ref: '#/definitions/lnrpcSendResponse'
        default:
          description: An unexpected error response.
          schema:
            $ref: '#/definitions/rpcStatus'
      parameters:
      - name: body
        in: body
        required: true
        schema:
          $ref: '#/definitions/lnrpcSendToRouteRequest'
      tags:
      - Lightning
  /v1/channels/{channel_point.funding_txid_str}/{channel_point.output_index}:
    delete:
      summary: 'lncli: `closechannel`

        CloseChannel attempts to close an active channel identified by its channel

        outpoint (ChannelPoint). The actions of this method can additionally be

        augmented to attempt a force close after a timeout period in the case of an

        inactive peer. If a non-force close (cooperative closure) is requested,

        then the user can specify either a target number of blocks until the

        closure transaction is confirmed, or a manual fee rate. If neither are

        specified, then a default lax, block confirmation target is used.'
      operationId: Lightning_CloseChannel
      responses:
        '200':
          description: A successful response.(streaming responses)
          schema:
            type: object
            properties:
              result:
                $ref: '#/definitions/lnrpcCloseStatusUpdate'
              error:
                $ref: '#/definitions/rpcStatus'
            title: Stream result of lnrpcCloseStatusUpdate
        default:
          description: An unexpected error response.
          schema:
            $ref: '#/definitions/rpcStatus'
      parameters:
      - name: channel_point.funding_txid_str
        description: 'Hex-encoded string representing the byte-reversed hash of the funding

          transaction.'
        in: path
        required: true
        type: string
      - name: channel_point.output_index
        description: The index of the output of the funding transaction
        in: path
        required: true
        type: integer
        format: int64
      - name: channel_point.funding_txid_bytes
        description: 'Txid of the funding transaction. When using REST, this field must be

          encoded as base64.'
        in: query
        required: false
        type: string
        format: byte
      - name: force
        description: 'If true, then the channel will be closed forcibly. This means the

          current commitment transaction will be signed and broadcast.'
        in: query
        required: false
        type: boolean
      - name: target_conf
        description: 'The target number of blocks that the closure transaction should be

          confirmed by.'
        in: query
        required: false
        type: integer
        format: int32
      - name: sat_per_byte
        description: 'Deprecated, use sat_per_vbyte.

          A manual fee rate set in sat/vbyte that should be used when crafting the

          closure transaction.'
        in: query
        required: false
        type: string
        format: int64
      - name: delivery_address
        description: 'An optional address to send funds to in the case of a cooperative close.

          If the channel was opened with an upfront shutdown script and this field

          is set, the request to close will fail because the channel must pay out

          to the upfront shutdown addresss.'
        in: query
        required: false
        type: string
      - name: sat_per_vbyte
        description: 'A manual fee rate set in sat/vbyte that should be used when crafting the

          closure transaction.'
        in: query
        required: false
        type: string
        format: uint64
      - name: max_fee_per_vbyte
        description: 'The maximum fee rate the closer is willing to pay.


          NOTE: This field is only respected if we''re the initiator of the channel.'
        in: query
        required: false
        type: string
        format: uint64
      - name: no_wait
        description: 'If true, then the rpc call will not block while it awaits a closing txid

          to be broadcasted to the mempool. To obtain the closing tx one has to

          listen to the stream for the particular updates. Moreover if a coop close

          is specified and this flag is set to true the coop closing flow will be

          initiated even if HTLCs are active on the channel. The channel will wait

          until all HTLCs are resolved and then start the coop closing process. The

          channel will be disabled in the meantime and will disallow any new HTLCs.'
        in: query
        required: false
        type: boolean
      tags:
      - Lightning
  /v1/chanpolicy:
    post:
      summary: 'lncli: `updatechanpolicy`

        UpdateChannelPolicy allows the caller to update the fee schedule and

        channel policies for all channels globally, or a particular channel.'
      operationId: Lightning_UpdateChannelPolicy
      responses:
        '200':
          description: A successful response.
          schema:
            $ref: '#/definitions/lnrpcPolicyUpdateResponse'
        default:
          description: An unexpected error response.
          schema:
            $ref: '#/definitions/rpcStatus'
      parameters:
      - name: body
        in: body
        required: true
        schema:
          $ref: '#/definitions/lnrpcPolicyUpdateRequest'
      tags:
      - Lightning
  /v1/custommessage:
    post:
      summary: 'lncli: `sendcustom`

        SendCustomMessage sends a custom peer message.'
      operationId: Lightning_SendCustomMessage
      responses:
        '200':
          description: A successful response.
          schema:
            $ref: '#/definitions/lnrpcSendCustomMessageResponse'
        default:
          description: An unexpected error response.
          schema:
            $ref: '#/definitions/rpcStatus'
      parameters:
      - name: body
        in: body
        required: true
        schema:
          $ref: '#/definitions/lnrpcSendCustomMessageRequest'
      tags:
      - Lightning
  /v1/custommessage/subscribe:
    get:
      summary: 'lncli: `subscribecustom`

        SubscribeCustomMessages subscribes to a stream of incoming custom peer

        messages.'
      description: 'To include messages with type outside of the custom range (>= 32768) lnd

        needs to be compiled with  the `dev` build tag, and the message type to

        override should be specified in lnd''s experimental protocol configuration.'
      operationId: Lightning_SubscribeCustomMessages
      responses:
        '200':
          description: A successful response.(streaming responses)
          schema:
            type: object
            properties:
              result:
                $ref: '#/definitions/lnrpcCustomMessage'
              error:
                $ref: '#/definitions/rpcStatus'
            title: Stream result of lnrpcCustomMessage
        default:
          description: An unexpected error response.
          schema:
            $ref: '#/definitions/rpcStatus'
      tags:
      - Lightning
  /v1/debuglevel:
    post:
      summary: 'lncli: `debuglevel`

        DebugLevel allows a caller to programmatically set the logging verbosity of

        lnd. The logging can be targeted according to a coarse daemon-wide logging

        level, or in a granular fashion to specify the logging for a target

        sub-system.'
      operationId: Lightning_DebugLevel
      responses:
        '200':
          description: A successful response.
          schema:
            $ref: '#/definitions/lnrpcDebugLevelResponse'
        default:
          description: An unexpected error response.
          schema:
            $ref: '#/definitions/rpcStatus'
      parameters:
      - name: body
        in: body
        required: true
        schema:
          $ref: '#/definitions/lnrpcDebugLevelRequest'
      tags:
      - Lightning
  /v1/fees:
    get:
      summary: 'lncli: `feereport`

        FeeReport allows the caller to obtain a report detailing the current fee

        schedule enforced by the node globally for each channel.'
      operationId: Lightning_FeeReport
      responses:
        '200':
          description: A successful response.
          schema:
            $ref: '#/definitions/lnrpcFeeReportResponse'
        default:
          description: An unexpected error response.
          schema:
            $ref: '#/definitions/rpcStatus'
      tags:
      - Lightning
  /v1/funding/step:
    post:
      summary: 'FundingStateStep is an advanced funding related call that allows the caller

        to either execute some preparatory steps for a funding workflow, or

        manually progress a funding workflow. The primary way a funding flow is

        identified is via its pending channel ID. As an example, this method can be

        used to specify that we''re expecting a funding flow for a particular

        pending channel ID, for which we need to use specific parameters.

        Alternatively, this can be used to interactively drive PSBT signing for

        funding for partially complete funding transactions.'
      operationId: Lightning_FundingStateStep
      responses:
        '200':
          description: A successful response.
          schema:
            $ref: '#/definitions/lnrpcFundingStateStepResp'
        default:
          description: An unexpected error response.
          schema:
            $ref: '#/definitions/rpcStatus'
      parameters:
      - name: body
        in: body
        required: true
        schema:
          $ref: '#/definitions/lnrpcFundingTransitionMsg'
      tags:
      - Lightning
  /v1/getdebuginfo:
    get:
      summary: 'lncli: ''getdebuginfo''

        GetDebugInfo returns debug information concerning the state of the daemon

        and its subsystems. This includes the full configuration and the latest log

        entries from the log file.'
      operationId: Lightning_GetDebugInfo
      responses:
        '200':
          description: A successful response.
          schema:
            $ref: '#/definitions/lnrpcGetDebugInfoResponse'
        default:
          description: An unexpected error response.
          schema:
            $ref: '#/definitions/rpcStatus'
      parameters:
      - name: include_log
        description: 'If set to true, the log file content will be included in the response.

          By default, only the config information is returned.'
        in: query
        required: false
        type: boolean
      tags:
      - Lightning
  /v1/getinfo:
    get:
      summary: 'lncli: `getinfo`

        GetInfo returns general information concerning the lightning node including

        it''s identity pubkey, alias, the chains it is connected to, and information

        concerning the number of open+pending channels.'
      operationId: Lightning_GetInfo
      responses:
        '200':
          description: A successful response.
          schema:
            $ref: '#/definitions/lnrpcGetInfoResponse'
        default:
          description: An unexpected error response.
          schema:
            $ref: '#/definitions/rpcStatus'
   

# --- truncated at 32 KB (262 KB total) ---
# Full source: https://raw.githubusercontent.com/api-evangelist/lightning-labs/refs/heads/main/openapi/lightning-labs-lightning-api-openapi.yml