Count words under subtree ignoring the properties drawer and the subheading

Question

How can we count the number of words inside a heading? (excluding the properties drawer and the actual heading title)

An example:

**Answer
:PROPERTIES:
:ID: <guid>
:END:
This is some text here

What I have been able to accomplish:

(org-id-goto "guid")
(org-mark-subtree)
(count-words (region-beginning) (region-end))

What I want is only counting This is some text here, not the entire heading, unlike what we get via the org-mark-subtree.

Edit: Let me perhaps describe my usecase a little more. What I am using org mode in this instance is for keeping track of word-limited essays, given a prompt. So my org file looks more like this:

 * DRAFTING Essay 1
 ** Prompt
    Describe a place in 60 words
 ** Answer
    It is very beautiful...

What I need is to count all words under the answer heading. Unable to find a way to do so, I created an ID so that I could use it to navigate, but that seems to add the overhead of the properties drawer. If I could find a way to only get the number of words, I can subtract the (in this case, fixed) number of words/characters taken by the heading and the properties drawer and get what I need.

Answer 1

Let the parser decide what real text, worthy to be word-counted, is.
You can use org-element-parse-headline and org-element-map for that purpose.

Below, there is an Elisp function org+-count-words-of-heading that demonstrates the principle.

Use it by putting point into the section where you want to count words and by M-x org+-count-words-of-heading. See the doc string of the function for more options.

(require 'cl-lib)
(require 'org-element)

(defun org-element-parse-headline (&optional granularity visible-only)
  "Parse current headline.
GRANULARITY and VISIBLE-ONLY are like the args of `org-element-parse-buffer'."
  (let ((level (org-current-level)))
    (org-element-map
    (org-element-parse-buffer granularity visible-only)
    'headline
      (lambda (el)
    (and
     (eq (org-element-property :level el) level)
     (<= (org-element-property :begin el) (point))
     (<= (point) (org-element-property :end el))
     el))
      nil 'first-match 'no-recursion)))

(cl-defun org+-count-words-of-heading (&key (worthy '(paragraph bold italic underline code footnote-reference link strike-through subscript superscript table table-row table-cell))
                        (no-recursion nil))
  "Count words in the section of the current heading.
WORTHY is a list of things worthy to be counted.
This list should at least include the symbols:
paragraph, bold, italic, underline and strike-through.

If NO-RECURSION is non-nil don't count the words in subsections."
  (interactive (and current-prefix-arg
            (list :no-recursion t)))
  (let ((word-count 0))
    (org-element-map
    (org-element-contents (org-element-parse-headline))
    '(paragraph table)
      (lambda (par)
    (org-element-map
        par
        worthy
        (lambda (el)
          (cl-incf
           word-count
           (cl-loop
        for txt in (org-element-contents el)
        when (eq (org-element-type txt) 'plain-text)
        sum
        (with-temp-buffer
          (insert txt)
          (count-words (point-min) (point-max))))
           ))))
      nil nil (and no-recursion 'headline)
      )
      (when (called-interactively-p 'any)
      (message "Word count in section: %d" word-count))
    word-count))