To begin I cite the Wikipedia about the definition of API:
In computer programming, an application programming interface (API) is
a set of routines, protocols, and tools for building software
applications. An API expresses a software component in terms of its
operations, inputs, outputs, and underlying types.
So, the if file format describes how operations are executed and/or transfers data, it is part of an API. To make the API complete you still need a mechanism to exchange the files.
One common example that practically fits your description are common web-APIs. A file (usually XML or JSON) is sent to the webservice in form of a POST-REQUEST and the result is sent back by HTTP status codes and another file as response. This more or less fits your description given in the question (with one exception I go into soon) and it is an API.
The one thing in your question that isn't fitting is:
The existence of the file is the only form of linkage between the two.
An API always needs a defined way to exchange the file. In the webservice-example it is the HTTP-connection. But it may also be as simple, as writing the file into a predefined directory that the other program monitors. Either way, without the definition of the communication-mechanism the file-format alone can be never enough, but the communication can be extremely simple (and therefore many people forget about it).
As you mention in your question that one of the programs is a GPL-licensed program, I assume your question targets in the direction of the usage of such an file-API makes the other program a derivate and therefore it has to be licensed under GPL too, This makes also sense, because without it, the question has no connection to open-source.
So to answer the implicit question: No, the simple usage of an API isn't creating a derivate and therefore triggering the GPL. The GPL is talking about linking the software, not about using an API. If linking is enough to create a derivate work is discussed, and not everyone shares the point of view of the FSF. But even the FSF stops at linking and I know of no one, who interprets the formation of a derivate even more inclusive than the FSF.
The FSF addresses this distinction in their FAQ:
If the modules are included in the same executable file, they are
definitely combined in one program. If modules are designed to run
linked together in a shared address space, that almost surely means
combining them into one program.
By contrast, pipes, sockets and command-line arguments are
communication mechanisms normally used between two separate programs.
So when they are used for communication, the modules normally are
separate programs. But if the semantics of the communication are
intimate enough, exchanging complex internal data structures, that too
could be a basis to consider the two parts as combined into a larger
As you can see, transferring files via Sockets or Pipes (including STDOUT and STDIN), does not qualify as combination into a larger program. The file could be also exchanged via a command-line parameter pointing to the position the file is saved. That is even more indirectly.
The FAQ has some consideration into 'complex internal data structures', so that could be an argument that both programs are combined. For a file with a defined content (needed for it being an API), we can argue against it being 'internal'. It's pretty obvious for text-files, that you defined in the question, internal data-structures (and that includes strings) have to be converted to fit into text-files. Strings have a length-integer at the beginning (seldom in use today) or are ended by a null-byte (more common). In a test-file strings are separated by a defined separator, commonly a line-break. That alone makes the data no longer internal.
But even for a binary file some sort of conversion is needed. Different compilers can lead to different memory-layout of data-structures: little vs. big-endian for multi-byte datatypes, direction for arrays, padding bytes included by the compiler, length of integers. If the file is part of an API all this has to be defined, meaning on a different platform with different compilers a conversion from the internal data-structure is needed.