According to the GPL, you can distribute GPL programs together with closed source programs as long as the programs are separate. The GPL calls such a collection an "aggregate":
A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an “aggregate” if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate.
Emphasis added. https://www.gnu.org/licenses/gpl-3.0.html
"I'm not linking with the GPL program; I'm just using sockets or IPC"
[We want] to implement some kind of API between [the GPL program and our closed-source app], where [the GPL program] acts more like a client, so closed-source app should provide an API. As far as I understand, implementing any program-level API like statically or dynamically linked library oblige to open service-providing application code.
Conventional Internet wisdom on this topic seems to go something like this: "if you statically link with an LGPL program, your program must also be (L)GPL'ed. If you dynamically link with an LGPL program, your program can remain closed source. If you statically or dynamically link with a GPL program, your program must also be GPL'ed."
However, this is not at all what the GPL says and it is unlikely that a judge would see it this way if there is actually a legal dispute. Section 5 of the GPL covers your main obligation of what you must do when you distribute GPL programs:
You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged.
Emphasis added. If the program is LGPL'ed, or if it is GPL with a linking exception, then there is extra language in the license which clarifies in what circumstances you are allowed to combine the program with yours, without needing to license your program in the same way. However, for the ordinary GPL, the above paragraph is what you need to scrutinize.
So the real question is whether your final product will ultimately be considered as one work or separate works. This is true whether your product is packaged as two executables that use IPC with each other, or one executable plus some DLLs, one executable with statically linked code, or in some other way. The FSF tried to answer this in their FAQ:
What constitutes combining two parts into one program? This is a legal question, which ultimately judges will decide. We believe that a proper criterion depends both on the mechanism of communication (exec, pipes, rpc, function calls within a shared address space, etc.) and the semantics of the communication (what kinds of information are interchanged).
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 program.
Emphasis added. https://www.gnu.org/licenses/old-licenses/gpl-2.0-faq.html#MereAggregation
Note that this explanation is from the FAQ, not the GPL itself. The FAQ also explicitly says that it is an unanswered question as to what will actually be considered a combined work.
Rather than guessing what a judge may decide, you should first think about how the copyright holder of the GPL program you are redistributing is likely to interpret what you've done. If the copyright holder considers that your product is an entire work combined with his, and sees that you have not fulfilled your license obligations by releasing your source code as well, he has a copyright infringement claim against you and could take legal action. Then you will be in the position of needing to convince a judge that you were allowed to do what you did. In the worst case, you may even be ordered to release your source code, despite your claim that "[there is] no possibility to open [our] code."
From your description, it sounds like you already suspect that combining your closed source program with the GPL program may not be legally possible in the 'conventional' way (via static or dynamic linking), so you are looking for a workaround. If your workaround is to first add on an IPC interface to the GPL program, then add on a compatible IPC interface to your closed source program, then package them together and ship it to customers as a product and say actually, these are two separate programs, so we don't need to supply you the source code to our closed source part, that would not look good to me. It would look like you are purposefully trying to circumvent the license requirements of the GPL program to your own advantage and the disadvantage of the copyright holder of the GPL program. Why is it a disadvantage to the GPL program's copyright holder? Because many software authors license their programs under the GPL specifically to encourage companies to do the same. I.e. "You may copy our code as long as you release yours as well."
On the other hand, if the GPL program already has an IPC interface, and the copyright holder intends for it to be used as a service to other programs via an IPC mechanism, and you are simply using this program in the way it was intended to be used by calling it from a separate program, you can make a good case that they are in fact separate programs and constitute a "mere aggregation" as defined by the GPL. Commercial Linux distributors do this, for example, when they distribute closed source programs for Linux in combination with the Linux kernel itself, although Linux is GPL licensed. Note that the communication between an application and an operating system kernel can actually be quite intimate, but operating system kernels in general and Linux in particular was designed to supply such services to other programs; no one is claiming that a closed source program is a combined work of Linux or "by its nature an extension of [Linux]" simply because it runs under Linux and/or because it performs intimate communication with Linux.
Related questions and answers
Calling GPL'd programs from a shell script
What are the arguments for considering dynamic links to constitute derivative works?
